@omegup/msync 0.1.7 → 0.1.9

package/lib/aggregate/match/$match-delta.d.ts

@@ -0,0 +1,3 @@
+import type { doc } from '../../../types';
+import type { Delta, Expr } from '../../types';
+export declare const $matchDelta: <T extends doc>(query: Expr<boolean, T>) => import("../../types").RawStages<unknown, Delta<T>, Delta<T>, unknown, number>;

package/lib/aggregate/match/$match.d.ts

@@ -0,0 +1,3 @@
+import type { doc } from '../../../types';
+import type { DeltaStages, Expr } from '../../types';
+export declare const $match: <T extends doc>(query: Expr<boolean, T>) => DeltaStages<T, T, T>;

package/lib/aggregate/match/index.d.ts

@@ -0,0 +1,2 @@
+export { $matchDelta } from './$match-delta';
+export { $match } from './$match';

package/lib/aggregate/mongo-stages.d.ts

@@ -0,0 +1,13 @@
+import type { Arr, O, Rec } from '../../types';
+import type { Accumulators, Expr, LookupArgs, Query, RawStages } from '../types';
+import type { Updater } from '../update/updater';
+export * from './raws';
+type s = string;
+export declare const $match_: <Q, T extends Q & O, C = unknown>(query?: Query<T, C>) => RawStages<O<T>, T, T, C>;
+export declare const $set_: <Q, T extends Q & O, V extends Q & O, C = unknown>(updater: Updater<T, T, V, C>) => RawStages<O<Q>, T, V, C, 1>;
+export declare const $replaceWith_: <T extends O, V extends O, C = unknown>(expr: Expr<V, T, C>) => RawStages<O, T, V, C, 1>;
+export declare const $unwind_: <T extends O, K extends s, U, Null extends null = never>(k: K, includeNull?: Null) => RawStages<O<T>, T & Rec<K, Arr<U>>, T & Rec<K, Null | U>>;
+export 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>;
+export declare const $documents_: <T extends O, C>(docs: Expr<Arr<T>, unknown, C>) => RawStages<unknown, null, T, C, 1>;
+export declare const $project_: <T extends O, K extends import("../..").StrKey<T>>(projection: import("../utils").ExactKeys<K>) => RawStages<T, T, T, unknown, 1>;
+export declare const $simpleLookup_: <T extends O, U extends O, R, K extends s, Ctx, C = unknown, S = string>(args: LookupArgs<T, U, R, K, Ctx, C, S>) => RawStages<O<T>, T, T & Rec<K, Arr<U>>, C, 1>;

package/lib/aggregate/out.d.ts

@@ -0,0 +1,37 @@
+import type { O, RWCollection, ReadonlyCollection, Replace, jsonItem } from '../../types';
+import type { ExprsExact } from '../expression/concat';
+import { type Field } from '../field';
+import type { RawStages } from '../types';
+export type MergeInto<T extends O, Out extends O, E = unknown> = {
+    whenNotMatched: 'insert';
+    into: RWCollection<T, Out>;
+} | {
+    whenNotMatched: 'discard' | 'fail';
+    into: ReadonlyCollection<Out> & E;
+};
+export 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>;
+});
+export 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>;
+export 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>;

package/lib/aggregate/prefix.d.ts

