@omegup/msync 0.0.7 → 0.0.9

package/lib/expression/arith.d.ts

@@ -0,0 +1,26 @@
+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_0: Expr<number, D, C>, expr_1: Expr<number, D, C>) => Expr<boolean, D, C>;
+export declare const gt: <D, C>(expr_0: Expr<number, D, C>, expr_1: 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,25 @@
+import type { App, Arr, HKT, N, 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 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 declare const mergeObjects: <T1, T2, D, C = unknown>(exprs_0: Expr<T1, D, C>, exprs_1: Expr<T2, D, C>) => Expr<T1 & T2, D, C>;
+export declare const inArray: <T, D, C = unknown>(exprs_0: Expr<T, D, C>, exprs_1: Expr<Arr<T>, D, C>) => Expr<boolean, 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>;

package/lib/expression/concat.d.ts

@@ -0,0 +1,30 @@
+import type { App, HKT, I, IdHKT, 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>;
+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,16 @@
+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 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,22 @@
+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 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, K, D, C>(a: Expr<T, D, C>) => (b: Expr<K, D, C>) => Expr<boolean, D, C>;
+export declare const notNull: <T, K, 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,6 @@
+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 $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,13 @@
+import { Timestamp } from 'mongodb';
+export declare const $eq: <T extends unknown>(operand: import("../../types").rawItem & T) => import("../types").Predicate<T>;
+export declare const $ne: <T extends unknown>(operand: import("../../types").rawItem & T) => import("../types").Predicate<T>;
+type Numeric = number | Timestamp | Date;
+export declare const comp: <D2 extends Numeric = number>(op: "$lte" | "$gte" | "$lt" | "$gt") => <T extends D2>(operand: import("../../types").rawItem & D2) => import("../types").Predicate<D2>;
+export declare const $gt: <T extends number>(operand: import("../../types").rawItem & number) => import("../types").Predicate<number>;
+export declare const $gtTs: <T extends Timestamp>(operand: import("../../types").rawItem & Timestamp) => import("../types").Predicate<Timestamp>;
+export declare const $gteTs: <T extends Timestamp>(operand: import("../../types").rawItem & Timestamp) => import("../types").Predicate<Timestamp>;
+export declare const $lt: <T extends number>(operand: import("../../types").rawItem & number) => import("../types").Predicate<number>;
+export declare const dateLt: <T extends Date>(operand: import("../../types").rawItem & Date) => import("../types").Predicate<Date>;
+export declare const $gte: <T extends number>(operand: import("../../types").rawItem & number) => import("../types").Predicate<number>;
+export declare const $lte: <T extends number>(operand: import("../../types").rawItem & number) => import("../types").Predicate<number>;
+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';
+export declare const operator: <K extends Operators, F extends HKT<Dom, HKT<Dom, Dom>>, Dom extends unknown, Default extends Dom = Dom, G extends HKT<Dom, HKT<Dom, Dom>> = F>() => <D2 extends Dom = Default>(op: K) => <T extends D2>(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>(input: <E>(consume: <S, B>(value: {
+    coll: ReadonlyCollection<S>;
+    input: RawStages<unknown, B, Result>;
+}) => E) => E, snapshot?: boolean, start?: number) => Promise<AggregateCommand<Result>>;

package/lib/types/accumulator.d.ts

@@ -0,0 +1,30 @@
+import type { Expr } from './expr';
+import type { HKT, I, N, O, RORec, RawObj, Rec, Type, U, Undef, jsonItem } from '../../types';
+import type { Field } from '../field';
+import type { Exact } from '../utils/map-object';
+declare const AccumulatorRaw: unique symbol;
+declare const Accumulator: unique symbol;
+export interface AccumulatorRaw<in Doc, out T, in C = unknown> extends RawObj {
+    [Type](_: typeof AccumulatorRaw, source: Doc, ctx: C): readonly [typeof AccumulatorRaw, T];
+}
+export interface AccumulatorHKT<T, C = unknown> extends HKT<unknown> {
+    readonly out: Accumulator<T, I<unknown, this>, C>;
+}
+export type Accumulators<T, V extends RORec<string, jsonItem>, C = unknown> = Exact<V, AccumulatorHKT<T, C>>;
+export interface DeltaAccumulatorHKT<T, C = unknown> extends HKT<unknown> {
+    readonly out: DeltaAccumulator<T, I<unknown, this>, C>;
+}
+export type DeltaAccumulators<T, V extends RORec<string, jsonItem>, C = unknown> = Exact<V, DeltaAccumulatorHKT<T, C>>;
+export type AccumulatorsRoot<Acc extends Accumulators<never, RORec<string, jsonItem>, never>> = Acc extends Accumulators<infer T extends O, RORec<string, jsonItem>, never> ? T : never;
+export 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>;
+    };
+};
+export type Part<Doc> = Rec<'v', Doc> & RORec<'old', boolean>;
+export 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>;
+};
+export {};

package/lib/types/aggregate.d.ts

@@ -0,0 +1,9 @@
+import type { Long, Timestamp } from 'mongodb';
+export type AggregateCommand<T> = {
+    cursor: {
+        id: Long | number;
+        firstBatch: T[];
+        atClusterTime: Timestamp;
+        ns: string;
+    };
+};

package/lib/types/expr.d.ts

@@ -0,0 +1,27 @@
+import type { O, Type, U, Undef, rawItem } from '../../types';
+import type { Field } from '../field';
+declare const Expr: unique symbol;
+declare const ExprRaw: unique symbol;
+export type ExprRaw<out T, in Doc, in Ctx = unknown> = {
+    [Type]?(x: typeof ExprRaw): void;
+    [ExprRaw]?(doc: Doc, ctx: Ctx): T;
+    get: () => rawItem;
+};
+export 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>;
+    };
+};
+export 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>;
+    };
+};
+export {};

