@omegup/msync 0.1.24 → 0.1.26

package/index.d.ts

@@ -1,738 +1,13 @@
-import { Timestamp, Filter, UpdateFilter, BSON, MaxKey, Db, Collection, IndexSpecification, CreateIndexesOptions, MongoClient as MongoClient$1, OptionalUnlessRequiredId } from 'mongodb';
-export { Collection, Timestamp } from 'mongodb';
-
-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<unknown>;
-};
-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;
-}
-
-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 = unknown> = 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 Actions<W> = {
-    updateMany: [Filter<W>, UpdateFilter<W> | BSON.Document[]];
-    deleteMany: [Filter<W>];
-};
-type TeardownRecord<W, M extends keyof Actions<W>> = {
-    collection: WriteonlyCollection<W>;
-    method: M;
-    params: Actions<W>[M];
-};
-type StreamRunnerParam<in V, out Result> = {
-    raw: (first: boolean) => RawStages<unknown, V, Result>;
-    teardown: <R>(consume: <W, M extends keyof Actions<W>>(x: TeardownRecord<W, M>) => R) => R;
-};
-type StreamRunner<out V> = <Result>(input: StreamRunnerParam<V, Result>, setup?: () => Promise<void>) => 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 IsDeleted = {
-    readonly deletedAt: Timestamp;
-};
-type DDel = IsDeleted & ID & TS;
-type Del = O<DDel>;
-type DeletedAt = {
-    readonly deletedAt?: Timestamp | null | undefined;
-};
-type D = O<DeletedAt & ID>;
-type Model = D & TS;
-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 ExactPart<T, F extends HKT<T[StrKey<T>]>> = MapOPart<T, MappedHKT<T, F>>;
-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>]>;
-}
-interface MergeHKT<T, V, F1 extends HKT<StrKey<Omit<T, No>>>, F2 extends HKT<StrKey<V>>, No extends keyof V = never> extends HKT<StrKey<V & Omit<T, No>>> {
-    readonly out: I<StrKey<V & Omit<T, No>>, this> extends StrKey<V> ? App<F2, I<StrKey<V>, this>> : App<F1, I<StrKey<Omit<T, No>>, 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>;
-};
-
-declare const concat: {
-    <D, C>(...expr: Expr<string, D, C>[]): Expr<string, D, C>;
-    <D, C>(...expr: Expr<string | N, D, C>[]): Expr<string | N, D, C>;
-};
-declare const regex: <D, C>(expr: Expr<string, D, C>, regex: Expr<string, D, C>, options?: Expr<string, D, C>) => Expr<boolean, D, C>;
-declare const str: <D, C>(expr: Expr<unknown, D, C>) => Expr<string, D, C>;
-declare const toInt: <D, C>(expr: Expr<unknown, D, C>) => Expr<number, D, C>;
-declare const fieldM: <M extends RORec<Dom, Ref>, T extends RORec<Ref, unknown>, D, Dom extends string = StrKey<M>, Ref extends string = StrKey<T>, C = unknown>(expr: { readonly [K in Ref]: Expr<T[K], D, C>; }, m: Pick<M, Dom>) => Expr<O<{ readonly [K in Dom]: T[M[K]]; }>, D, C>;
-type Exprs<out T, in D, in C = unknown> = {
-    readonly [K in StrKey<T>]: Expr<T[K], D, C>;
-};
-declare const mergeExact: <T1, T2, F extends HKT<T1[StrKey<T1>] | T2[StrKey<T2>]>, E = unknown>(exprsExact1: Exact<Omit<T1, keyof T2>, F>, exprsExact2: Exact<T2, F>) => Exact<T2 & Omit<T1, keyof T2> & Pick<E, symbol & keyof E>, F>;
-type MergeMapOArgs<T1, T2, F1 extends HKT<StrKey<Omit<T1, StrKey<T2>>>>, F2 extends HKT<StrKey<T2>>> = readonly [MapO<Omit<T1, StrKey<T2>>, F1>, MapO<T2, F2>];
-declare const mergeExact0: <T1, T2, F1 extends HKT<StrKey<Omit<T1, StrKey<T2>>>>, F2 extends HKT<StrKey<T2>>, E = unknown>(exprsExact1: MapO<Omit<T1, StrKey<T2>>, F1>, exprsExact2: MapO<T2, F2>) => MapO<T2 & Omit<T1, StrKey<T2>> & Pick<E, symbol & keyof E>, MergeHKT<T1, T2, F1, F2, StrKey<T2>>>;
-declare const mergeExpr: <T1, T2, D, C = unknown, E = unknown>(exprs_0: Exact<Omit<T1, keyof T2>, ExprHKT<D, C, IdHKT<unknown>>>, exprs_1: Exact<T2, ExprHKT<D, C, IdHKT<unknown>>>) => ExprsExact<T2 & Omit<T1, keyof T2> & Pick<E, symbol & keyof E>, D, C>;
-type ExprsPart<T, D, C> = ExactPart<T, ExprHKT<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>>;
-interface ExprsExactHKT<E, D, C = unknown, F extends HKT = IdHKT> extends HKT {
-    readonly out: ExprsExact<E & I<unknown, this>, D, C, F>;
-}
-declare const pair: <T, D, C, P extends StrKey<T>>(k: P, v: Expr<T[P], D, C>) => ExprsExact<T, D, C>[P];
-declare const fieldF: <F extends HKT>() => <T extends object, D, C = unknown>(exprs: ExprsExact<T, D, C, F>) => Expr<O<{ [K in keyof T]: App<F, T[K]>; }>, D, C>;
-declare const field: <T extends object, D, C = unknown>(exprs: ExprsExact<T, D, C>) => Expr<O<T>, D, C>;
-
-declare const Type: unique symbol;
-
-type U = undefined;
-type N = null | U;
-type jsonPrim = number | null | string | boolean | Timestamp | MaxKey | 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 module 'synchronous-promise' {
-    interface SynchronousPromiseConstructor {
-        any<T extends readonly unknown[] | [], _ extends 0 = 0>(values: AppMap<PromiseHKT, T>): SynchronousPromise<T[number]>;
-        any<T extends readonly unknown[] | []>(values: T): SynchronousPromise<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> | null;
-    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> & E;
-} | {
-    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?: never;
-} & ({
-    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, {
-        new: T;
-    }>;
-} | {
-    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>;
-declare const $merge2: <T extends O, Out extends O = T, Ctx = unknown, In extends O = Out>(args: 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 Par<T> = {
-    [P in keyof T]?: T[P] | null;
-};
-type Loose<Grp, VV, GG extends string> = Prepare<Grp, GG> & Par<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 OrReplace<T, V> = T | Replace<T, V>;
-type MergedInput<Out, VV, Grp, GG extends string, EE> = OrReplace<Replace<Replace<Out, V<VV, GG>>, Extra<EE, VV, GG>> & Model, TS & ID & V_Grp<VV, GG, Grp> & Extra<EE, 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<MergedInput<Out, V, Grp, GG, EE>>>, gid: AsLiteral<GI<GG>>, extra: ExprsExact<Extra<EE, V, GG>, V_Grp<V, GG, Grp>>, idPrefix?: string) => StreamRunnerParam<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<MergedInput<Out, V, string, "_id", EE>, Out>, extra: ExprsExact<Omit<EE, IdAndTsKeys | keyof Omit<V, IdAndTsKeys>>, doc & Omit<V, IdAndTsKeys>>) => StreamRunnerParam<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<MergedInput<Out, V, Grp, "_grp", EE> | Strict<Grp, V, "_grp", EE>, Out>, extra: ExprsExact<Omit<EE, IdAndTsKeys | "_grp" | Exclude<keyof V, IdAndTsKeys | "_grp">>, Rec<"_grp", Grp> & Omit<V, IdAndTsKeys | "_grp">>, idPrefix?: string) => StreamRunnerParam<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 $outerLookup: <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 | null>>;
-
-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>() => <R, Old extends notArr, C = unknown, K extends keyof Old = never>(fields: MapO<V, UpdaterHKT<R, Old, V, C, K>>) => Updater<R, Old, O & Omit<Old, StrKey<V>> & V, C> & Updater<R, Arr<Old>, Arr<Omit<Old, StrKey<V>> & V>, C>;
-declare const to: <R, V, C = unknown, T = unknown>(expr: Expr<V, R, C>) => Updater<R, T, V, C>;
-
-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, N1 extends null = never, N2 extends null = never>(k1: AsLiteral<K1>, k2: AsLiteral<K2>, k: K1 | K2 | false, middle?: string, includeNull1?: N1, includeNull2?: N2) => RawStages<Delta<Rec<K1, T | N1>>, Delta<Rec<K1, T | N1> & Rec<K2, Arr<U>>>, Delta<Rec<K1, T | N1> & Rec<K2, U | N2> & ID>>;
-
-type s = string;
-type TOf<TT, K extends string> = doc & Omit<TT, K>;
-declare const $unwind: <TT extends O, K extends s, U extends doc>(k: AsLiteral<K>, dict: RORec<K, "key"> & RORec<"_id", "id">, middle?: string) => DeltaStages<O, TOf<TT, K> & Rec<K, Arr<U>>, TOf<TT, K> & Rec<K, U>>;
-
-type OutInputE<T, E, A = T | null> = ID & Rec<'after', A> & E;
-type Allowed$2<K extends string> = Exclude<K, keyof (TS & ID)>;
-type Patch<V, KK extends StrKey<V> = StrKey<V>> = ((OPick<V, Allowed$2<KK>> & ID) | (Rec<Allowed$2<KK>, N> & ID)) & TS;
-type TakeDoc<V, E = ID, KK extends StrKey<V> = StrKey<V>> = OPick<V, Allowed$2<KK>> & E;
-type ND$1 = {
-    readonly deletedAt?: null;
-};
-type SafeE$1<E> = Omit<E, `$${string}` | keyof ID>;
-declare const getWhenMatchedForMerge: <Out extends Model, P extends Model, K extends keyof IsDeleted>(whenNotMatched: "discard" | "fail" | "insert") => RawStages<O, Out, Out | Replace<Out, P>, RORec<"new", Replace<P, RORec<K, Timestamp>>>>;
-declare const getWhenMatched: <Out extends Model, P extends Model, K extends keyof IsDeleted>(whenNotMatched: "discard" | "fail" | "insert") => RawStages<O, Rec<"old" | "merged", Out | Replace<Out, P>>, Out | Replace<Out, P>>;
-type MergeCollection<V extends O, Out extends Model> = {
-    coll: RWCollection<Out | Replace<Out, Patch<V>> | Replace<Patch<V>, IsDeleted>, Out>;
-    whenNotMatched: 'discard';
-} | {
-    coll: RWCollection<Out | Replace<Out, Patch<V>>, Out>;
-    whenNotMatched: 'fail';
-};
-declare const $mergeId: <V extends O>() => <SourcePart extends doc, Out extends Model, E = unknown, EEE extends RORec<string, rawItem> = {}>(out: MergeCollection<V, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>, id: Expr<string, OutInputE<TakeDoc<V>, E, null>>, ext: Exact<Omit<SafeE$1<EEE>, keyof (ND$1 & TS)>, IdHKT>) => StreamRunnerParam<OutInputE<SourcePart, E>, "out">;
-declare const $simpleMergePart: <V extends O>() => <Source extends doc, Out extends Model, EEE extends RORec<string, rawItem>>(out: MergeCollection<V, Out>, keys: ExprsExact<TakeDoc<V, unknown>, Source>, ext: Exact<Omit<SafeE$1<EEE>, keyof (ND$1 & TS)>, IdHKT>) => StreamRunnerParam<Source, "out">;
-declare const $simpleMerge: <V extends O>() => <Source extends doc, Out extends Model>(out: RWCollection<Out | Replace<Out, Patch<V>> | Replace<Patch<V>, IsDeleted>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, Source>, whenNotMatched?: "fail" | "discard") => StreamRunnerParam<Source, "out">;
-declare const $mergePart: <V extends O>() => <Out extends Model, SourcePart extends doc, EEE extends RORec<string, rawItem>>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>, ext: Exact<Omit<SafeE$1<EEE>, keyof (ND$1 & TS)>, IdHKT>) => StreamRunnerParam<Delta<SourcePart>, "out">;
-declare const $merge: <V extends O>() => <Out extends Model, SourcePart extends doc>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>) => StreamRunnerParam<Delta<SourcePart>, "out">;
-
-type ND = {
-    readonly deletedAt?: null;
-};
-type SafeE<E> = Omit<E, `$${string}` | keyof ID>;
-type Merge<T extends doc, E> = Omit<SafeE<E>, keyof (ND & TS)> & ((T & ND & TS) | Del);
-declare const $insertX: <T extends doc, D extends O, EEE extends RORec<string, rawItem>>(out: RWCollection<Merge<T, EEE>>, expr: Expr<T, D>, map: (x: Expr<T & ND & TS & Omit<SafeE<EEE>, keyof (ND & TS)>, D>) => Expr<Merge<T, EEE>, D>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>, extExpr: ExprsExact<Omit<SafeE<EEE>, keyof (ND & TS)>, unknown>) => StreamRunnerParam<D, "out">;
-declare const $simpleInsert: <T extends doc>(out: RWCollection<Merge<T, {}>>) => StreamRunnerParam<T, "out">;
-declare const $insertPart: <T extends doc, EEE extends RORec<string, rawItem>>(out: RWCollection<Merge<T, EEE>>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>) => StreamRunnerParam<Delta<T>, "out">;
-declare const $insert: <T extends doc>(out: RWCollection<Merge<T, {}>>) => StreamRunnerParam<Delta<T>, "out">;
-
-declare const log: (...args: unknown[]) => void;
-
-declare const createIndex: (collection: {
-    readonly createIndex: Collection["createIndex"];
-    collectionName: string;
-}, indexSpec: IndexSpecification, op?: CreateIndexesOptions) => Promise<void>;
-
-declare const noop: () => void;
-declare const map1: <K extends string, Im>(k: AsLiteral<K>, to: Im) => { readonly [P in K]: [P, Im]; } & {
-    readonly [_: string]: [K, Im];
-};
-
-declare const $group_: <V extends O>() => <ID, T extends O, C = unknown>(id: Expr<ID, T, C>, args: Accumulators<T, V, C>) => RawStages<O, T, Rec<"_id", ID> & V, C, 1>;
-
-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 AllowedPick$1<V extends Model, K extends StrKey<V>> = OPickD<V, Allowed$1<K>>;
-type Allowed$1<K> = Exclude<K, 'deletedAt' | '_id'>;
-
-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>> & {
-    needs?: Partial<Record<KK, 0 | 1>>;
-}, streamName: string, skip?: boolean, after?: () => Promise<void>) => 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, needs?: Partial<Record<KK, 0 | 1>>) => DeltaPipe<AllowedPick<V, KK>, AllowedPick<V, KK>, StreamRunnerHKT, StagesHKT>;
-
-type SingleResult<out Result> = <Result2>(finalInput: RawStages<unknown, Result, Result2>) => Stages<unknown, Result2, unknown>;
-interface SnapshotStreamHKT2 extends HKT<O2> {
-    readonly out: SingleResult<I<O2, this>[1]>;
-}
-declare const single: <V extends Model, KK extends StrKey<V>>(view: View<V, Allowed$1<KK>>, needs?: Partial<Record<KK, 0 | 1>>) => DeltaPipe<AllowedPick$1<V, KK>, AllowedPick$1<V, KK>, SnapshotStreamHKT2, DeltaHKT>;
-
-declare const max: <D, C>(...expr: Expr<number, D, C>[]) => Expr<number, D, C>;
-declare const lt: {
-    <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 gt: {
-    <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 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 inArray: <T, D, C>(item: Expr<T, D, C>, expr: Expr<Arr<T>, D, C>) => Expr<boolean, D, C>;
-declare const array: <T, D, C = unknown>(...exprs: Expr<T, D, C>[]) => Expr<Arr<T>, D, C>;
-declare const concatArray: <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>;
-type NullToOBJ<N extends null> = N extends null ? O : N;
-declare const mergeObjects: <T1, T2, D, C = unknown, N extends null = never>(...exprs: readonly [Expr<T1 | N, D, C>, ...[...Expr<T1 | T2 | N, D, C>[], Expr<T2, D, C>]]) => Expr<(T1 | NullToOBJ<N>) & T2, D, C>;
-declare const anyElementTrue: <D, C = unknown>(expr: Expr<Arr<boolean>, D, C>) => Expr<boolean, D, C>;
-type Reduce<T, V> = RORec<'value', V> & RORec<'this', T>;
-declare const $reduce: <T, V, D, C>(input: Expr<Arr<T>, D, C>, initialValue: Expr<V, D, C>, inExpr: Expr<V, D, C & Reduce<T, V>>) => Expr<V, 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 weekPart: <D, C>(date: Expr<Date, D, C>) => Expr<string, D, C>;
-declare const year: <D, C>(date: Expr<Date, D, C>) => Expr<number, 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: Expr<boolean, D, C>[]) => Expr<boolean, D, C>;
-declare const or: <D, C = unknown>(...expr: Expr<boolean, D, C>[]) => Expr<boolean, D, C>;
-declare const not: <D, C = unknown>(expr: 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, D, C>(a: Expr<T, D, C>) => <K>(b: Expr<K, D, C>) => Expr<boolean, D, C>;
-declare const notNull: <T, 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 $map0: <K extends string, T, R, D, C>({ as, expr, input, }: {
-    input: Expr<Arr<T>, D, C>;
-    as: K;
-    expr: Expr<R, D, RORec<K, T> & C>;
-}) => Expr<Arr<R>, 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 = Numeric>(op: "$lt" | "$lte" | "$gt" | "$gte") => <T extends Numeric>(operand: rawItem & D2) => Predicate<D2>;
-declare const $gt: <T extends Numeric>(operand: rawItem & Numeric) => Predicate<Numeric>;
-declare const $gtTs: <T extends Numeric>(operand: rawItem & Timestamp) => Predicate<Timestamp>;
-declare const $gteTs: <T extends Numeric>(operand: rawItem & Timestamp) => Predicate<Timestamp>;
-declare const $lt: <T extends Numeric>(operand: rawItem & number) => Predicate<number>;
-declare const dateLt: <T extends Numeric>(operand: rawItem & Date) => Predicate<Date>;
-declare const $gte: <T extends Numeric>(operand: rawItem & number) => Predicate<number>;
-declare const $lte: <T extends Numeric>(operand: rawItem & number) => Predicate<number>;
-type MongoTypes = {
-    number: number;
-    array: readonly rawItem[];
-    string: string;
-    object: RawObj;
-    [i: number]: unknown;
-};
-type MongoTypeNames = keyof MongoTypes;
-declare const $type: <T extends keyof MongoTypes>(operand: rawItem & readonly T[]) => Predicate<N | MongoTypes[T]>;
-declare const $exists: <T extends keyof MongoTypes>(operand: rawItem & boolean) => Predicate<unknown>;
-
-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<Document>;
-declare const prepare: (testName?: string) => Promise<MongoClient$1>;
-declare const makeCol: <T extends ID>(docs: readonly OptionalUnlessRequiredId<T>[], database: Db, name?: string) => Promise<Collection<T>>;
-
-export { $accumulator, $and, $countDict, $entries, $eq, $exists, $expr, $getField, $group, $groupId, $groupMerge, $group_, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $insert, $insertPart, $insertX, $keys, $let, $lookup, $lt, $lte, $map, $map0, $map1, $match, $matchDelta, $merge, $merge2, $mergeId, $mergePart, $merge_, $ne, $nin, $nor, $or, $outerLookup, $pushDict, $rand, $reduce, $replaceWith, $set, $simpleInsert, $simpleMerge, $simpleMergePart, $sum, $type, $unwind, $unwindDelta, type Accumulators, type Arr, type AsLiteral, type Delta, type DeltaAccumulator, type DeltaAccumulators, type ExactKeys, Expr, type ExprHKT, type Exprs, type ExprsExact, type ExprsExactHKT, type ExprsPart, Field, type ID, type Loose, Machine, type Merge, type MergeArgs, type MergeInto, type MergeMapOArgs, type Model, type MongoTypeNames, type N, type NoRaw, type NullToOBJ, type O, type OPick, type OPickD, type Patch, type RONoRaw, type RORec, type RawStages, type Rec, type Replace, type SnapshotStreamExecutionResult, type StrKey, type Strict, type TS, Type, type WriteonlyCollection, add, and, anyElementTrue, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, type doc, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, func, getWhenMatched, getWhenMatchedForMerge, gt, gte, inArray, isArray, ite, type jsonPrim, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, type notArr, notNull, now, or, pair, prepare, rand, range, regex, root, set, setField, single, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };
+export * from './lib/accumulators';
+export * from './lib/aggregate';
+export * from './lib/boot';
+export * from './lib/expression';
+export * from './lib/field';
+export * from './lib/update';
+export * from './lib/machine';
+export * from './lib/predicate';
+export * from './lib/query';
+export * from './lib/utils';
+export * from './lib/types/extern';
+export * from './types/extern';
+export { enablePreAndPostImages, prepare, makeCol } from './test/mongodb';

package/index.esm.js

@@ -1,4 +1,4 @@
-import { MaxKey, UUID, MongoClient } from 'mongodb';
+import { Timestamp, UUID, MongoClient } from 'mongodb';
 import crypto$1 from 'crypto';
 import { canonicalize } from 'json-canonicalize';
 import { SynchronousPromise } from 'synchronous-promise';
@@ -82,7 +82,7 @@ const val = (val) => asExpr({
         : val),
 });
 const current = asExpr({
-    raw: () => asExprRaw(new MaxKey()),
+    raw: () => asExprRaw(new Timestamp(0xffffffffffffffffn)),
 });
 const $let = (vars, inExpr) => asExpr({
     raw: f => asExprRaw({
@@ -1599,6 +1599,8 @@ const addTeardown = (it, tr) => {
 };
 
 const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+const maxTimestamp = new Timestamp(0xffffffffffffffffn);
+const isMax = (x) => x instanceof Timestamp && x.equals(maxTimestamp);
 const getCurrentTimestamp = async (db) => {
     const adminDb = db.admin();
     const serverStatus = await adminDb.command({ serverStatus: 1 });
@@ -1641,7 +1643,7 @@ async function* tailOplog(db, opts) {
                 if (doc.op === 'i' || '_id' in doc.o) {
                     const fields = new Set(Object.keys(doc.o));
                     fields.delete('_id');
-                    yield { fields, doc, changeTouched: doc.o['touchedAt'] instanceof MaxKey };
+                    yield { fields, doc, changeTouched: isMax(doc.o['touchedAt']) };
                 }
                 else {
                     let changeTouched = false;
@@ -1653,7 +1655,7 @@ async function* tailOplog(db, opts) {
                     for (const updateOp in diff) {
                         if (['u', 'i', 'd'].includes(updateOp)) {
                             updatedFields.push(...Object.keys(diff[updateOp]));
-                            if (diff[updateOp]['touchedAt'] instanceof MaxKey) {
+                            if (isMax(diff[updateOp]['touchedAt'])) {
                                 changeTouched = true;
                             }
                         }
@@ -1767,7 +1769,7 @@ const makeWatchStream = async ({ collection, projection: p, hardMatch: m }, stre
     const { db } = collection.s;
     await (maxKeysRemoved ??= Promise.all((await db.listCollections({}, { nameOnly: true }).toArray()).map(x => void db
         .collection(x.name)
-        .updateMany({ touchedAt: new MaxKey() }, [{ $set: { touchedAt: '$$CLUSTER_TIME' } }]))).then(() => { }));
+        .updateMany({ touchedAt: maxTimestamp }, [{ $set: { touchedAt: '$$CLUSTER_TIME' } }]))).then(() => { }));
     const projection = { ...(p ? mapExactToObject(p, v => v) : {}), deletedAt: 1 };
     let resolve = (_) => { };
     const promise = new Promise(r => (resolve = r));
@@ -2002,20 +2004,20 @@ const executes$2 = (view, input, streamName, skip = false, after, needs = {}) =>
                 whenMatched: link().with($replaceWith_(ite(eq(root().of('before').expr())(ctx()('new').of('after').expr()), root().expr(), mergeObjects(root().expr(), ctx()('new').expr())))).stages,
                 whenNotMatched: 'insert',
             })).stages;
+            const stream = await makeStream();
             const r = await aggregate(pdb, streamName, c => c({ coll: collection, input: cloneIntoNew }));
             const start = Date.now();
             const res = await snapshotCollection.deleteMany({ updated: true, after: null, before: null });
             log('deleting from cloned into new collection', Date.now() - start, res, `db['${snapshotCollection.collectionName}'].deleteMany({ updated: true, after: null, before: null })`);
-            return next(step4({ result: r, ts: lastTS?.ts }), 'run the aggregation');
+            return next(step4({ result: r, ts: lastTS?.ts, stream }), 'run the aggregation');
         };
         const makeStream = () => makeWatchStream(view, streamName);
-        const step4 = ({ result, ts }) => async () => {
+        const step4 = ({ result, ts, stream }) => async () => {
             const start = Date.now();
             log('snapshot', streamName, 'ensure before null', Date.now() - start);
             const first = ts === undefined;
             const stages = finalInput.raw(first);
             await last.updateOne({ _id: streamName }, { $set: { job: 1 } }, { upsert: true });
-            const stream = await makeStream();
             const nextRes = stream.tryNext();
             const aggResult = await aggregate(pdb, streamName, c => c({
                 coll: snapshotCollection,

package/index.js

@@ -84,7 +84,7 @@ const val = (val) => asExpr({
         : val),
 });
 const current = asExpr({
-    raw: () => asExprRaw(new mongodb.MaxKey()),
+    raw: () => asExprRaw(new mongodb.Timestamp(0xffffffffffffffffn)),
 });
 const $let = (vars, inExpr) => asExpr({
     raw: f => asExprRaw({
@@ -1601,6 +1601,8 @@ const addTeardown = (it, tr) => {
 };
 
 const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+const maxTimestamp = new mongodb.Timestamp(0xffffffffffffffffn);
+const isMax = (x) => x instanceof mongodb.Timestamp && x.equals(maxTimestamp);
 const getCurrentTimestamp = async (db) => {
     const adminDb = db.admin();
     const serverStatus = await adminDb.command({ serverStatus: 1 });
@@ -1643,7 +1645,7 @@ async function* tailOplog(db, opts) {
                 if (doc.op === 'i' || '_id' in doc.o) {
                     const fields = new Set(Object.keys(doc.o));
                     fields.delete('_id');
-                    yield { fields, doc, changeTouched: doc.o['touchedAt'] instanceof mongodb.MaxKey };
+                    yield { fields, doc, changeTouched: isMax(doc.o['touchedAt']) };
                 }
                 else {
                     let changeTouched = false;
@@ -1655,7 +1657,7 @@ async function* tailOplog(db, opts) {
                     for (const updateOp in diff) {
                         if (['u', 'i', 'd'].includes(updateOp)) {
                             updatedFields.push(...Object.keys(diff[updateOp]));
-                            if (diff[updateOp]['touchedAt'] instanceof mongodb.MaxKey) {
+                            if (isMax(diff[updateOp]['touchedAt'])) {
                                 changeTouched = true;
                             }
                         }
@@ -1769,7 +1771,7 @@ const makeWatchStream = async ({ collection, projection: p, hardMatch: m }, stre
     const { db } = collection.s;
     await (maxKeysRemoved ??= Promise.all((await db.listCollections({}, { nameOnly: true }).toArray()).map(x => void db
         .collection(x.name)
-        .updateMany({ touchedAt: new mongodb.MaxKey() }, [{ $set: { touchedAt: '$$CLUSTER_TIME' } }]))).then(() => { }));
+        .updateMany({ touchedAt: maxTimestamp }, [{ $set: { touchedAt: '$$CLUSTER_TIME' } }]))).then(() => { }));
     const projection = { ...(p ? mapExactToObject(p, v => v) : {}), deletedAt: 1 };
     let resolve = (_) => { };
     const promise = new Promise(r => (resolve = r));
@@ -2004,20 +2006,20 @@ const executes$2 = (view, input, streamName, skip = false, after, needs = {}) =>
                 whenMatched: link().with($replaceWith_(ite(eq(root().of('before').expr())(ctx()('new').of('after').expr()), root().expr(), mergeObjects(root().expr(), ctx()('new').expr())))).stages,
                 whenNotMatched: 'insert',
             })).stages;
+            const stream = await makeStream();
             const r = await aggregate(pdb, streamName, c => c({ coll: collection, input: cloneIntoNew }));
             const start = Date.now();
             const res = await snapshotCollection.deleteMany({ updated: true, after: null, before: null });
             log('deleting from cloned into new collection', Date.now() - start, res, `db['${snapshotCollection.collectionName}'].deleteMany({ updated: true, after: null, before: null })`);
-            return next(step4({ result: r, ts: lastTS?.ts }), 'run the aggregation');
+            return next(step4({ result: r, ts: lastTS?.ts, stream }), 'run the aggregation');
         };
         const makeStream = () => makeWatchStream(view, streamName);
-        const step4 = ({ result, ts }) => async () => {
+        const step4 = ({ result, ts, stream }) => async () => {
             const start = Date.now();
             log('snapshot', streamName, 'ensure before null', Date.now() - start);
             const first = ts === undefined;
             const stages = finalInput.raw(first);
             await last.updateOne({ _id: streamName }, { $set: { job: 1 } }, { upsert: true });
-            const stream = await makeStream();
             const nextRes = stream.tryNext();
             const aggResult = await aggregate(pdb, streamName, c => c({
                 coll: snapshotCollection,

package/package.json

@@ -3,7 +3,7 @@
     "module": "index.esm.js",
     "typings": "index.d.ts",
     "name": "@omegup/msync",
-    "version": "0.1.24",
+    "version": "0.1.26",
     "dependencies": {
         "dayjs": "^1.11.9",
         "dotenv": "^16.3.1",