@@ -0,0 +1,33 @@
+import type { App, HKT, O2, O3, O, RawObj } from '../../types';
+import type { Delta, DeltaStages, FRawStages, RawStages, Stream, TStages } from '../types';
+import type { Equal } from '../utils/guard';
+type n = number;
+export declare const asStages: <Q, T extends Q, V extends Q, C = unknown, M extends n = number>(x: readonly RawObj[]) => RawStages<Q, T, V, C, M>;
+export declare const same: <T extends Dom, V extends Dom, F extends HKT<Dom, Q>, Dom = unknown, Q = unknown, C = unknown, M extends n = number>(_: Equal<Dom, T, V>) => RawStages<Q, App<F, T>, App<F, V>, C, M>;
+export declare const concatStages: <Q, T extends Q, V extends Q, W extends Q, C, M extends n = number>(part1: RawStages<Q, T, V, C, M>, part2: RawStages<Q, V, W, C, M>) => RawStages<Q, T, W, C, M>;
+export declare const concatFStages: <Q, T extends Q & O, V extends Q & O, W extends Q & O, C, M extends n = number>(part1: FRawStages<Q, T, V, C, M>, part2: FRawStages<Q, V, W, C, M>) => FRawStages<Q, T, W, C, M>;
+export declare const concatDelta: <Q extends O, T extends Q, V extends Q, W extends Q>(part1: DeltaStages<Q, T, V>, part2: DeltaStages<Q, V, W>) => DeltaStages<Q, T, W>;
+export type Concat<out Q, in T extends Q, out V extends Q, in out C, in out M extends n = n> = {
+    with: <Q2, W extends Q2>(extra: RawStages<Q | Q2, V, W, C, M>) => Concat<Q | Q2, T, W, C, M>;
+    stages: RawStages<Q, T, V, C, M>;
+};
+type FConcat<out Q, in T extends Q & O, out V extends Q & O, in out C, in out M extends n = n> = {
+    with: <Q2, W extends Q2 & O>(extra: FRawStages<Q | Q2, V, W, C, M>) => FConcat<Q | Q2, T, W, C, M>;
+    stages: FRawStages<Q, T, V, C, M>;
+};
+export 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]>;
+};
+export declare const pipe: <Q extends O, S extends Q, T extends Q, F extends HKT<O2>, G extends HKT<O3>>(stream: Stream<Q, S, F, G>, s: App<G, [Q, S, T]>, concat: <Q_1 extends O, T_1 extends Q_1, V extends Q_1, W extends Q_1>(part1: App<G, [Q_1, T_1, V]>, part2: App<G, [Q_1, V, W]>) => App<G, [Q_1, T_1, W]>, empty: <T_2 extends Q>() => App<G, [Q, T_2, T_2]>) => DeltaPipe<Q, T, F, G>;
+type Link = <T, C = unknown, M extends n = n>() => Concat<T, T, T, C, M>;
+type FLink = <T extends O, C = unknown, M extends n = n>() => FConcat<T, T, T, C, M>;
+export declare const link: Link;
+export declare const flink: FLink;
+export 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>;
+};
+export declare const concatTStages: <S, Q, B extends Q, T extends Q, V extends Q>({ coll, exec, input }: TStages<S, Q, B, T>, stages: RawStages<Q, T, V>) => TStages<S, Q, B, V>;
+export {};

package/lib/aggregate/raws.d.ts

@@ -0,0 +1,17 @@
+import type { App, Arr, ConstHKT, HKT, O, Rec, StrKey, rawItem } from '../../types';
+import type { ExprsExact } from '../expression/concat';
+import { type Field } from '../field';
+import type { Accumulators, Expr, FRawStages, LookupArgs, Query, RawStages } from '../types';
+import type { Updater } from '../update/updater';
+import { type ExactKeys } from '../utils/map-object';
+type s = string;
+export declare const $match1: <T extends O, C = unknown>(query?: Query<T, C>) => FRawStages<T, T, T, C>;
+export declare const $set1: <Q, T extends Q & O, V extends Q & O, C = unknown>(updater: Updater<T, T, V, C>) => FRawStages<Q, T, V, C, 1>;
+export declare const $project1: <T extends O, K extends StrKey<T>>(projection: ExactKeys<K>) => RawStages<T, T, T, unknown, 1>;
+export declare const $replaceWith1: <T extends O, V extends O, C = unknown>(expr: Expr<V, T, C>) => FRawStages<O, T, V, C, 1>;
+export declare const $unwind1: <T extends O, K extends s, R, Null extends null = never>(k: K, includeNull?: Null) => FRawStages<T, T & Rec<K, Arr<R>>, T & Rec<K, R | Null>>;
+export declare const $group1: <T extends O, ID, V extends O, C>(id: Expr<ID, T, C>, args: Accumulators<T, V, C>) => <F extends HKT<O, O>>(f: <T_1 extends O>() => Field<App<F, T_1>, T_1>) => RawStages<O, App<F, T>, Rec<"_id", ID> & V, C, 1>;
+export declare const $documents1: <Q extends O, T extends Q & O, C>(docs: Expr<Arr<T>, unknown, C>) => <F extends HKT<O, O>>(f: <T_1 extends O>() => Field<App<F, T_1>, T_1>) => RawStages<unknown, null, App<F, T>, C, 1>;
+export declare const rawVars: <T, Ctx, C, V extends O>(vars: ExprsExact<Ctx, T, C>, f: Field<V, T, unknown>) => import("../utils/map-object").ExactPart1<Ctx, ConstHKT<rawItem, unknown>>;
+export declare const $simpleLookup1: <T extends O, U extends O, R, K extends s, Ctx, C = unknown, S = string>(args: LookupArgs<T, U, R, K, Ctx, C, S>) => FRawStages<T, T, T & Rec<K, Arr<U>>, C, 1>;
+export {};