package/lib/types/extern.d.ts

@@ -0,0 +1,3 @@
+export type { Accumulators, DeltaAccumulators, DeltaAccumulator } from './accumulator';
+export type { Expr } from './expr';
+export type { RawStages, SnapshotStreamExecutionResult, TS, Model, Delta } from './stream';

package/lib/types/index.d.ts

@@ -0,0 +1,8 @@
+export * from './machine';
+export * from './query';
+export * from './stream';
+export * from './expr';
+export * from './predicate';
+export * from './accumulator';
+export * from './lookup';
+export * from './aggregate';

package/lib/types/lookup.d.ts

@@ -0,0 +1,19 @@
+import type { AsLiteral, O, ReadonlyCollection } from '../../types';
+import type { ExprsExact } from '../expression/concat';
+import type { Field } from '../field';
+import type { RawStages } from '../types';
+export type LookupArgs<T extends O, U extends O, R, K extends string, Ctx, C, s = string> = {
+    vars: ExprsExact<Ctx, T, C>;
+    k: AsLiteral<K>;
+} & ({
+    coll: ReadonlyCollection<R>;
+    pipeline: RawStages<unknown, R, U, Ctx & C>;
+    fields?: {
+        foreign: Field<R, s>;
+        local: Field<T, s>;
+    };
+} | {
+    coll?: never;
+    pipeline: RawStages<unknown, null, U, Ctx & C>;
+    fields?: never;
+});

package/lib/types/machine.d.ts

@@ -0,0 +1,17 @@
+export type HasJob = {
+    job: object | undefined;
+};
+export type Runner<T, Info extends HasJob> = Iterator<T, Info>;
+export type NextFrame<T, Info> = PromiseLike<Frame<T, Info>>;
+export type Frame<T, Info> = {
+    data: T;
+    info: Info;
+    cont: Iterator<T, Info>;
+};
+export type IteratorResult<out T, out Info> = {
+    next: NextFrame<T, Info>;
+    stop: Iterator<T, Info>;
+    clear: () => Promise<void>;
+};
+export type Iterator<out T, out Info> = () => IteratorResult<T, Info>;
+export type AsynIter<T> = readonly [T, () => PromiseLike<AsynIter<T>>];

package/lib/types/predicate.d.ts

@@ -0,0 +1,14 @@
+import type { Expr } from '../types';
+import type { Type, RawObj, O } from '../../types';
+import type { Field } from '../field';
+declare const Predicate: unique symbol;
+declare const PredicateRaw: unique symbol;
+export type PredicateRaw = RawObj & {
+    [Type]?(x: typeof PredicateRaw): void;
+};
+export interface Predicate<in V> {
+    [Type]?(x: typeof Predicate, _: V): void;
+    raw: PredicateRaw;
+    expr: <D extends O, C>(field: Field<D, V, C>) => Expr<boolean, D, C>;
+}
+export {};

package/lib/types/query.d.ts

