@omegup/msync 0.0.1

package/index.d.ts

@@ -0,0 +1,605 @@
+import { Timestamp, BSON, Db, Collection, MongoClient as MongoClient$1 } from 'mongodb';
+export { Collection, Timestamp } from 'mongodb';
+import * as bson from 'bson';
+
+type HasJob = {
+    job: object | undefined;
+};
+type Runner<T, Info extends HasJob> = Iterator<T, Info>;
+type NextFrame<T, Info> = PromiseLike<Frame<T, Info>>;
+type Frame<T, Info> = {
+    data: T;
+    info: Info;
+    cont: Iterator<T, Info>;
+};
+type IteratorResult<out T, out Info> = {
+    next: NextFrame<T, Info>;
+    stop: Iterator<T, Info>;
+    clear: () => Promise<void>;
+};
+type Iterator<out T, out Info> = () => IteratorResult<T, Info>;
+
+declare const PredicateRaw: unique symbol;
+type PredicateRaw = RawObj & {
+    [Type]?(x: typeof PredicateRaw): void;
+};
+declare const Predicate: unique symbol;
+interface Predicate<in V> {
+    [Type]?(x: typeof Predicate, _: V): void;
+    raw: PredicateRaw;
+    expr: <D extends O, C>(field: Field<D, V, C>) => Expr<boolean, D, C>;
+}
+
+declare class Field<in R, out V, in C = unknown> {
+    private field;
+    private raw;
+    private concat;
+    has<R extends O>(this: Field<R, V>, p: Predicate<V>): Query<R, C>;
+    has<R extends O, V>(this: Field<R, Arr<V>>, p: Predicate<V>): Query<R, C>;
+    private constructor();
+    static root: <T extends O>() => Field<T, T, unknown>;
+    static ctx: <T>() => <K extends string>(k: K) => Field<unknown, T, RORec<K, T>>;
+    of<V, K extends keyof V, _ extends 0 = 0>(this: Field<R, Arr<V>, C>, k: AsLiteral<K>): Field<R, Arr<V[K]>, C>;
+    of<V, K extends keyof V, _ extends 1 = 1>(this: Field<R, O<V>, C>, k: K): Field<R, V[K], C>;
+    of<V, K extends keyof V, I extends N = never, _ extends 2 = 2>(this: Field<R, Arr<V> | Undef<I>, C>, k: K): Field<R, Arr<V[K]> | I, C>;
+    of<V, K extends keyof V, I extends N = never, _ extends 3 = 3>(this: Field<R, O<V> | Undef<I>, C>, k: K): Field<R, V[K] | I, C>;
+    with<V, W, C2 = unknown, _ extends 0 = 0>(this: Field<R, O<V>, C>, k: Field<O<V>, W, C2>): Field<R, W, C & C2>;
+    with<V, W, C2 = unknown, _ extends 1 = 1>(this: Field<R, Arr<V>, C>, k: Field<O<V>, Arr<W> | O<W>, C2>): Field<R, Arr<W>, C & C2>;
+    with<V, W, I extends N = never, C2 = unknown, _ extends 2 = 2>(this: Field<R, O<V> | Undef<I>, C>, k: Field<O<V>, W, C2>): Field<R, W | I, C & C2>;
+    with<V, W, I extends N = never, C2 = unknown, _ extends 3 = 3>(this: Field<R, Arr<V> | Undef<I>, C>, k: Field<O<V>, Arr<W> | O<W>, C2>): Field<R, Arr<W> | I, C & C2>;
+    str(this: Field<R, V>): string;
+    private exprRaw;
+    expr<R, V, C = unknown>(this: Field<R, V, C>): Expr<V, R, C>;
+}
+declare const root: <T extends O>() => Field<T, T, unknown>;
+declare const ctx: <T>() => <K extends string>(k: K) => Field<unknown, T, RORec<K, T>>;
+
+declare const QueryRaw: unique symbol;
+type QueryRaw<T, C> = RawObj & {
+    [Type]?(x: typeof QueryRaw, y: T, c: C): void;
+};
+declare const Query: unique symbol;
+type Query<in T extends O, in C = unknown> = {
+    [Type]?(x: typeof Query, y: T, c: C): void;
+    raw: <DeltaT extends O>(f: Field<DeltaT, T>) => QueryRaw<DeltaT, C>;
+};
+
+declare const RawStage$1: unique symbol;
+type RawArr = readonly RawObj[];
+interface RawStages<out Q, in S extends Q, out R extends Q, in C = unknown, out M = number> extends RawArr {
+    [Type]?(_: typeof RawStage$1, source: S, ctx: C, q: Q): readonly [typeof RawStage$1, R, M, Q];
+}
+type FRawStages<out Q, in S extends Q & O, out R extends Q & O, in C = unknown, out M extends number = number> = <F extends HKT<O, O>>(f: <T extends O>() => Field<App<F, T>, T>) => RawStages<App<F, Q & O>, App<F, S>, App<F, R>, C, M>;
+type DeltaStages<out Q, in S extends Q & O, out R extends Q & O, in C = unknown> = {
+    delta: RawStages<unknown, Delta<S>, Delta<R>, C>;
+    raw: FRawStages<Q, S, R, C>;
+};
+type LinStages<out Q, in S extends Q, out R extends Q, in C = unknown> = {
+    lin: RawStages<Q, S, R, C, 1>;
+};
+type TStages<in out S, out Q, in out B extends Q, out R extends Q, M extends number = number> = {
+    coll: ReadonlyCollection<S>;
+    input: RawStages<unknown, S, B, unknown, M>;
+    exec: RawStages<Q, B, R, unknown, M>;
+};
+type Stages<out Q, out R extends Q, out SDom> = <E>(consume: <S extends SDom, B extends Q>(value: TStages<S, Q, B, R>) => E) => E;
+type StreamRunner<out V> = <Result>(input: RawStages<unknown, V, Result>) => Runner<readonly Result[], HasJob>;
+type SimpleStreamExecutionResult<out Q, out V extends Q> = {
+    readonly out: StreamRunner<V>;
+};
+type SnapshotStreamExecutionResult<out Q, out V extends Q> = {
+    readonly out: StreamRunner<Delta<V>>;
+    readonly stages: Stages<Before<Q>, Before<V>, UBefore<Q>>;
+};
+type Stream<out Q extends O, in out T extends Q, in out F extends HKT<[O, O]>, in out G extends HKT<[O, O, O]>> = <Q2 extends O, Result extends Q2>(input: App<G, [Q2 | T, T, Result]>) => App<F, [Q | Q2, Result]>;
+type TS = {
+    readonly touchedAt: Timestamp;
+};
+type Del = O<{
+    readonly deletedAt: Timestamp;
+} & ID & TS>;
+type D = O<{
+    readonly deletedAt?: Timestamp | null | undefined;
+} & ID>;
+type Model = D & TS;
+type OutInput<T, A = T | null> = ID & Rec<'after', A>;
+type BA = 'before' | 'after';
+type PreDelta<T, K extends BA = BA, E = unknown> = Rec<K, T> & E;
+type Delta<T, K extends BA = BA, E = ID> = PreDelta<T | null, K, E>;
+type Before<T> = PreDelta<T, 'before'>;
+type UBefore<T> = O & Partial<Delta<T | null, 'before'>>;
+type SnapshotStream<out Q extends O, in out T extends Q> = <Q2 extends O, Result extends Q2>(input: DeltaStages<Q2 | T, T, Result>) => SnapshotStreamExecutionResult<Q | Q2, Result>;
+
+declare const ExprRaw: unique symbol;
+type ExprRaw<out T, in Doc, in Ctx = unknown> = {
+    [Type]?(x: typeof ExprRaw): void;
+    [ExprRaw]?(doc: Doc, ctx: Ctx): T;
+    get: () => rawItem;
+};
+declare const Expr: unique symbol;
+type Expr<out T, in Doc, in Ctx = unknown> = {
+    [Type]?(x: typeof Expr): void;
+    [Expr]?(doc: Doc, ctx: Ctx): T;
+    raw: {
+        <DeltaD extends O, I extends U, C = unknown>(f: Field<DeltaD, Doc | Undef<I>, C>): ExprRaw<T | I, DeltaD, Ctx & C>;
+    };
+};
+type BoolExpr<in D1, in D2, in Ctx = unknown> = {
+    [Type]?(x: typeof Expr): void;
+    [Expr](doc: D1, ctx: Ctx): true;
+    [Expr](doc: D2, ctx: Ctx): false;
+    raw: {
+        <DeltaD extends O, I extends U, C = unknown>(f: Field<DeltaD, D1 | D2 | Undef<I>, C>): ExprRaw<boolean, DeltaD, Ctx & C>;
+        <DeltaD extends O, I extends U, C = unknown>(f: Field<DeltaD, D1 | Undef<I>, C>): ExprRaw<true, DeltaD, Ctx & C>;
+        <DeltaD extends O, I extends U, C = unknown>(f: Field<DeltaD, D2 | Undef<I>, C>): ExprRaw<false, DeltaD, Ctx & C>;
+    };
+};
+
+type ExactKeys<K extends string> = Exact<RORec<K, 1>, IdHKT>;
+type MapO<T, F extends HKT<StrKey<T>>> = MapOPart<T, F> & {
+    readonly [P: string]: readonly [StrKey<T>, unknown];
+};
+type MapOPart<T, F extends HKT<StrKey<T>>, K extends keyof T = StrKey<T>> = {
+    readonly [P in K]: readonly [P, App<F, P & string>];
+};
+type Exact<T, F extends HKT<T[StrKey<T>]>> = MapO<T, MappedHKT<T, F>>;
+interface MappedHKT<T, F extends HKT<T[StrKey<T>]>> extends HKT<StrKey<T>> {
+    readonly out: App<F, T[I<StrKey<T>, this>]>;
+}
+
+declare const AccumulatorRaw: unique symbol;
+interface AccumulatorRaw<in Doc, out T, in C = unknown> extends RawObj {
+    [Type](_: typeof AccumulatorRaw, source: Doc, ctx: C): readonly [typeof AccumulatorRaw, T];
+}
+interface AccumulatorHKT<T, C = unknown> extends HKT<unknown> {
+    readonly out: Accumulator<T, I<unknown, this>, C>;
+}
+type Accumulators<T, V extends RORec<string, jsonItem>, C = unknown> = Exact<V, AccumulatorHKT<T, C>>;
+interface DeltaAccumulatorHKT<T, C = unknown> extends HKT<unknown> {
+    readonly out: DeltaAccumulator<T, I<unknown, this>, C>;
+}
+type DeltaAccumulators<T, V extends RORec<string, jsonItem>, C = unknown> = Exact<V, DeltaAccumulatorHKT<T, C>>;
+declare const Accumulator: unique symbol;
+type Accumulator<in Doc, out T, in Ctx = unknown> = {
+    [Type]?(_: typeof Accumulator): typeof Accumulator;
+    raw: {
+        <DeltaD extends O, I extends U>(f: Field<DeltaD, Doc | Undef<I>>): AccumulatorRaw<T | I, DeltaD, Ctx>;
+    };
+};
+type Part<Doc> = Rec<'v', Doc> & RORec<'old', boolean>;
+type DeltaAccumulator<in out Doc, in out T, in out Ctx = unknown> = {
+    group: Accumulator<Part<Doc>, T, Ctx>;
+    merge: <D, C = Ctx>(a: Expr<T | N, D, C>, b: Expr<T, D, C>) => Expr<T, D, C>;
+};
+
+interface ExprHKT<D, C = unknown, F extends HKT = IdHKT> extends HKT<unknown> {
+    readonly out: Expr<App<F, I<unknown, this>>, D, C>;
+}
+type ExprsExact<T, D, C = unknown, F extends HKT = IdHKT> = Exact<T, ExprHKT<D, C, F>>;
+
+declare const Type: unique symbol;
+
+type U = undefined;
+type N = null | U;
+type jsonPrim = number | null | string | boolean | Timestamp | Date;
+type notObj = jsonPrim | U;
+type notArr = notObj | O;
+type jsonItem = unknown;
+type rawItem = jsonPrim | raw | U;
+type Undef<I extends N> = I | (I extends never ? I : notObj);
+declare const object: unique symbol;
+declare const array$1: unique symbol;
+type A = {
+    [Type]: typeof array$1;
+};
+type Arr<T, N extends number = number> = A & {
+    readonly [_ in N]: T;
+};
+type Obj = {
+    [Type]: typeof object;
+};
+type O<T = unknown> = Obj & T;
+type RORec<K extends keyof never, T = unknown> = {
+    readonly [P in K]: T;
+};
+type Rec<K extends string, T = unknown> = O<RORec<K, T>>;
+type O2 = readonly [O, O];
+type O3 = readonly [O, O, O];
+type ID = {
+    readonly _id: string;
+};
+type doc = O & ID;
+interface RawObj {
+    readonly [_: string]: rawItem | U;
+}
+type raw = readonly rawItem[] | RawObj;
+type StrKey<T> = string & keyof T;
+type Replace<R, V> = Omit<R, StrKey<V>> & V & O;
+type AsLiteral<T extends keyof any | boolean, V = NoUnion<T>> = T extends keyof any ? {} extends {
+    [K in T]: 1;
+} ? never : V : V;
+type NoUnion<T, V = T> = T extends unknown ? ([V] extends [T] ? T : never) : never;
+
+interface HKT<in Dom = unknown, out Im = unknown> {
+    readonly in: (x: Dom) => void;
+    readonly out: Im;
+}
+type App<F extends HKT<X>, X> = (F & {
+    readonly in: (x: X) => void;
+})['out'];
+type I<Dom, F extends HKT<Dom>> = F['in'] extends (x: infer X extends Dom) => void ? X : never;
+interface IdHKT<Dom = unknown> extends HKT<Dom> {
+    readonly out: I<Dom, this>;
+}
+type AppMap<F extends HKT<Dom>, X extends readonly Dom[], Dom = unknown> = readonly App<F, Dom>[] & {
+    [I in keyof X]: App<F, X[I]>;
+};
+type AppMapRW<F extends HKT<Dom>, X extends readonly Dom[], Dom = unknown> = App<F, Dom>[] & {
+    [I in keyof X]: App<F, X[I]>;
+};
+interface PromiseHKT<Dom = unknown> extends HKT<Dom> {
+    readonly out: PromiseLike<I<Dom, this>>;
+}
+
+type AsNum<R> = R extends `${infer A extends number}` ? A : never;
+type GetDom<Dom = unknown> = readonly [readonly Dom[], keyof any];
+declare global {
+    type Entry<T, K extends keyof T = keyof T> = readonly [string, T[string & K]] & {
+        [k in K]: readonly [string & k, T[k]];
+    }[K];
+    interface ObjectConstructor {
+        entries<T, _ = 0>(object?: T): readonly Entry<T>[];
+        fromEntries<T, _ = 0>(entries: readonly Entry<T>[]): T;
+        keys<T, _ extends 1>(obj: T): readonly StrKey<T>[];
+    }
+    interface ReadonlyArray<T> {
+        includes<T, V extends T>(this: ReadonlyArray<V>, item: T, fromIndex?: number): item is V;
+        map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
+        map<K extends string, T extends RORec<K>, U extends RORec<K>, _ extends 2 = 2>(this: readonly Entry<T, K>[], callbackfn: <P extends K>(value: [P, T[P]], index: number, array: this) => readonly [P, U[P]], thisArg?: any): readonly Entry<U, K>[];
+        map<V extends ReadonlyArray<unknown>, F extends HKT<unknown>, G extends HKT<unknown>, _ extends 1 = 1>(this: AppMap<F, V>, callbackfn: <I extends keyof V>(value: App<F, V[I]>, index: AsNum<I>, array: V) => App<G, V[I]>, thisArg?: any): AppMapRW<G, V>;
+        reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
+        reduce<V extends ReadonlyArray<unknown>, F extends HKT, U>(this: AppMap<F, V>, callbackfn: <I extends keyof V>(previousValue: U, currentValue: App<F, V[I]>, currentIndex: AsNum<I>, array: V) => U, initialValue: U): U;
+        map<V extends ReadonlyArray<Dom>, F extends HKT<Dom>, G extends HKT<GetDom<Dom>>, Dom = unknown, _ extends 0 = 0>(this: AppMap<F, V, Dom>, callbackfn: <I extends keyof V>(value: App<F, V[I] & Dom>, index: AsNum<I>, array: V) => App<G, [V, I]>, thisArg?: any): AppMapRW<G, {
+            [I in keyof V]: [V, I];
+        }, GetDom<Dom>>;
+    }
+    interface Array<T> extends ReadonlyArray<T> {
+        includes<T, V extends T>(this: ReadonlyArray<V>, item: T, fromIndex?: number): item is V;
+        map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
+        map<K extends string, T extends RORec<K>, U extends RORec<K>, _ extends 2 = 2>(this: readonly Entry<T, K>[], callbackfn: <P extends K>(value: [P, T[P]], index: number, array: this) => readonly [P, U[P]], thisArg?: any): readonly Entry<U, K>[];
+        map<V extends ReadonlyArray<unknown>, F extends HKT<unknown>, G extends HKT<unknown>, _ extends 1 = 1>(this: AppMap<F, V>, callbackfn: <I extends keyof V>(value: App<F, V[I]>, index: AsNum<I>, array: V) => App<G, V[I]>, thisArg?: any): AppMapRW<G, V>;
+        reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
+        reduce<V extends ReadonlyArray<unknown>, F extends HKT, U>(this: AppMap<F, V>, callbackfn: <I extends keyof V>(previousValue: U, currentValue: App<F, V[I]>, currentIndex: AsNum<I>, array: V) => U, initialValue: U): U;
+        map<V extends ReadonlyArray<Dom>, F extends HKT<Dom>, G extends HKT<GetDom<Dom>>, Dom = unknown, _ extends 0 = 0>(this: AppMap<F, V, Dom>, callbackfn: <I extends keyof V>(value: App<F, V[I] & Dom>, index: AsNum<I>, array: V) => App<G, [V, I]>, thisArg?: any): AppMapRW<G, {
+            [I in keyof V]: [V, I];
+        }, GetDom<Dom>>;
+    }
+    interface PromiseConstructor {
+        all<T extends readonly unknown[] | []>(values: AppMap<PromiseHKT, T>): Promise<T>;
+        race<T extends readonly unknown[] | [], _ extends 0 = 0>(values: AppMap<PromiseHKT, T>): Promise<T[number]>;
+        all<T extends readonly unknown[] | []>(values: T): Promise<{
+            -readonly [P in keyof T]: Awaited<T[P]>;
+        }>;
+        race<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
+    }
+}
+
+declare const RawStage: unique symbol;
+declare module 'mongodb' {
+    interface Collection<TSchema extends BSON.Document = BSON.Document> {
+        [RawStage]: {
+            (_: 2): TSchema;
+            (_: 1, x: TSchema): TSchema;
+        };
+        s: {
+            db: Db;
+        };
+    }
+    interface Db {
+        s: {
+            client?: MongoClient;
+        };
+        client: MongoClient;
+    }
+    interface Timestamp {
+        toExtendedJSON(): BSON.TimestampExtended;
+    }
+}
+
+interface CommonCollection {
+    readonly s: {
+        readonly db: Db;
+    };
+    collectionName: string;
+    namespace: string;
+    dbName: string;
+    createIndex: Collection['createIndex'];
+}
+interface ReadonlyCollection<out Out> extends CommonCollection {
+    [RawStage](_: 2): Out;
+}
+interface WriteonlyCollection<in R> extends CommonCollection {
+    [RawStage]: {
+        (_: 1, x: R): unknown;
+    };
+}
+interface RWCollection<in R extends O, out Out extends O = R> extends CommonCollection {
+    [RawStage](_: 2): Out;
+    [RawStage](_: 1, x: R): unknown;
+}
+type OPick<V, K extends StrKey<V>, E extends StrKey<V> = never> = O & Pick<V, K | E>;
+type OPickD<V extends Model, K extends StrKey<V>> = OPick<V, K, 'deletedAt' | '_id'>;
+type View<V extends Model, K extends StrKey<V>> = {
+    collection: ReadonlyCollection<V | Del>;
+    projection: ExactKeys<K>;
+    match?: Expr<boolean, OPickD<V, K>>;
+    hardMatch?: Query<V>;
+};
+
+declare const val: <T extends rawItem>(val: T) => Expr<T, unknown>;
+declare const current: Expr<Timestamp, unknown>;
+declare const $let: <T, D, C, V extends RORec<string, jsonItem>>(vars: ExprsExact<V, D, C>, inExpr: Expr<T, D, C & V>) => Expr<T, D, C>;
+declare const nil: Expr<null, unknown>;
+declare const $getField: {
+    <T, K extends StrKey<T>, D, C = unknown>(expr: Expr<T, D, C>, field: K): Expr<T[K], D, C>;
+    <T, K extends StrKey<T>, D, C = unknown>(expr: Expr<T | N, D, C>, field: K): Expr<T[K] | null, D, C>;
+};
+type NoRaw<T> = T extends Arr<infer U> ? NoRaw<U>[] : T extends readonly unknown[] ? {
+    [K in keyof T]: NoRaw<T[K]>;
+} : T extends O ? {
+    [K in StrKey<T>]: NoRaw<T[K]>;
+} : T;
+type RONoRaw<T> = T extends Arr<infer U> ? readonly RONoRaw<U>[] : T extends readonly unknown[] ? {
+    readonly [K in keyof T]: RONoRaw<T[K]>;
+} : T extends O ? {
+    readonly [K in StrKey<T>]: RONoRaw<T[K]>;
+} : T;
+declare const func: <T extends jsonItem, A extends readonly jsonItem[], D, C = unknown>(f: (...args: NoRaw<A>) => RONoRaw<T>, ...args: { [X in keyof A]: Expr<A[X], D, C>; }) => Expr<T, D, C>;
+declare const rand: () => string;
+declare const $rand: Expr<string, unknown, unknown>;
+
+declare const $sum: <D extends O, C = unknown>(expr: Expr<number | N, D, C>) => DeltaAccumulator<D, number, C>;
+declare const $accumulator: <D, T, Ctx, A extends readonly unknown[]>(init: () => NoRaw<T>, accumulateArgs: AppMap<ExprHKT<Part<D>, Ctx>, A>, accumulate: (a: NoRaw<T>, ...args: NoRaw<A>) => NoRaw<T>, merge: (...args: NoRaw<[T | N, T]>) => NoRaw<T>) => DeltaAccumulator<D, T, Ctx>;
+declare const $countDict: <D extends O, C = unknown>(expr: Expr<string, D, C>) => DeltaAccumulator<D, Rec<string, number>, C>;
+declare const $pushDict: <D extends O, V, C = unknown>(key: Expr<string, D, C>, value: Expr<V, D, C>) => DeltaAccumulator<D, Rec<string, Rec<"0" | "1", Arr<V>>>, C>;
+declare const $keys: <D extends O, C = unknown>(expr: Expr<Rec<string, number>, D, C>) => Expr<Arr<string>, D, C>;
+declare const $entries: <D extends O, V, C = unknown>(expr: Expr<Rec<string, Rec<"1" | "0", Arr<V>>>, D, C>) => Expr<Arr<Rec<"k", string> & Rec<"v", V>>, D, C>;
+
+type MergeInto<T extends O, Out extends O, E = unknown> = {
+    whenNotMatched: 'insert';
+    into: RWCollection<T, Out>;
+} | {
+    whenNotMatched: 'discard' | 'fail';
+    into: ReadonlyCollection<Out> & E;
+};
+type MergeArgs<T extends O, Out extends O, Ctx, In extends O> = {
+    on: Field<T, jsonItem> & Field<Out, jsonItem>;
+} & MergeInto<T, Out> & (({
+    stages?: undefined;
+} & ({
+    whenMatched: 'keepExisting' | 'fail';
+} | {
+    whenMatched: 'replace';
+    into: RWCollection<T, Out>;
+} | {
+    whenMatched: 'merge';
+    into: RWCollection<Replace<Out, T>, Out>;
+})) | {
+    stages: true;
+    into: RWCollection<In, Out>;
+    whenMatched: RawStages<unknown, Out, In>;
+} | {
+    stages: 'ctx';
+    vars: ExprsExact<Ctx, T>;
+    into: RWCollection<In, Out>;
+    whenMatched: RawStages<unknown, Out, In, Ctx>;
+});
+declare const $merge_: <T extends O, Out extends O = T, Ctx = unknown, In extends O = Out>({ into, on, whenNotMatched, ...notMatched }: MergeArgs<T, Out, Ctx, In>) => RawStages<unknown, T, "out", unknown, number>;
+
+type GI$1<GG> = Exclude<GG, keyof TS>;
+type IdAndTsKeys = keyof (TS & ID);
+type V<VV, GG extends string> = Omit<VV, IdAndTsKeys | GI$1<GG>>;
+type Prepare<Grp, GG extends string> = TS & ID & Rec<GI$1<GG>, Grp>;
+type Loose<Grp, VV, GG extends string> = Prepare<Grp, GG> & Partial<V<VV, GG>>;
+type Strict<Grp, VV, GG extends string, EE> = Prepare<Grp, GG> & V<VV, GG> & Omit<EE, IdAndTsKeys | GI$1<GG> | keyof V<VV, GG>>;
+type V_Grp<VV, GG extends string, Grp> = Rec<GI$1<GG>, Grp> & V<VV, GG>;
+type Extra<EE, VV, GG extends string> = Omit<EE, IdAndTsKeys | GI$1<GG> | keyof V<VV, GG>>;
+
+type Denied<GID = never> = keyof (TS & ID) | GID;
+type GI<GG> = Exclude<GG, keyof TS>;
+declare const $groupMerge: <T extends O, Grp extends notArr, V extends O, GG extends string, EE = {}, Out extends Loose<Grp, V, GG> = Loose<Grp, V, GG>>(id: Expr<Grp, T>, args: DeltaAccumulators<T, O & Omit<V, Denied<GI<GG>>>>, out: MergeInto<Strict<Grp, V, GG, EE>, Out, WriteonlyCollection<Replace<Out, Strict<Grp, V, GG, EE>>>>, gid: AsLiteral<GI<GG>>, extra: ExprsExact<Extra<EE, V, GG>, V_Grp<V, GG, Grp>>, idPrefix?: string) => RawStages<unknown, Delta<T>, "out">;
+declare const $groupId: <T extends O, V extends O, EE = {}, Out extends Loose<string, V, "_id"> = Loose<string, V, "_id">>(id: Expr<string, T>, args: DeltaAccumulators<T, O & Omit<V, Denied>>, out: RWCollection<Replace<Out, Strict<string, V, "_id", EE>>, Out>, extra: ExprsExact<Omit<EE, IdAndTsKeys | keyof Omit<V, IdAndTsKeys>>, doc & Omit<V, IdAndTsKeys>>) => RawStages<unknown, Delta<T>, "out">;
+declare const $group: <T extends O, Grp extends notArr, V extends O, EE = {}, Out extends Loose<Grp, V, "_grp"> = Loose<Grp, V, "_grp">>(id: Expr<Grp, T>, args: DeltaAccumulators<T, O & Omit<V, Denied<"_grp">>>, out: RWCollection<Strict<Grp, V, "_grp", EE>, Out>, extra: ExprsExact<Omit<EE, IdAndTsKeys | "_grp" | keyof Omit<V, IdAndTsKeys | "_grp">>, Rec<"_grp", Grp> & Omit<V, IdAndTsKeys | "_grp">>, idPrefix?: string) => RawStages<unknown, Delta<T>, "out">;
+
+type Params<As extends string, LQ extends O, RQ extends O, RE extends RQ, S extends notArr> = {
+    localField: Field<LQ, S>;
+    foreignField: Field<RQ, S>;
+    from: SnapshotStreamExecutionResult<RQ, RE>;
+    as: AsLiteral<As>;
+};
+declare const $lookup: <As extends string, LQ extends doc, RQ extends O, RE extends RQ & doc, S extends notArr>(p: Params<As, LQ, RQ, RE, S>) => <LE extends LQ>(l: SnapshotStream<LQ, LE>) => SnapshotStream<LQ, LE & RORec<As, RE>>;
+
+declare const $matchDelta: <T extends doc>(query: Expr<boolean, T>) => RawStages<unknown, Delta<T>, Delta<T>, unknown, number>;
+
+declare const $match: <T extends doc>(query: Expr<boolean, T>) => DeltaStages<T, T, T>;
+
+declare const Updater: unique symbol;
+type Updater<in R, in T, out V, in C = unknown> = {
+    [Type]?(x: typeof Updater, r: R, t: T, c: C): V;
+    readonly raw: <D extends O>(f: Field<D, R | N>) => readonly (readonly [string, rawItem])[];
+};
+interface UpdaterHKT<R, Old, V, C, K extends keyof Old = keyof Old, V2 extends V = V> extends HKT<StrKey<V>> {
+    readonly out: Updater<R, Get<Old, I<StrKey<V>, this>, K>, V2[I<StrKey<V>, this>], C>;
+}
+type Get<T, P extends string, K extends keyof T = never> = P extends K ? T[P] : P extends keyof T ? T[P] : undefined;
+
+declare const $set: <V extends O>() => <R extends O, C = unknown>(fields: MapO<V, UpdaterHKT<R, R, V, C>>) => DeltaStages<O, R, Replace<R, V>, C> & LinStages<O, R, Replace<R, V>, C>;
+declare const $replaceWith: <T extends O, V extends O>(expr: Expr<V, T>) => DeltaStages<O, T, V> & LinStages<O, T, V>;
+
+type s$1 = string;
+declare const $unwindDelta: <K1 extends s$1, T extends doc, K2 extends s$1, U extends doc>(k1: AsLiteral<K1>, k2: AsLiteral<K2>, k: K1 | K2 | false) => RawStages<Delta<Rec<K1, T>>, Delta<Rec<K1, T> & Rec<K2, Arr<U>>>, Delta<Rec<K1, T> & Rec<K2, U> & ID>>;
+
+type s = string;
+declare const $unwind: <T extends doc, K extends s, U extends doc>(k: AsLiteral<K>, dict: RORec<K, "key">) => DeltaStages<O, T & Rec<K, Arr<U>>, T & Rec<K, U>>;
+
+type Allowed$2<K extends string> = Exclude<K, keyof (TS & ID)>;
+type Patch<V, KK extends StrKey<V>> = ((OPick<V, Allowed$2<KK>> & ID) | (Rec<Allowed$2<KK>, N> & ID)) & TS;
+declare const $merge: <V extends Model & ID>() => <KK extends StrKey<V>, Out extends doc>(out: RWCollection<Out | Replace<Out, Patch<V, KK>>, Out>, keys: ExactKeys<Allowed$2<KK>>) => RawStages<unknown, OutInput<OPick<V, Allowed$2<KK>> & ID>, "out">;
+
+type ND = {
+    readonly deletedAt?: null;
+};
+type Merge<T extends ID> = (T & ND & TS) | Del;
+declare const $upsert: <T extends doc>(out: RWCollection<Merge<T>>) => RawStages<unknown, OutInput<T>, "out">;
+
+type DeltaPipe<Q extends O, T extends Q, F extends HKT<O2>, G extends HKT<O3>> = {
+    with: <Q2 extends O, V extends Q2>(map: (a: Stream<Q, T, F, G>) => Stream<Q | Q2, V, F, G>) => DeltaPipe<Q | Q2, V, F, G>;
+    then: <Q2 extends O, V extends Q2>(next: App<G, [Q2 | T, T, V]>) => DeltaPipe<Q | Q2, V, F, G>;
+    get: () => App<F, [Q, T]>;
+};
+
+type Allowed$1<K> = Exclude<K, 'deletedAt' | '_id'>;
+type AllowedPick$1<V extends Model, K extends StrKey<V>> = OPickD<V, Allowed$1<K>>;
+interface SnapshotStreamHKT extends HKT<O2> {
+    readonly out: SnapshotStreamExecutionResult<I<O2, this>[0], I<O2, this>[1]>;
+}
+interface DeltaHKT extends HKT<O3> {
+    readonly out: DeltaStages<I<O3, this>[0], I<O3, this>[1], I<O3, this>[2]>;
+}
+declare const staging: <V extends Model, KK extends StrKey<V>>(view: View<V, Allowed$1<KK>>, streamName: string) => DeltaPipe<AllowedPick$1<V, KK>, AllowedPick$1<V, KK>, SnapshotStreamHKT, DeltaHKT>;
+
+type Allowed<K> = Exclude<K, 'deletedAt' | '_id'>;
+type AllowedPick<V extends Model, K extends StrKey<V>> = OPickD<V, Allowed<K>>;
+interface StreamRunnerHKT extends HKT<O2> {
+    readonly out: SimpleStreamExecutionResult<I<O2, this>[0], I<O2, this>[1]>;
+}
+interface StagesHKT extends HKT<O3> {
+    readonly out: RORec<'lin', RawStages<I<O3, this>[0], I<O3, this>[1], I<O3, this>[2], unknown, 1>>;
+}
+declare const from: <V extends Model, KK extends StrKey<V>>(view: View<V, Allowed<KK>>, streamName: string) => DeltaPipe<AllowedPick<V, KK>, AllowedPick<V, KK>, StreamRunnerHKT, StagesHKT>;
+
+declare const max: <D, C>(...expr: Expr<number, D, C>[]) => Expr<number, D, C>;
+declare const lt: <D, C>(expr_0: Expr<number, D, C>, expr_1: Expr<number, D, C>) => Expr<boolean, D, C>;
+declare const gt: <D, C>(expr_0: Expr<number, D, C>, expr_1: Expr<number, D, C>) => Expr<boolean, D, C>;
+declare const lte: {
+    <D, C>(...expr: [Expr<Date, D, C>, Expr<Date, D, C>]): Expr<boolean, D, C>;
+    <D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<boolean, D, C>;
+};
+declare const gte: {
+    <D, C>(...expr: [Expr<Date, D, C>, Expr<Date, D, C>]): Expr<boolean, D, C>;
+    <D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<boolean, D, C>;
+};
+type Num = number | null | undefined;
+declare function subtract<D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<number, D, C>;
+declare function subtract<D, C>(...expr: [Expr<Num, D, C>, Expr<Num, D, C>]): Expr<Num, D, C>;
+declare function add<D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<number, D, C>;
+declare function add<D, C>(...expr: [Expr<Num, D, C>, Expr<Num, D, C>]): Expr<Num, D, C>;
+declare function divide<D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<number, D, C>;
+declare function divide<D, C>(...expr: [Expr<Num, D, C>, Expr<Num, D, C>]): Expr<Num, D, C>;
+declare function multiply<D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<number, D, C>;
+declare function multiply<D, C>(...expr: [Expr<Num, D, C>, Expr<Num, D, C>]): Expr<Num, D, C>;
+declare function floor<D, C>(expr: Expr<number, D, C>): Expr<number, D, C>;
+declare function floor<D, C>(expr: Expr<Num, D, C>): Expr<Num, D, C>;
+declare function ceil<D, C>(expr: Expr<number, D, C>): Expr<number, D, C>;
+declare function ceil<D, C>(expr: Expr<Num, D, C>): Expr<Num, D, C>;
+
+declare const size: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<number, D, C>;
+declare const filterDefined: <T, D, C = unknown>(expr: Expr<Arr<T | N>, D, C>) => Expr<Arr<T>, D, C>;
+declare const filter: <T, D, K extends string, C = unknown>({ as, cond, expr, limit, }: {
+    expr: Expr<Arr<T>, D, C>;
+    as: K;
+    cond: Expr<unknown, D, C & RORec<K, T>>;
+    limit?: Expr<number, D, C>;
+}) => Expr<Arr<T>, D, C>;
+declare const sortArray: <T, D, C, K extends keyof T>({ sortBy, expr, order, }: {
+    expr: Expr<Arr<T>, D, C>;
+    sortBy: K;
+    order?: 1 | -1;
+}) => Expr<Arr<T>, D, C>;
+declare const isArray: <T extends notArr, D, C, F extends HKT<T | Arr<T>>>(expr: Expr<T | Arr<T>, D & (App<F, T> | App<F, Arr<T>>), C>) => BoolExpr<D & App<F, Arr<T>>, D & App<F, T>, C>;
+declare const array: <T, D, C = unknown>(...exprs: Expr<T, D, C>[]) => Expr<Arr<T>, D, C>;
+declare const concat: <T, D, C>(...exprs: Expr<Arr<T>, D, C>[]) => Expr<Arr<T>, D, C>;
+declare const first: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
+declare const firstSure: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T, D, C>;
+declare const last: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
+declare const mergeObjects: <T1, T2, D, C = unknown>(exprs_0: Expr<T1, D, C>, exprs_1: Expr<T2, D, C>) => Expr<T1 & T2, D, C>;
+declare const inArray: <T, D, C = unknown>(exprs_0: Expr<T, D, C>, exprs_1: Expr<Arr<T>, D, C>) => Expr<boolean, D, C>;
+declare const slice: <T, D, C>(array: Expr<Arr<T>, D, C>, start: Expr<number, D, C>, end: Expr<number, D, C>) => Expr<Arr<T>, D, C>;
+declare const except: <T, D, C>(a: Expr<Arr<T>, D, C>, b: Expr<Arr<T>, D, C>) => Expr<Arr<T>, D, C>;
+
+declare const dayAndMonthPart: <D, C>(date: Expr<Date, D, C>) => Expr<string, D, C>;
+declare const now: <D, C>() => Expr<Date, D, C>;
+declare const monthPart: <D, C>(date: Expr<Date, D, C>) => Expr<string, D, C>;
+declare const dateAdd: <D, C>(date: Expr<Date, D, C>, amount: Expr<number, D, C>, unit: Expr<"year" | "week" | "month" | "day" | "hour" | "minute" | "second", D, C>) => Expr<Date, D, C>;
+declare const maxDate: <D, C>(expr: Expr<Arr<Date>, D, C>) => Expr<Date, D, C>;
+declare const minDate: <D, C>(expr: Expr<Arr<Date>, D, C>) => Expr<Date, D, C>;
+declare const datePart: <D, C>(date: Expr<Date, D, C>) => Expr<string, D, C>;
+declare const startOf: <D, C>(startDate: Expr<Date, D, C>, freq: Expr<"week" | "day" | "month" | "year", D, C>, offset: Expr<number, D, C>) => Expr<Date, D, C>;
+declare const dateDiff: <D, C>({ end, unit, start, }: {
+    start: Expr<Date, D, C>;
+    end: Expr<Date, D, C>;
+    unit: Expr<"week" | "day" | "month" | "year", D, C>;
+}) => Expr<number, D, C>;
+
+declare const ite: {
+    <T, D, C = unknown>(cond: Expr<unknown, D, C>, then: Expr<T, D, C>, orelse: Expr<T, D, C>): Expr<T, D, C>;
+    <T, R1, R2, F extends HKT<R1 | R2>, C = unknown>(cond: BoolExpr<App<F, R1>, App<F, R2>, C>, then: Expr<T, App<F, R1>, C>, orelse: Expr<T, App<F, R2>, C>): Expr<T, App<F, R1 | R2>, C>;
+};
+declare const and: <D, C = unknown>(expr_0: Expr<boolean, D, C>, expr_1: Expr<boolean, D, C>) => Expr<boolean, D, C>;
+declare const eq: <T, D, C = unknown>(a: Expr<T, D, C>) => (b: Expr<T, D, C>) => Expr<boolean, D, C>;
+declare const sub: <T, D, Ctx, P extends O>(a: Expr<T, D, Ctx>, f: Field<P, D, Ctx>) => Expr<T, P, Ctx>;
+declare const eqTyped: <T1 extends Dom, T2 extends Dom, F extends HKT<Dom>, C = unknown, Dom = unknown>(a: Expr<T1 | T2, App<F, T1 | T2>, C>, b: Expr<T1, App<F, T1 | T2>, C>) => BoolExpr<App<F, T1>, App<F, T2>, C>;
+declare const ne: <T, K, D, C>(a: Expr<T, D, C>) => (b: Expr<K, D, C>) => Expr<boolean, D, C>;
+declare const notNull: <T, K, D, C>(a: Expr<T, D, C>) => Expr<boolean, D, C>;
+declare const $ifNull: <R, D, C>(...expr: [...Expr<R | null | undefined, D, C>[], Expr<R, D, C>]) => Expr<R, D, C>;
+declare const exprMapVal: <K extends string, T extends Partial<Record<K, rawItem>>, D, C>(expr: Expr<K, D, C>, map: { readonly [P in K]: Expr<T[P], D, C>; }, or?: Expr<T[K], D, C>) => Expr<T[K & keyof T], D, C>;
+declare const mapVal: <K extends string, T extends Partial<Record<K, rawItem>>, D, C>(expr: Expr<K, D, C>, map: T, or: T[K & keyof T]) => Expr<T[K & keyof T], D, C>;
+declare const setField: <K extends string, T, V, D, C>({ field, input, value, }: {
+    field: Expr<K, D, C>;
+    input: Expr<T, D, C>;
+    value: Expr<V, D, C>;
+}) => Expr<T & Record<K, V>, D, C>;
+
+declare const range: <D, C>(start: Expr<number, D, C>, end: Expr<number, D, C>, step?: Expr<number, D, C>) => Expr<Arr<number>, D, C>;
+declare const $map1: <T, R, D, C>(ex: Expr<Arr<T>, D, C>, map: (i: Field<unknown, T, RORec<"item", T>>) => Expr<R, D, RORec<"item", T> & C>) => Expr<Arr<R>, D, C>;
+declare const $map: <T, R, D, C = unknown>(ex: Expr<Arr<T>, D, C>, map: (i: Expr<T, D, RORec<"item", T>>) => Expr<R, D, RORec<"item", T> & C>) => Expr<Arr<R>, D, C>;
+
+declare class Machine<Result = unknown> {
+    private sources;
+    constructor(root?: Iterator<Result, HasJob>);
+    add(x: Iterator<Result, HasJob>): void;
+    runner(): Iterator<Result, HasJob>;
+    start(cb?: (info: HasJob) => void | boolean): Promise<never>;
+}
+declare const wrap: <Result>(root: Machine<Result>) => Machine<Result>;
+
+declare const $eq: <T extends unknown>(operand: rawItem & T) => Predicate<T>;
+declare const $ne: <T extends unknown>(operand: rawItem & T) => Predicate<T>;
+type Numeric = number | Timestamp | Date;
+declare const comp: <D2 extends Numeric = number>(op: "$lte" | "$gte" | "$lt" | "$gt") => <T extends D2>(operand: rawItem & D2) => Predicate<D2>;
+declare const $gt: <T extends number>(operand: rawItem & number) => Predicate<number>;
+declare const $gtTs: <T extends Timestamp>(operand: rawItem & Timestamp) => Predicate<Timestamp>;
+declare const $gteTs: <T extends Timestamp>(operand: rawItem & Timestamp) => Predicate<Timestamp>;
+declare const $lt: <T extends number>(operand: rawItem & number) => Predicate<number>;
+declare const dateLt: <T extends Date>(operand: rawItem & Date) => Predicate<Date>;
+declare const $gte: <T extends number>(operand: rawItem & number) => Predicate<number>;
+declare const $lte: <T extends number>(operand: rawItem & number) => Predicate<number>;
+
+declare const $expr: <D extends O, C>(expr: Expr<boolean, D, C>) => Query<D, C>;
+
+declare const $in: <T extends unknown>(operand: rawItem & readonly T[]) => Predicate<T>;
+declare const $nin: <T extends unknown>(operand: rawItem & readonly T[]) => Predicate<T>;
+
+type Many<T> = readonly (T | N)[];
+type Combiner = {
+    <T extends O, C = unknown>(first: Query<T, C>, ...args: Many<Query<T, C>>): Query<T, C>;
+    <T extends O, C = unknown>(...args: Many<Query<T, C>>): Query<T, C> | undefined;
+};
+declare const $and: Combiner;
+declare const $nor: Combiner;
+declare const $or: Combiner;
+
+declare const enablePreAndPostImages: <T extends doc>(coll: Collection<T>) => Promise<bson.Document>;
+declare const prepare: (testName?: string) => Promise<MongoClient$1>;
+
+export { $accumulator, $and, $countDict, $entries, $eq, $expr, $getField, $group, $groupId, $groupMerge, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $keys, $let, $lookup, $lt, $lte, $map, $map1, $match, $matchDelta, $merge, $merge_, $ne, $nin, $nor, $or, $pushDict, $rand, $replaceWith, $set, $sum, $unwind, $unwindDelta, $upsert, type Accumulators, type Arr, type AsLiteral, type Delta, type DeltaAccumulator, type DeltaAccumulators, Expr, Field, type ID, type Loose, Machine, type Merge, type MergeArgs, type MergeInto, type Model, type N, type NoRaw, type O, type OPick, type RONoRaw, type RORec, type RawStages, type Rec, type Replace, type SnapshotStreamExecutionResult, type StrKey, type Strict, type TS, Type, type WriteonlyCollection, add, and, array, ceil, comp, concat, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, type doc, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, filter, filterDefined, first, firstSure, floor, from, func, gt, gte, inArray, isArray, ite, last, lt, lte, mapVal, max, maxDate, mergeObjects, minDate, monthPart, multiply, ne, nil, type notArr, notNull, now, prepare, rand, range, root, setField, size, slice, sortArray, staging, startOf, sub, subtract, val, wrap };