package/lib/aggregate/set/$replace-with-each.d.ts

@@ -0,0 +1,13 @@
+import type { ConstHKT, HKT, I, N, O, RORec, Rec, jsonItem } from '../../../types';
+import type { BA, Delta, Expr, FRawStages, RawStages } from '../../types';
+import { type Updater } from '../../update/updater';
+import { type MapK } from '../../utils/map-object';
+export interface ParDeltaHKT<K extends BA, T extends jsonItem, E> extends HKT<jsonItem> {
+    readonly out: RORec<K, I<jsonItem, this>> & Delta<T> & E;
+}
+type Delta2<T extends jsonItem, BA2 extends string> = Delta<T> & Partial<RORec<BA2, T | null>>;
+export declare const $setEach1: <T extends jsonItem, V extends jsonItem, BA2 extends string, E = unknown, C = unknown>(updater: (k: BA) => Updater<Delta<T> & Partial<RORec<BA2, T | null>> & E, T | N, V | null, C>, dict: MapK<BA2, ConstHKT<BA>>) => FRawStages<unknown, Delta2<T, BA2> & E, Rec<BA2, V | null> & Omit<Delta<T> & E, BA2>, C, 1>;
+export declare const $setEach: <T extends O, V extends jsonItem, BA2 extends string, E = unknown, C = unknown>(updater: (k: BA) => Updater<Delta<T> & E, T | N, V | null, C>, dict: MapK<BA2, ConstHKT<BA>>) => RawStages<unknown, Delta2<T, BA2> & E, Rec<BA2, V | null> & Omit<Delta<T> & E, BA2>, C, 1>;
+export declare const $replaceWithEach1: <T extends O, V extends jsonItem, E = unknown>(t: <K extends BA>(field: K) => Expr<V | null, Delta<T> & E>) => RawStages<unknown, Delta<T> & E, Delta<V> & Omit<E, BA>>;
+export declare const $replaceWithEach: <T extends O, V extends jsonItem, E = unknown>(expr: <K extends BA>(field: K) => Expr<V | null, Rec<K, T> & Delta<T> & E>) => RawStages<unknown, Delta<T> & E, Delta<V> & Omit<E, BA>>;
+export {};

package/lib/aggregate/set/$set-delta.d.ts

@@ -0,0 +1,5 @@
+import type { O, jsonItem } from '../../../types';
+import type { Delta, Expr, RawStages } from '../../types';
+import { type Updater } from '../../update/updater';
+export declare const $replaceWithDelta: <T extends O, V extends jsonItem>(expr: Expr<V, T>) => RawStages<unknown, Delta<T>, Delta<V>>;
+export declare const $setDelta: <T extends O, V extends O, C = unknown>(updater: Updater<T, T, V, C>) => RawStages<unknown, Delta<T>, Delta<V>, C, number>;

package/lib/aggregate/set/$set.d.ts

@@ -0,0 +1,6 @@
+import type { O, Replace } from '../../../types';
+import type { DeltaStages, Expr, LinStages } from '../../types';
+import { type UpdaterHKT } from '../../update/updater';
+import type { MapO } from '../../utils/map-object';
+export 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>;
+export declare const $replaceWith: <T extends O, V extends O>(expr: Expr<V, T>) => DeltaStages<O, T, V> & LinStages<O, T, V>;

package/lib/aggregate/set/index.d.ts