@@ -0,0 +1,12 @@
+import type { O, RawObj, Type } from '../../types';
+import type { Field } from '../field';
+declare const Query: unique symbol;
+declare const QueryRaw: unique symbol;
+export type QueryRaw<T, C> = RawObj & {
+    [Type]?(x: typeof QueryRaw, y: T, c: C): void;
+};
+export 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>;
+};
+export {};

package/lib/types/stream.d.ts

@@ -0,0 +1,55 @@
+import type { Timestamp } from 'mongodb';
+import type { App, HKT, ID, O, RawObj, ReadonlyCollection, Rec, Type } from '../../types';
+import type { Field } from '../field';
+import type { HasJob, Runner } from './machine';
+declare const RawStage: unique symbol;
+type RawArr = readonly RawObj[];
+export interface RawStages<out Q, in S extends Q, out R extends Q, in C = unknown, out M = number> extends RawArr {
+    [Type]?(_: typeof RawStage, source: S, ctx: C, q: Q): readonly [typeof RawStage, R, M, Q];
+}
+export 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>;
+export 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>;
+};
+export type LinStages<out Q, in S extends Q, out R extends Q, in C = unknown> = {
+    lin: RawStages<Q, S, R, C, 1>;
+};
+export type TStages<in out S, out Q, in out B extends Q, out R extends Q, M extends number = number> = {
+    coll: ReadonlyCollection<S>;
+    input: RawStages<unknown, S, B, unknown, M>;
+    exec: RawStages<Q, B, R, unknown, M>;
+};
+export 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;
+export type StreamRunner<out V> = <Result>(input: RawStages<unknown, V, Result>) => Runner<readonly Result[], HasJob>;
+export type SimpleStreamExecutionResult<out Q, out V extends Q> = {
+    readonly out: StreamRunner<V>;
+};
+export type SnapshotStreamExecutionResult<out Q, out V extends Q> = {
+    readonly out: StreamRunner<Delta<V>>;
+    readonly stages: Stages<Before<Q>, Before<V>, UBefore<Q>>;
+};
+export 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]>;
+export type TS = {
+    readonly touchedAt: Timestamp;
+};
+export type Del = O<{
+    readonly deletedAt: Timestamp;
+} & ID & TS>;
+export type D = O<{
+    readonly deletedAt?: Timestamp | null | undefined;
+} & ID>;
+export type Model = D & TS;
+export type OutInput<T, A = T | null> = ID & Rec<'after', A>;
+export type SimpleStream<in out Q extends O, out T extends Q> = <Q2 extends O, Result extends Q2>(input: LinStages<Q2 | T, T, Result>) => SimpleStreamExecutionResult<Q | Q2, Result>;
+export type BA = 'before' | 'after';
+export type PreDelta<T, K extends BA = BA, E = unknown> = Rec<K, T> & E;
+export type Delta<T, K extends BA = BA, E = ID> = PreDelta<T | null, K, E>;
+export type Before<T> = PreDelta<T, 'before'>;
+export type After<T> = Delta<T, 'after'>;
+export type UBefore<T> = O & Partial<Delta<T | null, 'before'>>;
+export type UDelta<T, E = {
+    readonly updated: boolean;
+}> = Delta<T, 'after', ID> & UBefore<T> & E;
+export 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>;
+export {};

package/lib/update/index.d.ts

@@ -0,0 +1 @@
+export { set, to } from './updater';

package/lib/update/updater.d.ts

@@ -0,0 +1,19 @@
+import type { Arr, HKT, I, N, O, StrKey, Type, notArr, rawItem } from '../../types';
+import { Field } from '../field';
+import type { Expr } from '../types';
+import { type MapO } from '../utils/map-object';
+declare const Updater: unique symbol;
+export 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])[];
+};
+export declare const subUpdater: <P extends O, D, T, V, Ctx>(a: Updater<D, T, V, Ctx>, f: Field<P, D>) => Updater<P, T, V, Ctx>;
+export interface UpdaterHKT<R, Old, V, C, K extends keyof Old = keyof Old, V2 extends V = V> extends HKT<StrKey<V>> {
+    readonly out: Updater<R, Get<Old, I<StrKey<V>, this>, K>, V2[I<StrKey<V>, this>], C>;
+}
+export type Get<T, P extends string, K extends keyof T = never> = P extends K ? T[P] : P extends keyof T ? T[P] : undefined;
+export declare const set: <V>() => <R, Old extends notArr, C = unknown, K extends keyof Old = never>(fields: MapO<V, UpdaterHKT<R, Old, V, C, K>>) => Updater<R, Old, O & Omit<Old, StrKey<V>> & V, C> & Updater<R, Arr<Old>, Arr<Omit<Old, StrKey<V>> & V>, C>;
+export declare const weaken: <R, T, V, C = unknown>(updater: Updater<R, T, V, C>) => Updater<R | null, T | N, V | null, C>;
+export declare const to: <R, V, C = unknown, T = unknown>(expr: Expr<V, R, C>) => Updater<R, T, V, C>;
+export declare const items: <R, T, V, C = unknown>(x: Updater<R, T, V, C>) => Updater<R, Arr<T>, Arr<V>, C>;
+export {};

