@omegup/msync 0.1.61 → 0.1.62

package/index.d.ts

@@ -1,847 +1,13 @@
-import { Timestamp, Filter, UpdateFilter, BSON, Db, Collection, IndexSpecification, CreateIndexesOptions, OptionalUnlessRequiredId, MongoClient as MongoClient$1 } from 'mongodb';
-export { Collection, Timestamp } from 'mongodb';
-
-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$1 = {
-    [Type]: typeof array$1;
-};
-type Arr<T, N extends number = number> = A$1 & {
-    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 PRRec<K extends keyof never, T = unknown> = {
-    [P in K]?: T;
-};
-type Par$1<K extends string, V extends Rec<K, jsonItem>> = {
-    readonly [k in K]?: V[k] | N;
-};
-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 ReplaceQ<R extends Q, VV, Q extends O> = Omit<R, StrKey<VV>> & Omit<VV, StrKey<Q>> & Q;
-type AsLiteral<T extends keyof any | boolean | N, V = NoUnion<T>> = T extends keyof any ? {} extends {
-    [K in T]: 1;
-} ? never : V : V;
-type NoUnion<T, V = T> = T extends T ? ([V] extends [T] ? T : never) : never;
-
-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, 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 NTrue = true | N;
-type DeletedFlags = Rec<BA, NTrue>;
-type Deleted = {
-    readonly deleted?: DeletedFlags;
-};
-type Delta<T, K extends BA = BA, E = ID & Deleted> = PreDelta<T | null, K, E> & ({
-    after: T;
-} | {
-    before: T;
-});
-type Before<T> = PreDelta<T, 'before'>;
-type UBefore<T> = O & {
-    readonly before?: T | null;
-};
-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>;
-    };
-};
-
-declare const map: <T, K extends string & keyof T, V extends RORec<K, unknown>>(x: Pick<T, K>, f: <P extends K>(v: T[P], k: P) => V[P]) => V;
-type ExactPart<T, F extends HKT<T[StrKey<T>]>> = MapOPart<T, MappedHKT<T, F>>;
-type ExactPart1<T, F extends HKT<StrKey<T>>> = {
-    readonly [K in StrKey<T>]: App<F, K>;
-};
-type s$3 = string;
-type MapKDom<RK extends MapKDom<RK, F>, F extends HKT<StrKey<RK>>> = MapO<RK, F> & {
-    readonly [P in s$3]?: readonly [keyof RK, unknown];
-};
-type ExactKeys<K extends string> = Exact<RORec<K, 1>, IdHKT>;
-type MapO<T, F extends HKT<K>, K extends StrKey<T> = StrKey<T>> = MapOPart<T, F, K> & {
-    readonly [P: string]: readonly [K, unknown];
-};
-type MapK<K extends s$3, F extends HKT<K>> = MapO<RORec<K>, F>;
-type MapOPart<T, F extends HKT<K>, K extends keyof T = StrKey<T>> = {
-    readonly [P in K]: readonly [P, App<F, P & string>];
-};
-type MapKPart1<T, F extends HKT<K>, K extends StrKey<T> = StrKey<T>> = {
-    readonly [P in K]: App<F, P>;
-};
-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 mapExactToObject0: <T, F extends HKT<K>, G extends HKT<K>, K extends StrKey<T> = StrKey<T>>(x: MapO<T, F, K>, f: <P extends K>(v: App<F, P>, k: P) => App<G, P>) => MapKPart1<T, G, K>;
-declare const mapExactToObject1: <K extends string, F extends HKT<K>, G extends HKT<K>>(x: MapK<K, F>, f: <P extends K>(v: App<F, P>, k: P) => App<G, P>) => MapKPart1<RORec<K>, G>;
-interface WithKey1<K extends string, G extends HKT<K>> extends HKT<K> {
-    readonly out: readonly [I<K, this>, App<G, I<K, this>>];
-}
-declare const mapExact0: <T, F extends HKT<StrKey<T>>, G extends HKT<StrKey<T>>>(x: MapO<T, F>, f: <P extends StrKey<T>>(v: App<F, P>, k: P) => App<G, P>) => MapO<T, G>;
-declare const mapExact1: <K extends s$3, F extends HKT<K>, G extends HKT<K>>(x: MapK<K, F>, f: <P extends K>(v: App<F, P>, k: P) => App<G, P>) => MapK<K, G>;
-declare const mapExactToObject: <T, F extends HKT<T[StrKey<T>]>, G extends HKT<StrKey<T>>>(x: Exact<T, F>, f: <P extends StrKey<T>>(v: App<F, T[P]>, k: P) => App<G, P>) => ExactPart1<T, G>;
-declare const mapExact: <T, F extends HKT<T[StrKey<T>]>, G extends HKT<T[StrKey<T>]>>(x: Exact<T, F>, f: <P extends StrKey<T>>(v: App<F, T[P]>, k: P) => App<G, T[P]>) => Exact<T, G>;
-type Dom$1<T, V> = HKT<T[StrKey<T>] | V[StrKey<V>]>;
-declare const spread: <T, V, F extends Dom$1<T, V>, EK extends symbol = never, EE = unknown, No extends keyof V = never>(a: Exact<Omit<T, No>, F>, b: Exact<V, F>) => Exact<V & Omit<T, keyof V> & Record<EK, EE>, F>;
-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 spread0: <T, V, F1 extends HKT<StrKey<Omit<T, No>>>, F2 extends HKT<StrKey<V>>, E = unknown, No extends keyof V = never>(a: MapO<Omit<T, No>, F1>, b: MapO<V, F2>) => MapO<V & Omit<T, No> & Pick<E, symbol & keyof E>, MergeHKT<T, V, F1, F2, No>>;
-
-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> & {
-    readonly deleted?: true | N;
-};
-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 $substr: <D, C>(expr: Expr<string, D, C>, start: Expr<number, D, C>, length: Expr<number, D, C>) => Expr<string, D, C>;
-declare const padLeft: <D, C>(expr: Expr<string, D, C>, pad: string) => Expr<string, 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>]>, EK extends symbol = never, EE = unknown>(exprsExact1: Exact<Omit<T1, keyof T2>, F>, exprsExact2: Exact<T2, F>) => Exact<T2 & Omit<T1, keyof T2> & Record<EK, EE>, 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, EK extends symbol = never, EE = 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> & Record<EK, EE>, 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 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>;
-
-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 ArrHKT<Dom = unknown> extends HKT<Dom> {
-    readonly out: readonly I<Dom, this>[];
-}
-interface IdHKT<Dom = unknown> extends HKT<Dom> {
-    readonly out: I<Dom, this>;
-}
-interface RConstHKT<Im, Dom = Im> extends HKT<Im, HKT<Dom, Im>> {
-    readonly out: ConstHKT<I<Im, this>, Dom>;
-}
-interface ConstHKT<Im, Dom = unknown> extends HKT<Dom, Im> {
-    readonly out: Im;
-}
-type ApplyF<Dom, Im, T extends [Dom, HKT<Dom, Im>]> = App<T[1], T[0]>;
-interface ApplyHKT<Dom, Im> extends HKT<[Dom, HKT<Dom, Im>], Im> {
-    readonly out: ApplyF<Dom, Im, I<[Dom, HKT<Dom, Im>], this>>;
-}
-interface µ<X extends [HKT<A, B>, HKT<B, C>], A = unknown, B = unknown, C = unknown> extends HKT<A, C> {
-    readonly out: App<X[1], App<X[0], I<A, 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>>;
-}
-interface DeepFieldHKT<R, T, K extends keyof T, F extends HKT<R, T>> extends HKT<R, T[K]> {
-    readonly out: App<F, I<R, this>>[K];
-}
-interface FieldHKT<K extends string> extends DeepFieldHKT<Record<K, unknown>, Record<K, unknown>, K, IdHKT<Record<K, unknown>>> {
-}
-interface RecordHKT<K extends string, Dom = unknown> extends HKT<Dom, Record<K, Dom>> {
-    readonly out: Record<K, I<Dom, this>>;
-}
-interface RecHKT<K extends string, Dom = unknown, E = unknown> extends HKT<Dom, Rec<K, Dom>> {
-    readonly out: Rec<K, I<Dom, this>> & E;
-}
-interface UBeforeHKT<Dom = unknown> extends HKT<Dom, UBefore<Dom>> {
-    readonly out: UBefore<I<Dom, this>>;
-}
-interface And<E> extends HKT {
-    readonly out: E & I<unknown, this>;
-}
-
-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 AddO<T> = T extends notObj ? T : T extends Array<infer U> ? Arr<AddO<U>> : O<{
-    [K in keyof T]: AddO<T[K]>;
-}>;
-declare const func: <T extends jsonItem, A extends readonly jsonItem[], D, C = unknown>(f: (...args: A) => T, ...args: { [X in keyof A]: Expr<AddO<A[X]>, D, C>; }) => Expr<AddO<T>, D, C>;
-declare const rand: () => string;
-declare const $rand: Expr<string, unknown, unknown>;
-
-type AddOs<A extends readonly unknown[]> = {
-    [K in keyof A]: AddO<A[K]>;
-};
-type PushSides<V> = {
-    0: V[];
-    1: V[];
-};
-type PushDict<V> = PRRec<string, PushSides<V>>;
-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: () => T, accumulateArgs: AppMap<ExprHKT<Part<D>, Ctx>, AddOs<A>>, accumulate: (a: T, ...args: A) => T, merge: (...args: [T | N, T]) => T) => DeltaAccumulator<D, AddO<T>, Ctx>;
-declare const $countDict: <D extends O, K extends string = string, C = unknown>(expr: Expr<AddO<K>, D, C>) => DeltaAccumulator<D, AddO<PRRec<K, number>>, C>;
-declare const $countDictArray: <D extends O, K extends string = string, C = unknown>(expr: Expr<AddO<K[]>, D, C>) => DeltaAccumulator<D, AddO<PRRec<K, number>>, C>;
-declare const $pushDict: <D extends O, V, C = unknown>(key: Expr<string, D, C>, value: Expr<AddO<V>, D, C>) => DeltaAccumulator<D, O<{
-    [x: string]: O<{
-        0: Arr<AddO<V>>;
-        1: Arr<AddO<V>>;
-    }> | undefined;
-}>, C>;
-declare const $keys: <D extends O, K extends string = string, C = unknown>(expr: Expr<AddO<PRRec<K, number>>, D, C>) => Expr<AddO<K[]>, D, C>;
-declare const $entries: <D extends O, V, C = unknown>(expr: Expr<AddO<PushDict<V>>, D, C>) => Expr<AddO<{
-    k: string;
-    v: V;
-}[]>, D, C>;
-
-type Equal<Dom, T extends Dom, V extends Dom> = {
-    forward: <F extends HKT<Dom>>(x: App<F, T>) => App<F, V>;
-    forward1: (x: T) => V;
-    backward: <F extends HKT<Dom>>(x: App<F, V>) => App<F, T>;
-    backward1: (x: V) => T;
-};
-declare const sym: <Dom, T extends Dom, V extends Dom>(eq: Equal<Dom, T, V>) => Equal<Dom, V, T>;
-declare const reflex: <Dom, T extends Dom>() => Equal<Dom, T, T>;
-declare const eqExtends: <Im, T, U, F extends HKT<T, Im>, G extends HKT<T, Im>, H extends HKT<T, Im>, M extends Im>(_1: Equal<Im, App<F, T & U>, M | App<G, T & U>>, _2: Equal<Im, App<F, Exclude<T, U>>, M | App<H, Exclude<T, U>>>) => Equal<Im, App<F, T>, M | (T extends U ? App<G, T> : App<H, T>)>;
-declare const fromEq: <Dom, T extends Dom, V extends Dom>(eq: Pick<Equal<Dom, T, V>, "forward" | "backward">) => Equal<Dom, T, V>;
-declare const literalsEqaul: <T extends keyof any | boolean | N, V extends T>(_: AsLiteral<T> & V) => Equal<T, T, V>;
-declare const omitRORec: <K extends string, E extends string, R extends string, T extends unknown>() => Equal<unknown, RORec<Exclude<K, E | R>, T>, Omit<RORec<Exclude<K, E | R>, T>, R>>;
-type s$2 = keyof any;
-declare const omitPick: <K extends s$2, E extends s$2, R extends s$2, T extends RORec<Exclude<K, E | R>, unknown>>() => Equal<unknown, Pick<T, Exclude<K, E | R>>, Omit<Pick<T, Exclude<K, E | R>>, R>>;
-declare const omitExclude: <K extends s$2, E extends s$2, R extends s$2, T extends RORec<Exclude<K, E | R>, unknown>>() => Equal<unknown, Omit<T, E & Exclude<K, keyof T>>, Omit<Pick<T, Exclude<K, E | R>>, R>>;
-declare const renamedFields: <K extends s$2, F extends HKT<K, s$2>, G extends HKT<App<F, K>>>() => Equal<string | number | symbol, keyof { [P in K as App<F, P>]: App<G, P>; }, App<F, K>>;
-declare const translateOmit: <T, K extends string, Q extends string, P extends string>() => Equal<unknown, Omit<Omit<T, K | Q>, P>, Omit<Omit<T, K | Q>, Q | P>>;
-declare const excludeIdem: <K extends s$2, E extends s$2, S extends E = E>() => Equal<Exclude<K, E>, Exclude<K, E>, Exclude<Exclude<K, E>, S>>;
-declare const eqPar: <K extends string, T extends Rec<K, jsonItem>, K2 extends K>() => Equal<unknown, Par$1<K2, T>, Par$1<K, T>>;
-
-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]>;
-};
-declare const emptyDelta: <T extends O>() => {
-    delta: RawStages<Delta<T>, Delta<T>, Delta<T>, unknown, number>;
-    raw: <F extends HKT<O>>() => RawStages<App<F, T>, App<F, T>, App<F, T>, unknown, number>;
-};
-
-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$1<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$1<VV, GG>>;
-type Strict<Grp, VV, GG extends string, EE> = Prepare<Grp, GG> & V$1<VV, GG> & Omit<EE, IdAndTsKeys | GI$1<GG> | keyof V$1<VV, GG>>;
-type V_Grp<VV, GG extends string, Grp> = Rec<GI$1<GG>, Grp> & V$1<VV, GG>;
-type Extra<EE, VV, GG extends string> = Omit<EE, IdAndTsKeys | GI$1<GG> | keyof V$1<VV, GG>>;
-type OrReplace<T, V> = T | Replace<T, V>;
-type MergedInput<Out, VV, Grp, GG extends string, EE> = OrReplace<Replace<Replace<Out, V$1<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>;
-type GroupMergeOut<Grp extends notArr, V extends O, GG extends string, EE = {}, Out extends Loose<Grp, V, GG> = Loose<Grp, V, GG>> = MergeInto<Strict<Grp, V, GG, EE>, Out, WriteonlyCollection<MergedInput<Out, V, Grp, GG, EE>>>;
-type GroupMergeCollection<WhenNotMatched extends MergeInto<never, never>['whenNotMatched'], Grp extends notArr, V extends O, GG extends string, EE = {}, Out extends Loose<Grp, V, GG> = Loose<Grp, V, GG>> = (GroupMergeOut<Grp, V, GG, EE, Out> & {
-    whenNotMatched: WhenNotMatched;
-})['into'];
-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: GroupMergeOut<Grp, V, GG, EE, Out>, gid: AsLiteral<GI<GG>>, extra: ExprsExact<Extra<EE, V, GG>, V_Grp<V, GG, Grp>>, idPrefix?: string) => StreamRunnerParam<Delta<T>, "out">;
-type GroupIdCollection<V extends O, EE = {}, Out extends Loose<string, V, '_id'> = Loose<string, V, '_id'>> = RWCollection<MergedInput<Out, V, string, '_id', EE>, 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: GroupIdCollection<V, EE, Out>, extra: ExprsExact<Omit<EE, IdAndTsKeys | keyof Omit<V, IdAndTsKeys>>, doc & Omit<V, IdAndTsKeys>>) => StreamRunnerParam<Delta<T>, "out">;
-type GroupCollection<Grp extends notArr, V extends O, EE = {}, Out extends Loose<Grp, V, '_grp'> = Loose<Grp, V, '_grp'>> = RWCollection<MergedInput<Out, V, Grp, '_grp', EE> | Strict<Grp, V, '_grp', EE>, 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: GroupCollection<Grp, V, 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> = {
-    from: SnapshotStreamExecutionResult<RQ, RE>;
-    as: AsLiteral<As>;
-} & ({
-    to: 'one';
-    localField: Field<LQ, string | N>;
-    foreignField?: never;
-    middle?: never;
-} | {
-    to: 'many';
-    middle: string;
-    localField: Field<LQ, S | Arr<S>>;
-    foreignField: Field<RQ, S | Arr<S>>;
-});
-declare const $lookup: <As extends string, LQ extends doc, RQ extends doc, 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 doc, 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 matchDelta: <D>() => RawStages<unknown, Delta<D | null>, Delta<D>>;
-
-declare const $match: <T extends doc>(query: Expr<boolean, T>) => DeltaStages<T, T, T>;
-
-type Omit$1<T, K extends keyof any> = T extends T ? Pick<T, Exclude<keyof T, K>> : never;
-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 UpdaterQHKT<R, Old, V2, StrKey<V>, C, K> {
-}
-interface UpdaterQHKT<R, Old, V, KV extends StrKey<V>, C, K extends keyof Old = keyof Old> extends HKT<KV> {
-    readonly out: Updater<R, Get<Old, I<KV, this>, K>, V[I<KV, 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$1<Old, StrKey<V>> & V, C> & Updater<R, Arr<Old>, Arr<Omit$1<Old, StrKey<V>> & V>, C>;
-declare const to: <R, V, C = unknown, T = unknown>(expr: Expr<V, R, C>) => Updater<R, T, V, C>;
-
-type V<VV, Q> = Exclude<StrKey<VV>, StrKey<Q>>;
-type $Set<VV extends O, Q extends O> = <R extends Q, C = unknown>(fields: MapO<Omit<VV, StrKey<Q>>, UpdaterQHKT<R, R, VV, V<VV, Q>, C>, V<VV, Q>>) => DeltaStages<Q, R, Q & ReplaceQ<R, VV, Q>, C> & LinStages<Q, R, Q & ReplaceQ<R, VV, Q>, C>;
-declare const $set: <VV extends O, Q extends O = O>() => $Set<VV, Q>;
-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;
-type JoinId<K1 extends s$1, K2 extends s$1> = K1 | K2 | readonly [K1, middle: s$1, K2] | readonly [K2, middle: s$1, K1];
-declare const joinIdOf: <K1 extends s$1, K2 extends s$1, D, C = unknown>(k: JoinId<K1, K2>, k1: K1, k1Id: Expr<s$1, D, C>, k2Id: Expr<s$1, D, C>) => Expr<s$1, D, C>;
-declare const $unwindDelta: <K1 extends s$1, T extends doc, KK2 extends s$1, U extends doc, N1 extends null = never, N2 extends null = never>(k1: AsLiteral<K1>, k2: AsLiteral<Exclude<KK2, K1 | BA>>, k: JoinId<K1, Exclude<KK2, K1 | BA>>, includeNull1?: N1, includeNull2?: N2) => RawStages<unknown, Delta<Rec<K1, T | N1> & Rec<Exclude<KK2, K1 | BA>, Arr<U>>>, Delta<Rec<K1, T | N1> & Rec<Exclude<KK2, K1 | BA>, 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>;
-type Args<P, Out> = [added: Expr<P, unknown, {
-    new: P;
-}>, old: Expr<Out, Out>];
-type Result<P> = Expr<P, unknown, {
-    new: P;
-}>;
-type Update$1<P, Out> = (...args: Args<P, Out>) => Result<P>;
-type UpdateF<P, Out> = <K extends keyof IsDeleted>(...args: Args<Replace<P, RORec<K, Timestamp>>, Out>) => Result<Replace<P, RORec<K, Timestamp>>>;
-declare const getSubsetMatchForExt: <Out extends Model, P extends Model, E extends Record<keyof E, rawItem>>(ext: Exact<E, IdHKT>) => null | Expr<boolean, Rec<"old" | "merged", Out | Replace<Out, P>>>;
-declare const getWhenMatchedForMerge: <Out extends Model, P extends Model, K extends keyof IsDeleted>(whenNotMatched: "discard" | "fail" | "insert", update: Update$1<Replace<P, RORec<K, Timestamp>>, Out>, canWrite: Expr<boolean, Rec<"old" | "merged", Out | Replace<Out, P>>> | null) => RawStages<O, Out, Out | Replace<Out, P>, RORec<"new", Replace<P, RORec<K, Timestamp>>>>;
-declare const getWhenMatched: <Out extends Model, P extends Model>(whenNotMatched: "discard" | "fail" | "insert", canWrite: Expr<boolean, Rec<"old" | "merged", Out | Replace<Out, P>>> | null) => 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';
-};
-type MergeUpdate<V, Out> = UpdateF<((OPick<V, Allowed$2<StrKey<V>>> & ID) | (Rec<Allowed$2<StrKey<V>>, N> & ID)) & TS, Out>;
-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>, update?: MergeUpdate<V, Out>) => 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>, update?: MergeUpdate<V, Out>) => 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", update?: MergeUpdate<V, Out>) => 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>, update?: MergeUpdate<V, Out>) => 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>, update?: MergeUpdate<V, Out>) => 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);
-type ExprP<P> = Expr<P, unknown, {
-    new: P;
-}>;
-type Update<P, Out> = (added: ExprP<P>, old: Expr<Out, Out>) => ExprP<P>;
-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>, update?: Update<Replace<Merge<T, EEE>, {}>, Merge<T, EEE>>) => StreamRunnerParam<D, "out">;
-declare const $simpleInsert: <T extends doc, EEE extends RORec<string, rawItem>>(out: RWCollection<Merge<T, EEE>>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>) => 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 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 min: <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 | N, D, C>, Expr<Date | N, D, C>]): Expr<boolean, D, C>;
-    <D, C>(...expr: [Expr<number | N, D, C>, Expr<number | N, D, C>]): Expr<boolean, D, C>;
-};
-declare const gte: {
-    <D, C>(...expr: [Expr<Date | N, D, C>, Expr<Date | N, D, C>]): Expr<boolean, D, C>;
-    <D, C>(...expr: [Expr<number | N, D, C>, Expr<number | N, 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 mapFromPlainDateTime: <D, C>({ plainDate, timezone, }: {
-    plainDate: Expr<Date, D, C>;
-    timezone: Expr<string, D, C>;
-}) => Expr<Date, D, C>;
-declare const mapToPlainDateTime: <D, C>(date: Expr<Date, D, C>, timezone: Expr<string, D, C>) => Expr<Date, 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 = unknown>(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 = unknown>(...expr: [...Expr<R | null | undefined, D, C>[], Expr<R, D, C>]): Expr<R, D, C>;
-    <R, D, C = unknown>(...expr: [Expr<R, D, C>, ...Expr<R | null | undefined, 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: "$gt" | "$gte" | "$lt" | "$lte") => <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: Arr<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, $countDictArray, $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, $substr, $sum, $type, $unwind, $unwindDelta, Expr, Field, Machine, Type, add, and, anyElementTrue, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, emptyDelta, enablePreAndPostImages, eq, eqExtends, eqPar, eqTyped, except, excludeIdem, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, fromEq, func, getSubsetMatchForExt, getWhenMatched, getWhenMatchedForMerge, gt, gte, inArray, isArray, ite, joinIdOf, last, literalsEqaul, log, lt, lte, makeCol, map, map1, mapExact, mapExact0, mapExact1, mapExactToObject, mapExactToObject0, mapExactToObject1, mapFromPlainDateTime, mapToPlainDateTime, mapVal, matchDelta, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, min, minDate, monthPart, multiply, ne, nil, noop, not, notNull, now, omitExclude, omitPick, omitRORec, or, padLeft, prepare, rand, range, reflex, regex, renamedFields, root, set, setField, single, size, slice, sortArray, spread, spread0, staging, startOf, str, sub, subtract, sym, to, toInt, translateOmit, val, weekPart, wrap, year };
-export type { Accumulators, AddO, And, App, AppMap, AppMapRW, ApplyHKT, Arr, ArrHKT, AsLiteral, ConstHKT, DeepFieldHKT, Delta, DeltaAccumulator, DeltaAccumulatorHKT, DeltaAccumulators, DeltaStages, Equal, Exact, ExactKeys, ExactPart, ExactPart1, ExprHKT, Exprs, ExprsExact, ExprsExactHKT, ExprsPart, FieldHKT, GroupCollection, GroupIdCollection, GroupMergeCollection, GroupMergeOut, HKT, I, ID, IdHKT, JoinId, Loose, MapK, MapKDom, MapKPart1, MapO, MapOPart, MappedHKT, Merge, MergeArgs, MergeHKT, MergeInto, MergeMapOArgs, MergedInput, Model, MongoTypeNames, N, NullToOBJ, O, OPick, OPickD, Patch, PromiseHKT, RConstHKT, RORec, RWCollection, RawStages, Rec, RecHKT, RecordHKT, Replace, SnapshotStreamExecutionResult, StrKey, Strict, TS, UBeforeHKT, WithKey1, WriteonlyCollection, doc, jsonPrim, notArr, µ };
+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';