@@ -0,0 +1 @@
+export { $replaceWith, $set } from './$set';

package/lib/aggregate/unwind/$unwind-delta.d.ts

@@ -0,0 +1,5 @@
+import type { Arr, AsLiteral, ID, Rec, doc } from '../../../types';
+import type { Delta, RawStages } from '../../types';
+type s = string;
+export declare const $unwindDelta: <K1 extends s, T extends doc, K2 extends s, 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>>;
+export {};

package/lib/aggregate/unwind/index.d.ts

@@ -0,0 +1,6 @@
+import type { Arr, AsLiteral, doc, O, Rec, RORec } from '../../../types';
+import type { DeltaStages } from '../../types';
+export { $unwindDelta } from './$unwind-delta';
+type s = string;
+type TOf<TT, K extends string> = doc & Omit<TT, K>;
+export 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>>;

package/lib/boot/boot-simpl.d.ts

@@ -0,0 +1,14 @@
+import type { O2, O3, OPickD, RORec, StrKey, View } from '../../types';
+import type { HKT, I } from '../../types/hkt';
+import type { RawStages } from '../types';
+import type { Model, SimpleStreamExecutionResult } from '../types/stream';
+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>>;
+}
+export declare const from: <V extends Model, KK extends StrKey<V>>(view: View<V, Allowed<KK>>, streamName: string, needs?: Partial<Record<KK, 0 | 1>>) => import("../aggregate/prefix").DeltaPipe<AllowedPick<V, KK>, AllowedPick<V, KK>, StreamRunnerHKT, StagesHKT>;
+export {};

package/lib/boot/boot-utils.d.ts

@@ -0,0 +1,26 @@
+import { Collection, type Timestamp } from 'mongodb';
+import type { BSON, OPickD, rawItem, RawObj, StrKey } from '../../types';
+import type { Actions, Model } from '../types/stream';
+export type AllowedPick<V extends Model, K extends StrKey<V>> = OPickD<V, Allowed<K>>;
+export type Allowed<K> = Exclude<K, 'deletedAt' | '_id'>;
+export type Teardown = {
+    collection: string;
+    method: string;
+    params: unknown[];
+};
+export type TsData = {
+    input: readonly RawObj[];
+    finalInput: readonly RawObj[];
+    finalInputFirst: readonly RawObj[];
+    project: rawItem;
+    match: rawItem;
+    teardown: Teardown;
+};
+export type Last = {
+    _id: string;
+    ts: Timestamp;
+    data?: TsData;
+};
+export declare const actions: {
+    [K in keyof Actions<unknown>]: <W extends BSON.Document>(col: Collection<W>, x: Actions<W>[K]) => [Promise<unknown>, unknown[]];
+};

package/lib/boot/boot.d.ts

@@ -0,0 +1,16 @@
+import type { O2, O3, StrKey, View } from '../../types';
+import type { HKT, I } from '../../types/hkt';
+import { type DeltaPipe } from '../aggregate/prefix';
+import type { SnapshotStreamExecutionResult } from '../types';
+import type { DeltaStages, Model } from '../types/stream';
+import type { Allowed, AllowedPick } from './boot-utils';
+export declare const streamNames: Record<string, string>;
+export interface SnapshotStreamHKT extends HKT<O2> {
+    readonly out: SnapshotStreamExecutionResult<I<O2, this>[0], I<O2, this>[1]>;
+}
+export interface DeltaHKT extends HKT<O3> {
+    readonly out: DeltaStages<I<O3, this>[0], I<O3, this>[1], I<O3, this>[2]>;
+}
+export declare const staging: <V extends Model, KK extends StrKey<V>>(view: View<V, Allowed<KK>> & {
+    needs?: Partial<Record<KK, 0 | 1>>;
+}, streamName: string, skip?: boolean, after?: () => Promise<void>) => DeltaPipe<AllowedPick<V, KK>, AllowedPick<V, KK>, SnapshotStreamHKT, DeltaHKT>;

package/lib/boot/first-stages.d.ts