package/lib/utils/before.d.ts

@@ -0,0 +1,3 @@
+import type { O } from '../../types';
+import type { Before, FRawStages, RawStages } from '../types';
+export declare const asBefore: <Q extends O, S extends Q, R extends Q, C = unknown>(f: FRawStages<Q, S, R, C>) => RawStages<Before<Q>, Before<S>, Before<R>, C>;

package/lib/utils/coll.d.ts

@@ -0,0 +1,5 @@
+import type { ReadonlyCollection, WriteonlyCollection } from '../../types';
+export declare const dbcoll: (x: ReadonlyCollection<unknown> | WriteonlyCollection<never>) => {
+    db: string;
+    coll: string;
+};

package/lib/utils/db-indexes.d.ts

@@ -0,0 +1,4 @@
+import type { Collection, CreateIndexesOptions, IndexSpecification } from 'mongodb';
+export declare const createIndex: (collection: {
+    readonly createIndex: Collection["createIndex"];
+}, indexSpec: IndexSpecification, options?: CreateIndexesOptions) => Promise<void>;

package/lib/utils/guard.d.ts

@@ -0,0 +1,18 @@
+import type { App, HKT, jsonItem, Literal, Par, Rec, RORec } from '../../types';
+export 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;
+};
+export declare const sym: <Dom, T extends Dom, V extends Dom>(eq: Equal<Dom, T, V>) => Equal<Dom, V, T>;
+export 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 = keyof any;
+export declare const omitPick: <K extends s, E extends s, R extends s, T extends RORec<Exclude<K, E | R>, unknown>>() => Equal<unknown, Pick<T, Exclude<K, E | R>>, Omit<Pick<T, Exclude<K, E | R>>, R>>;
+export declare const omitExclude: <K extends s, E extends s, R extends s, 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>>;
+export declare const renamedFields: <K extends s, F extends HKT<K, s>, G extends HKT<App<F, K>>>() => Equal<string | number | symbol, keyof { [P in K as App<F, P>]: App<G, P>; }, App<F, K>>;
+export declare const doubleExclude: <K extends string, E extends s, R extends s>() => Equal<K, K, Exclude<K, E & Exclude<Literal<R>, K>>>;
+export declare const excludeIdem: <K extends s, E extends s, S extends E = E>() => Equal<Exclude<K, E>, Exclude<K, E>, Exclude<Exclude<K, E>, S>>;
+export declare const eqPar: <K extends string, T extends Rec<K, jsonItem>, K2 extends K>() => Equal<unknown, Par<K2, T>, Par<K, T>>;
+export declare const notExtendExcluded: <Key extends keyof any, Others extends keyof any, Source extends keyof any, Denied extends keyof any, F extends HKT<Others | Exclude<Source, Denied | Key>, Dom>, Else extends Dom, Dom = unknown>() => Equal<Dom, Key extends Others | Exclude<Source, Key | Denied> ? App<F, Key> : Else, Key extends Others ? App<F, Key> : Else>;
+export {};

package/lib/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { log } from './log';
+export { createIndex } from './db-indexes';
+export { map1, noop } from './json';

package/lib/utils/json.d.ts

@@ -0,0 +1,9 @@
+import type { AsLiteral, Rec } from '../../types';
+export declare const id: <T>(x: T) => T;
+export declare const defined: <T>(x: T | undefined | null) => x is T;
+export declare const noop: () => void;
+export declare const anoop: () => Promise<void>;
+export declare const asRec: <K extends string, T>(x: Record<K, T>) => Rec<K, T>;
+export declare const map1: <K extends string, Im>(k: AsLiteral<K>, to: Im) => { readonly [P in K]: [P, Im]; } & {
+    readonly [_: string]: [K, Im];
+};

package/lib/utils/log.d.ts

@@ -0,0 +1 @@
+export declare const log: (...args: unknown[]) => void;