@@ -0,0 +1,12 @@
+import { type Timestamp } from 'mongodb';
+import type { O, StrKey, View } from '../../types';
+import { type Concat } from '../aggregate/prefix';
+import type { Query } from '../types';
+import type { Del, Model } from '../types/stream';
+import type { Allowed } from './boot-utils';
+export declare const getFirstStages: <V extends Model, KK extends StrKey<V>>(view: View<V, Allowed<KK>>, needs: Partial<Record<KK, 0 | 1>>) => {
+    firstStages: (lastTS: {
+        ts: Timestamp;
+    } | null, keepNulls?: boolean) => Concat<V | O | Del, Del | V, V, unknown>;
+    hardMatch: Query<V> | undefined;
+};

package/lib/boot/index.d.ts

@@ -0,0 +1,3 @@
+export { staging } from './boot';
+export { from } from './boot-simpl';
+export { single } from './single';

package/lib/boot/single.d.ts

@@ -0,0 +1,11 @@
+import type { O2, StrKey, View } from '../../types';
+import type { HKT, I } from '../../types/hkt';
+import { type DeltaPipe } from '../aggregate/prefix';
+import type { Model, RawStages, Stages } from '../types/stream';
+import type { DeltaHKT } from './boot';
+import type { Allowed, AllowedPick } from './boot-utils';
+export type SingleResult<out Result> = <Result2>(finalInput: RawStages<unknown, Result, Result2>) => Stages<unknown, Result2, unknown>;
+export interface SnapshotStreamHKT2 extends HKT<O2> {
+    readonly out: SingleResult<I<O2, this>[1]>;
+}
+export declare const single: <V extends Model, KK extends StrKey<V>>(view: View<V, Allowed<KK>>, needs?: Partial<Record<KK, 0 | 1>>) => DeltaPipe<AllowedPick<V, KK>, AllowedPick<V, KK>, SnapshotStreamHKT2, DeltaHKT>;

package/lib/expression/arith.d.ts

@@ -0,0 +1,32 @@
+import type { Expr } from '../types';
+export declare const max: <D, C>(...expr: Expr<number, D, C>[]) => Expr<number, D, C>;
+export 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>;
+};
+export 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>;
+};
+export 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>;
+};
+export 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;
+export declare function subtract<D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<number, D, C>;
+export declare function subtract<D, C>(...expr: [Expr<Num, D, C>, Expr<Num, D, C>]): Expr<Num, D, C>;
+export declare function add<D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<number, D, C>;
+export declare function add<D, C>(...expr: [Expr<Num, D, C>, Expr<Num, D, C>]): Expr<Num, D, C>;
+export declare function divide<D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<number, D, C>;
+export declare function divide<D, C>(...expr: [Expr<Num, D, C>, Expr<Num, D, C>]): Expr<Num, D, C>;
+export declare function multiply<D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<number, D, C>;
+export declare function multiply<D, C>(...expr: [Expr<Num, D, C>, Expr<Num, D, C>]): Expr<Num, D, C>;
+export declare function floor<D, C>(expr: Expr<number, D, C>): Expr<number, D, C>;
+export declare function floor<D, C>(expr: Expr<Num, D, C>): Expr<Num, D, C>;
+export declare function ceil<D, C>(expr: Expr<number, D, C>): Expr<number, D, C>;
+export declare function ceil<D, C>(expr: Expr<Num, D, C>): Expr<Num, D, C>;
+export {};

package/lib/expression/array.d.ts

@@ -0,0 +1,30 @@
+import type { App, Arr, HKT, N, O, RORec, notArr } from '../../types';
+import type { Expr } from '../types';
+export declare const size: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<number, D, C>;
+export declare const filterDefined: <T, D, C = unknown>(expr: Expr<Arr<T | N>, D, C>) => Expr<Arr<T>, D, C>;
+export 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>;
+export 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>;
+export 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>) => import("../types").BoolExpr<D & App<F, Arr<T>>, D & App<F, T>, C>;
+export declare const inArray: <T, D, C>(item: Expr<T, D, C>, expr: Expr<Arr<T>, D, C>) => Expr<boolean, D, C>;
+export declare const array: <T, D, C = unknown>(...exprs: Expr<T, D, C>[]) => Expr<Arr<T>, D, C>;
+export declare const concatArray: <T, D, C>(...exprs: Expr<Arr<T>, D, C>[]) => Expr<Arr<T>, D, C>;
+export declare const first: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
+export declare const firstSure: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T, D, C>;
+export declare const last: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
+export type NullToOBJ<N extends null> = N extends null ? O : N;
+export 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>;
+export 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>;
+export 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>;
+export 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>;
+export declare const except: <T, D, C>(a: Expr<Arr<T>, D, C>, b: Expr<Arr<T>, D, C>) => Expr<Arr<T>, D, C>;
+export {};

package/lib/expression/concat.d.ts

@@ -0,0 +1,34 @@
+import type { App, HKT, I, IdHKT, N, O, RORec, StrKey } from '../../types';
+import type { Expr } from '../types';
+import { type Exact, type ExactPart, type MapO, type MergeHKT } from '../utils/map-object';
+export 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>;
+};
+export declare const regex: <D, C>(expr: Expr<string, D, C>, regex: Expr<string, D, C>, options?: Expr<string, D, C>) => Expr<boolean, D, C>;
+export declare const str: <D, C>(expr: Expr<unknown, D, C>) => Expr<string, D, C>;
+export declare const toInt: <D, C>(expr: Expr<unknown, D, C>) => Expr<number, D, C>;
+export 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>;
+export type Exprs<out T, in D, in C = unknown> = {
+    readonly [K in StrKey<T>]: Expr<T[K], D, C>;
+};
+type MergeExactArgs<T1, T2, F extends HKT<T1[StrKey<T1>] | T2[StrKey<T2>]>> = readonly [
+    Exact<Omit<T1, keyof T2>, F>,
+    Exact<T2, F>
+];
+export 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>;
+export 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>];
+export 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>>>;
+export 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>;
+export type ExprsPart<T, D, C> = ExactPart<T, ExprHKT<D, C>>;
+export interface ExprHKT<D, C = unknown, F extends HKT = IdHKT> extends HKT<unknown> {
+    readonly out: Expr<App<F, I<unknown, this>>, D, C>;
+}
+export type ExprsExact<T, D, C = unknown, F extends HKT = IdHKT> = Exact<T, ExprHKT<D, C, F>>;
+export interface ExprsExactHKT<E, D, C = unknown, F extends HKT = IdHKT> extends HKT {
+    readonly out: ExprsExact<E & I<unknown, this>, D, C, F>;
+}
+export declare const pair: <T, D, C, P extends StrKey<T>>(k: P, v: Expr<T[P], D, C>) => ExprsExact<T, D, C>[P];
+export 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>;
+export declare const field: <T extends object, D, C = unknown>(exprs: ExprsExact<T, D, C>) => Expr<O<T>, D, C>;
+export {};

package/lib/expression/date.d.ts

@@ -0,0 +1,17 @@
+import type { Arr } from '../../types';
+import type { Expr } from '../types';
+export declare const dayAndMonthPart: <D, C>(date: Expr<Date, D, C>) => Expr<string, D, C>;
+export declare const now: <D, C>() => Expr<Date, D, C>;
+export declare const monthPart: <D, C>(date: Expr<Date, D, C>) => Expr<string, D, C>;
+export declare const weekPart: <D, C>(date: Expr<Date, D, C>) => Expr<string, D, C>;
+export declare const year: <D, C>(date: Expr<Date, D, C>) => Expr<number, D, C>;
+export 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>;
+export declare const maxDate: <D, C>(expr: Expr<Arr<Date>, D, C>) => Expr<Date, D, C>;
+export declare const minDate: <D, C>(expr: Expr<Arr<Date>, D, C>) => Expr<Date, D, C>;
+export declare const datePart: <D, C>(date: Expr<Date, D, C>) => Expr<string, D, C>;
+export 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>;
+export 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>;

package/lib/expression/expr-base.d.ts

@@ -0,0 +1,5 @@
+import type { rawItem } from '../../types';
+import type { BoolExpr, Expr, ExprRaw } from '../types';
+export declare const asExprRaw: <T, Doc, Ctx>(raw: rawItem) => ExprRaw<T, Doc, Ctx>;
+export declare const asExpr: <T, Doc, Ctx = unknown>(r: Pick<Expr<T, Doc, Ctx>, "raw">) => Expr<T, Doc, Ctx>;
+export declare const asBoolExpr: <D1, D2, Ctx = unknown>(r: Pick<BoolExpr<D1, D2, Ctx>, "raw">) => BoolExpr<D1, D2, Ctx>;

package/lib/expression/index.d.ts

@@ -0,0 +1,7 @@
+export * from './arith';
+export * from './array';
+export * from './date';
+export * from './logic';
+export * from './concat';
+export * from './range';
+export * from './val';

package/lib/expression/logic.d.ts

@@ -0,0 +1,23 @@
+import type { App, HKT, O, jsonItem, rawItem } from '../../types';
+import type { Field } from '../field';
+import type { BoolExpr, Expr } from '../types';
+export 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>;
+};
+export declare const and: <D, C = unknown>(...expr: Expr<boolean, D, C>[]) => Expr<boolean, D, C>;
+export declare const or: <D, C = unknown>(...expr: Expr<boolean, D, C>[]) => Expr<boolean, D, C>;
+export declare const not: <D, C = unknown>(expr: Expr<boolean, D, C>) => Expr<boolean, D, C>;
+export declare const eq: <T, D, C = unknown>(a: Expr<T, D, C>) => (b: Expr<T, D, C>) => Expr<boolean, D, C>;
+export declare const sub: <T, D, Ctx, P extends O>(a: Expr<T, D, Ctx>, f: Field<P, D, Ctx>) => Expr<T, P, Ctx>;
+export 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>;
+export declare const ne: <T, D, C>(a: Expr<T, D, C>) => <K>(b: Expr<K, D, C>) => Expr<boolean, D, C>;
+export declare const notNull: <T, D, C>(a: Expr<T, D, C>) => Expr<boolean, D, C>;
+export declare const $ifNull: <R, D, C>(...expr: [...Expr<R | null | undefined, D, C>[], Expr<R, D, C>]) => Expr<R, D, C>;
+export 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>;
+export 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>;
+export 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>;

package/lib/expression/range.d.ts

@@ -0,0 +1,11 @@
+import type { Arr, RORec } from '../../types';
+import { Field } from '../field';
+import type { Expr } from '../types';
+export 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>;
+export 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>;
+export 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>;
+export 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>;

package/lib/expression/val.d.ts

@@ -0,0 +1,25 @@
+import type { Timestamp } from 'mongodb';
+import type { Arr, N, O, RORec, StrKey, jsonItem, rawItem } from '../../types';
+import type { Expr } from '../types';
+import type { ExprsExact } from './concat';
+export declare const val: <T extends rawItem>(val: T) => Expr<T, unknown>;
+export declare const current: Expr<Timestamp, unknown>;
+export 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>;
+export declare const nil: Expr<null, unknown>;
+export 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>;
+};
+export 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;
+export 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;
+export 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>;
+export declare const rand: () => string;
+export declare const $rand: Expr<string, unknown, unknown>;

package/lib/field/field.d.ts

@@ -0,0 +1,25 @@
+import type { Arr, AsLiteral, N, O, RORec, Undef } from '../../types';
+import type { Expr, Query } from '../types';
+import type { Predicate } from '../types/predicate';
+export 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>;
+}
+export declare const root: <T extends O>() => Field<T, T, unknown>, ctx: <T>() => <K extends string>(k: K) => Field<unknown, T, RORec<K, T>>;

package/lib/field/index.d.ts

@@ -0,0 +1 @@
+export * from './field';

package/lib/machine.d.ts

@@ -0,0 +1,9 @@
+import type { Iterator, HasJob } from './types';
+export 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>;
+}
+export declare const wrap: <Result>(root: Machine<Result>) => Machine<Result>;

package/lib/predicate/$eq.d.ts

@@ -0,0 +1,24 @@
+import type { Timestamp } from 'mongodb';
+import type { N, rawItem, RawObj } from '../../types';
+export declare const $eq: <T extends unknown>(operand: rawItem & T) => import("../types").Predicate<T>;
+export declare const $ne: <T extends unknown>(operand: rawItem & T) => import("../types").Predicate<T>;
+type Numeric = number | Timestamp | Date;
+export declare const comp: <D2 extends Numeric = Numeric>(op: "$lt" | "$gt" | "$lte" | "$gte") => <T extends Numeric>(operand: rawItem & D2) => import("../types").Predicate<D2>;
+export declare const $gt: <T extends Numeric>(operand: rawItem & Numeric) => import("../types").Predicate<Numeric>;
+export declare const $gtTs: <T extends Numeric>(operand: rawItem & Timestamp) => import("../types").Predicate<Timestamp>;
+export declare const $gteTs: <T extends Numeric>(operand: rawItem & Timestamp) => import("../types").Predicate<Timestamp>;
+export declare const $lt: <T extends Numeric>(operand: rawItem & number) => import("../types").Predicate<number>;
+export declare const dateLt: <T extends Numeric>(operand: rawItem & Date) => import("../types").Predicate<Date>;
+export declare const $gte: <T extends Numeric>(operand: rawItem & number) => import("../types").Predicate<number>;
+export declare const $lte: <T extends Numeric>(operand: rawItem & number) => import("../types").Predicate<number>;
+type MongoTypes = {
+    number: number;
+    array: readonly rawItem[];
+    string: string;
+    object: RawObj;
+    [i: number]: unknown;
+};
+export type MongoTypeNames = keyof MongoTypes;
+export declare const $type: <T extends keyof MongoTypes>(operand: rawItem & readonly T[]) => import("../types").Predicate<N | MongoTypes[T]>;
+export declare const $exists: <T extends keyof MongoTypes>(operand: rawItem & boolean) => import("../types").Predicate<unknown>;
+export {};

package/lib/predicate/$expr.d.ts

@@ -0,0 +1,3 @@
+import type { O } from '../../types';
+import type { Expr, Query } from '../types';
+export declare const $expr: <D extends O, C>(expr: Expr<boolean, D, C>) => Query<D, C>;

package/lib/predicate/$in.d.ts

@@ -0,0 +1,2 @@
+export declare const $in: <T extends unknown>(operand: import("../../types").rawItem & readonly T[]) => import("../types").Predicate<T>;
+export declare const $nin: <T extends unknown>(operand: import("../../types").rawItem & readonly T[]) => import("../types").Predicate<T>;

package/lib/predicate/index.d.ts

@@ -0,0 +1,3 @@
+export * from './$eq';
+export * from './$expr';
+export * from './$in';

package/lib/predicate/utils.d.ts

@@ -0,0 +1,5 @@
+import type { App, HKT, rawItem } from '../../types';
+import type { Predicate } from '../types';
+type Operators = '$eq' | '$ne' | '$gt' | '$gte' | '$lt' | '$lte' | '$in' | '$nin' | '$type' | '$exists';
+export declare const operator: <K extends Operators, F extends HKT<Dom2, HKT<Dom1, unknown>>, Dom1, Dom2 = Dom1, G extends HKT<Dom2, HKT<Dom1, unknown>> = F>() => <D2 extends Dom2 = Dom2>(op: K) => <T extends Dom1>(operand: rawItem & App<App<F, D2>, T>) => Predicate<App<App<G, D2>, T>>;
+export {};

package/lib/query/index.d.ts

@@ -0,0 +1 @@
+export { $and, $nor, $or } from './logic';

package/lib/query/logic.d.ts

@@ -0,0 +1,11 @@
+import type { N, O } from '../../types';
+import type { Query } from '../types';
+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;
+};
+export declare const $and: Combiner;
+export declare const $nor: Combiner;
+export declare const $or: Combiner;
+export {};

package/lib/stream/aggregate.d.ts

@@ -0,0 +1,7 @@
+import type { AggregateCommand } from '../types/aggregate';
+import type { ReadonlyCollection } from '../../types';
+import type { RawStages } from '../types';
+export declare const aggregate: <Result>(streamName: string, input: <E>(consume: <S, B>(value: {
+    coll: ReadonlyCollection<S>;
+    input: RawStages<unknown, B, Result>;
+}) => E) => E, snapshot?: boolean, start?: number) => Promise<AggregateCommand<Result>>;