@omegup/msync 0.0.8 → 0.0.9

package/index.d.ts

@@ -469,7 +469,8 @@ declare const $unwind: <T extends doc, K extends s, U extends doc>(k: AsLiteral<
 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>> = ((OPick<V, Allowed$2<KK>> & ID) | (Rec<Allowed$2<KK>, N> & ID)) & TS;
-declare const $merge: <V extends Model & ID>() => <KK extends StrKey<V>, Out extends doc, E = unknown>(out: RWCollection<Out | Replace<Out, Patch<V, KK>>, Out>, keys: ExactKeys<Allowed$2<KK>>, id: Expr<string, OutInputE<OPick<V, Allowed$2<KK>> & ID, E, null>>) => RawStages<unknown, OutInputE<OPick<V, Allowed$2<KK>> & ID, E>, "out">;
+declare const $simpleMerge: <V extends Model & ID>() => <KK extends StrKey<V>, Out extends doc>(out: RWCollection<Out | Replace<Out, Patch<V, KK>>, Out>, keys: ExactKeys<Allowed$2<KK>>) => RawStages<unknown, OutInputE<OPick<V, Allowed$2<KK>> & ID, unknown>, "out">;
+declare const $merge: <V extends Model & ID>() => <KK extends StrKey<V>, Out extends doc>(out: RWCollection<Out | Replace<Out, Patch<V, KK>>, Out>, keys: ExactKeys<Allowed$2<KK>>) => RawStages<unknown, Delta<OPick<V, Allowed$2<KK>> & ID>, "out">;
 
 type ND = {
     readonly deletedAt?: null;
@@ -641,4 +642,4 @@ declare const enablePreAndPostImages: <T extends doc>(coll: Collection<T>) => Pr
 declare const prepare: (testName?: string) => Promise<MongoClient$1>;
 declare const makeCol: <T extends ID>(docs: readonly OptionalUnlessRequiredId<T>[], database: Db, name?: string) => Promise<Collection<T>>;
 
-export { $accumulator, $and, $countDict, $entries, $eq, $expr, $getField, $group, $groupId, $groupMerge, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $keys, $let, $lookup, $lt, $lte, $map, $map1, $match, $matchDelta, $merge, $merge_, $ne, $nin, $nor, $or, $pushDict, $rand, $replaceWith, $set, $sum, $unwind, $unwindDelta, $upsert, type Accumulators, type Arr, type AsLiteral, type Delta, type DeltaAccumulator, type DeltaAccumulators, Expr, type ExprHKT, type Exprs, type ExprsExact, type ExprsExactHKT, type ExprsPart, Field, type ID, type Loose, Machine, type Merge, type MergeArgs, type MergeInto, type MergeMapOArgs, type Model, type N, type NoRaw, type O, type OPick, type OPickD, type RONoRaw, type RORec, type RawStages, type Rec, type Replace, type SnapshotStreamExecutionResult, type StrKey, type Strict, type TS, Type, type WriteonlyCollection, add, and, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, type doc, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, func, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, type notArr, notNull, now, or, pair, prepare, rand, range, root, set, setField, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap };
+export { $accumulator, $and, $countDict, $entries, $eq, $expr, $getField, $group, $groupId, $groupMerge, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $keys, $let, $lookup, $lt, $lte, $map, $map1, $match, $matchDelta, $merge, $merge_, $ne, $nin, $nor, $or, $pushDict, $rand, $replaceWith, $set, $simpleMerge, $sum, $unwind, $unwindDelta, $upsert, type Accumulators, type Arr, type AsLiteral, type Delta, type DeltaAccumulator, type DeltaAccumulators, Expr, type ExprHKT, type Exprs, type ExprsExact, type ExprsExactHKT, type ExprsPart, Field, type ID, type Loose, Machine, type Merge, type MergeArgs, type MergeInto, type MergeMapOArgs, type Model, type N, type NoRaw, type O, type OPick, type OPickD, type RONoRaw, type RORec, type RawStages, type Rec, type Replace, type SnapshotStreamExecutionResult, type StrKey, type Strict, type TS, Type, type WriteonlyCollection, add, and, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, type doc, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, func, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, type notArr, notNull, now, or, pair, prepare, rand, range, root, set, setField, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap };

package/index.esm.js

@@ -1010,7 +1010,7 @@ const $replaceWith = (expr) => ({
     lin: $replaceWith_(expr),
 });
 
-const $merge = () => (out, keys, id) => {
+const $mergeId = () => (out, keys, id) => {
     const omRORec = omitRORec();
     const patch = mapExactToObject(keys, (_, k) => [k, root().of('after').of(k).expr()]);
     const replacer = ite(eqTyped(root().of('after').expr(), nil), field(omRORec.backward(spread(mapExact(keys, () => nil), {
@@ -1029,6 +1029,12 @@ const $merge = () => (out, keys, id) => {
         whenMatched: 'merge',
     })).stages;
 };
+const $simpleMerge = () => (out, keys) => $mergeId()(out, keys, root().of('_id').expr());
+const $merge = () => (out, keys) => $mergeId()(out, keys, assertNotNull(root()
+    .of('before')
+    .of('_id')
+    .expr()));
+const assertNotNull = (expr) => expr;
 
 const $upsert = (out) => {
     const replacer = ite(eqTyped(root().of('after').expr(), nil), field({
@@ -1615,4 +1621,4 @@ const makeCol = async (docs, database, name) => {
     }
 };
 
-export { $accumulator, $and, $countDict, $entries, $eq, $expr, $getField, $group, $groupId, $groupMerge, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $keys, $let, $lookup, $lt, $lte, $map, $map1, $match, $matchDelta, $merge, $merge_, $ne, $nin, $nor, $or, $pushDict, $rand, $replaceWith, $set, $sum, $unwind, $unwindDelta, $upsert, Field, Machine, add, and, array, ceil, comp, concat$1 as concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first$1 as first, firstSure, floor, from, func, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, notNull, now, or, pair, prepare, rand, range, root, set, setField, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap };
+export { $accumulator, $and, $countDict, $entries, $eq, $expr, $getField, $group, $groupId, $groupMerge, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $keys, $let, $lookup, $lt, $lte, $map, $map1, $match, $matchDelta, $merge, $merge_, $ne, $nin, $nor, $or, $pushDict, $rand, $replaceWith, $set, $simpleMerge, $sum, $unwind, $unwindDelta, $upsert, Field, Machine, add, and, array, ceil, comp, concat$1 as concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first$1 as first, firstSure, floor, from, func, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, notNull, now, or, pair, prepare, rand, range, root, set, setField, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap };

package/index.js

@@ -1012,7 +1012,7 @@ const $replaceWith = (expr) => ({
     lin: $replaceWith_(expr),
 });
 
-const $merge = () => (out, keys, id) => {
+const $mergeId = () => (out, keys, id) => {
     const omRORec = omitRORec();
     const patch = mapExactToObject(keys, (_, k) => [k, root().of('after').of(k).expr()]);
     const replacer = ite(eqTyped(root().of('after').expr(), nil), field(omRORec.backward(spread(mapExact(keys, () => nil), {
@@ -1031,6 +1031,12 @@ const $merge = () => (out, keys, id) => {
         whenMatched: 'merge',
     })).stages;
 };
+const $simpleMerge = () => (out, keys) => $mergeId()(out, keys, root().of('_id').expr());
+const $merge = () => (out, keys) => $mergeId()(out, keys, assertNotNull(root()
+    .of('before')
+    .of('_id')
+    .expr()));
+const assertNotNull = (expr) => expr;
 
 const $upsert = (out) => {
     const replacer = ite(eqTyped(root().of('after').expr(), nil), field({
@@ -1652,6 +1658,7 @@ exports.$pushDict = $pushDict;
 exports.$rand = $rand;
 exports.$replaceWith = $replaceWith;
 exports.$set = $set;
+exports.$simpleMerge = $simpleMerge;
 exports.$sum = $sum;
 exports.$unwind = $unwind;
 exports.$unwindDelta = $unwindDelta;

package/lib/accumulators/index.d.ts

@@ -0,0 +1,10 @@
+import type { AppMap, Arr, N, O, Rec } from '../../types';
+import type { ExprHKT } from '../expression/concat';
+import { type NoRaw } from '../expression/val';
+import type { DeltaAccumulator, Expr, Part } from '../types';
+export declare const $sum: <D extends O, C = unknown>(expr: Expr<number | N, D, C>) => DeltaAccumulator<D, number, C>;
+export declare const $accumulator: <D, T, Ctx, A extends readonly unknown[]>(init: () => NoRaw<T>, accumulateArgs: AppMap<ExprHKT<Part<D>, Ctx>, A>, accumulate: (a: NoRaw<T>, ...args: NoRaw<A>) => NoRaw<T>, merge: (...args: NoRaw<[T | N, T]>) => NoRaw<T>) => DeltaAccumulator<D, T, Ctx>;
+export declare const $countDict: <D extends O, C = unknown>(expr: Expr<string, D, C>) => DeltaAccumulator<D, Rec<string, number>, C>;
+export declare const $pushDict: <D extends O, V, C = unknown>(key: Expr<string, D, C>, value: Expr<V, D, C>) => DeltaAccumulator<D, Rec<string, Rec<"0" | "1", Arr<V>>>, C>;
+export declare const $keys: <D extends O, C = unknown>(expr: Expr<Rec<string, number>, D, C>) => Expr<Arr<string>, D, C>;
+export declare const $entries: <D extends O, V, C = unknown>(expr: Expr<Rec<string, Rec<"1" | "0", Arr<V>>>, D, C>) => Expr<Arr<Rec<"k", string> & Rec<"v", V>>, D, C>;

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

@@ -0,0 +1,10 @@
+import type { OPick, RWCollection } from '../../types';
+import type { ID, N, Rec, Replace, StrKey, doc } from '../../types/json';
+import type { Delta, Model, RawStages, TS } from '../types';
+import { type ExactKeys } from '../utils/map-object';
+type OutInputE<T, E, A = T | null> = ID & Rec<'after', A> & E;
+type Allowed<K extends string> = Exclude<K, keyof (TS & ID)>;
+type Patch<V, KK extends StrKey<V>> = ((OPick<V, Allowed<KK>> & ID) | (Rec<Allowed<KK>, N> & ID)) & TS;
+export declare const $simpleMerge: <V extends Model & ID>() => <KK extends StrKey<V>, Out extends doc>(out: RWCollection<Out | Replace<Out, Patch<V, KK>>, Out>, keys: ExactKeys<Allowed<KK>>) => RawStages<unknown, OutInputE<OPick<V, Allowed<KK>> & ID, unknown>, "out">;
+export declare const $merge: <V extends Model & ID>() => <KK extends StrKey<V>, Out extends doc>(out: RWCollection<Out | Replace<Out, Patch<V, KK>>, Out>, keys: ExactKeys<Allowed<KK>>) => RawStages<unknown, Delta<OPick<V, Allowed<KK>> & ID>, "out">;
+export {};

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

@@ -0,0 +1,9 @@
+import type { RWCollection } from '../../types';
+import type { ID, doc } from '../../types/json';
+import type { Del, OutInput, RawStages, TS } from '../types';
+type ND = {
+    readonly deletedAt?: null;
+};
+export type Merge<T extends ID> = (T & ND & TS) | Del;
+export declare const $upsert: <T extends doc>(out: RWCollection<Merge<T>>) => RawStages<unknown, OutInput<T>, "out">;
+export {};

package/lib/aggregate/group/$group-merge.d.ts

@@ -0,0 +1,12 @@
+import type { RWCollection, WriteonlyCollection } from '../../../types';
+import type { AsLiteral, ID, O, Rec, Replace, doc, notArr } from '../../../types/json';
+import { type ExprsExact } from '../../expression/concat';
+import type { Delta, DeltaAccumulators, Expr, RawStages, TS } from '../../types';
+import type { MergeInto } from '../out';
+import { type Extra, type IdAndTsKeys, type Loose, type Strict, type V_Grp } from './utils/sub-merge';
+type Denied<GID = never> = keyof (TS & ID) | GID;
+type GI<GG> = Exclude<GG, keyof TS>;
+export declare const $groupMerge: <T extends O, Grp extends notArr, V extends O, GG extends string, EE = {}, Out extends Loose<Grp, V, GG> = Loose<Grp, V, GG>>(id: Expr<Grp, T>, args: DeltaAccumulators<T, O & Omit<V, Denied<GI<GG>>>>, out: MergeInto<Strict<Grp, V, GG, EE>, Out, WriteonlyCollection<Replace<Out, Strict<Grp, V, GG, EE>>>>, gid: AsLiteral<GI<GG>>, extra: ExprsExact<Extra<EE, V, GG>, V_Grp<V, GG, Grp>>, idPrefix?: string) => RawStages<unknown, Delta<T>, "out">;
+export declare const $groupId: <T extends O, V extends O, EE = {}, Out extends Loose<string, V, "_id"> = Loose<string, V, "_id">>(id: Expr<string, T>, args: DeltaAccumulators<T, O & Omit<V, Denied>>, out: RWCollection<Replace<Out, Strict<string, V, "_id", EE>>, Out>, extra: ExprsExact<Omit<EE, IdAndTsKeys | keyof Omit<V, IdAndTsKeys>>, doc & Omit<V, IdAndTsKeys>>) => RawStages<unknown, Delta<T>, "out">;
+export declare const $group: <T extends O, Grp extends notArr, V extends O, EE = {}, Out extends Loose<Grp, V, "_grp"> = Loose<Grp, V, "_grp">>(id: Expr<Grp, T>, args: DeltaAccumulators<T, O & Omit<V, Denied<"_grp">>>, out: RWCollection<Strict<Grp, V, "_grp", EE>, Out>, extra: ExprsExact<Omit<EE, IdAndTsKeys | "_grp" | keyof Omit<V, IdAndTsKeys | "_grp">>, Rec<"_grp", Grp> & Omit<V, IdAndTsKeys | "_grp">>, idPrefix?: string) => RawStages<unknown, Delta<T>, "out">;
+export {};

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

@@ -0,0 +1,2 @@
+export { $groupMerge, $groupId, $group } from './$group-merge';
+export type { Loose, Strict } from './utils/sub-merge';

package/lib/aggregate/group/utils/sub-group.d.ts

@@ -0,0 +1,6 @@
+import type { O, RORec, Rec } from '../../../../types';
+import { type ExprsExact } from '../../../expression/concat';
+import type { Delta, Expr, RawStages } from '../../../types';
+import type { DeltaAccumulators } from '../../../types/accumulator';
+export type WithItem<V, Grp> = Rec<'_id', Grp> & Rec<'item', O<V>>;
+export declare const subGroup: <T extends O, Grp, V extends O, GID extends string>(id: Expr<Grp, T>, args: DeltaAccumulators<T, V>, addGrp: <D extends Rec<"_id", Grp>>(src: ExprsExact<V, D>) => ExprsExact<RORec<GID, Grp> & V, D>) => RawStages<unknown, Delta<T>, Rec<GID, Grp> & V>;

package/lib/aggregate/group/utils/sub-merge.d.ts

@@ -0,0 +1,15 @@
+import type { AsLiteral, ID, O, Rec, Replace, WriteonlyCollection, notArr } from '../../../../types';
+import { type ExprsExact } from '../../../expression/concat';
+import type { RawStages, TS } from '../../../types';
+import type { DeltaAccumulators } from '../../../types/accumulator';
+import { type MergeInto } from '../../out';
+type GI<GG> = Exclude<GG, keyof TS>;
+export type IdAndTsKeys = keyof (TS & ID);
+type V<VV, GG extends string> = Omit<VV, IdAndTsKeys | GI<GG>>;
+export type Prepare<Grp, GG extends string> = TS & ID & Rec<GI<GG>, Grp>;
+export type Loose<Grp, VV, GG extends string> = Prepare<Grp, GG> & Partial<V<VV, GG>>;
+export type Strict<Grp, VV, GG extends string, EE> = Prepare<Grp, GG> & V<VV, GG> & Omit<EE, IdAndTsKeys | GI<GG> | keyof V<VV, GG>>;
+export type V_Grp<VV, GG extends string, Grp> = Rec<GI<GG>, Grp> & V<VV, GG>;
+export type Extra<EE, VV, GG extends string> = Omit<EE, IdAndTsKeys | GI<GG> | keyof V<VV, GG>>;
+export declare const subMerge: <T extends O, Grp extends notArr, VV extends O, GG extends string, EE = {}, Out extends Loose<Grp, VV, GG> = Loose<Grp, VV, GG>>(args: DeltaAccumulators<T, V<VV, GG>>, out: MergeInto<Strict<Grp, VV, GG, EE>, Out, WriteonlyCollection<Replace<Out, Strict<Grp, VV, GG, EE>>>>, gid: AsLiteral<GI<GG>>, extra: ExprsExact<Extra<EE, VV, GG>, V_Grp<VV, GG, Grp>>, idPrefix: string) => RawStages<unknown, V_Grp<VV, GG, Grp>, "out">;
+export {};

package/lib/aggregate/index.d.ts

@@ -0,0 +1,8 @@
+export * from './group';
+export * from './lookup';
+export * from './match';
+export * from './set';
+export * from './unwind';
+export * from './$merge';
+export * from './$upsert';
+export * from './out';

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

@@ -0,0 +1,10 @@
+import type { AsLiteral, ID, N, O, Rec } from '../../../types';
+import { Field } from '../../field';
+import type { BA, Before, Delta, RawStages, TStages, UBefore } from '../../types';
+type s = string;
+type Both<K1 extends s, LE, KK2 extends s, RE> = Delta<Rec<K1, LE> & Rec<Exclude<KK2, BA | K1>, RE> & ID>;
+export declare const $lookupDelta: <LQ extends O, LE extends LQ & O, RQ extends O, RE extends RQ, BRB extends UBefore<RQ>, RS extends UBefore<RQ>, S, K1 extends s, KK2 extends s>({ field1, field2 }: {
+    field1: Field<LQ, S | N>;
+    field2: Field<RQ, S | N>;
+}, { coll, exec, input }: TStages<RS, UBefore<RQ>, BRB, Before<RE>>, k1: AsLiteral<K1>, k2: AsLiteral<Exclude<KK2, BA | K1>>, k: K1 | Exclude<KK2, BA | K1> | false) => RawStages<unknown, Delta<LE>, Both<K1, LE, KK2, RE>>;
+export {};

package/lib/aggregate/lookup/$lookup-raw.d.ts

@@ -0,0 +1,9 @@
+import type { App, AsLiteral, HKT, ID, O, Rec } from '../../../types';
+import { type Field } from '../../field';
+import type { Before, RawStages, TStages } from '../../types';
+type s = string;
+export declare const $lookupRaw: <LQ extends O, LE extends LQ & ID, RQ extends O, RE extends RQ & ID, BRB extends Before<RQ>, RS, S, As extends s>({ field1, field2 }: {
+    field1: Field<LQ, S>;
+    field2: Field<RQ, S>;
+}, { coll, exec, input }: TStages<RS, Before<RQ>, BRB, Before<RE>>, k2: AsLiteral<As>, k: "left" | "right" | false) => <F extends HKT<O, O>>(f: <T extends O>() => Field<App<F, T>, T>) => RawStages<App<F, LQ>, App<F, LE>, App<F, LE & Rec<As, RE> & ID>>;
+export {};

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

@@ -0,0 +1,11 @@
+import type { AsLiteral, O, RORec, doc, notArr } from '../../../types';
+import { type Field } from '../../field';
+import type { SnapshotStream, SnapshotStreamExecutionResult } from '../../types/stream';
+type Params<As extends string, LQ extends O, RQ extends O, RE extends RQ, S extends notArr> = {
+    localField: Field<LQ, S>;
+    foreignField: Field<RQ, S>;
+    from: SnapshotStreamExecutionResult<RQ, RE>;
+    as: AsLiteral<As>;
+};
+export declare const $lookup: <As extends string, LQ extends doc, RQ extends O, RE extends RQ & doc, S extends notArr>(p: Params<As, LQ, RQ, RE, S>) => <LE extends LQ>(l: SnapshotStream<LQ, LE>) => SnapshotStream<LQ, LE & RORec<As, RE>>;
+export {};

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>(k: K) => RawStages<O<T>, T & Rec<K, Arr<U>>, T & Rec<K, 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/map-object").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,34 @@
+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?: undefined;
+} & ({
+    whenMatched: 'keepExisting' | 'fail';
+} | {
+    whenMatched: 'replace';
+    into: RWCollection<T, Out>;
+} | {
+    whenMatched: 'merge';
+    into: RWCollection<Replace<Out, T>, Out>;
+})) | {
+    stages: true;
+    into: RWCollection<In, Out>;
+    whenMatched: RawStages<unknown, Out, In>;
+} | {
+    stages: 'ctx';
+    vars: ExprsExact<Ctx, T>;
+    into: RWCollection<In, Out>;
+    whenMatched: RawStages<unknown, Out, In, Ctx>;
+});
+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>;

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>;
+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>(k: K) => FRawStages<T, T & Rec<K, Arr<R>>, T & Rec<K, R>>;
+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,12 @@
+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 $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>(k1: AsLiteral<K1>, k2: AsLiteral<K2>, k: K1 | K2 | false) => RawStages<Delta<Rec<K1, T>>, Delta<Rec<K1, T> & Rec<K2, Arr<U>>>, Delta<Rec<K1, T> & Rec<K2, U> & ID>>;
+export {};

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

@@ -0,0 +1,5 @@
+import type { Arr, AsLiteral, doc, O, Rec, RORec } from '../../../types';
+import type { DeltaStages } from '../../types';
+export { $unwindDelta } from './$unwind-delta';
+type s = string;
+export declare const $unwind: <T extends doc, K extends s, U extends doc>(k: AsLiteral<K>, dict: RORec<K, "key">) => DeltaStages<O, T & Rec<K, Arr<U>>, T & Rec<K, U>>;

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) => import("../aggregate/prefix").DeltaPipe<AllowedPick<V, KK>, AllowedPick<V, KK>, StreamRunnerHKT, StagesHKT>;
+export {};

package/lib/boot/boot.d.ts

@@ -0,0 +1,16 @@
+import type { O2, O3, OPickD, 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';
+type Allowed<K> = Exclude<K, 'deletedAt' | '_id'>;
+type AllowedPick<V extends Model, K extends StrKey<V>> = OPickD<V, Allowed<K>>;
+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>>, streamName: string) => DeltaPipe<AllowedPick<V, KK>, AllowedPick<V, KK>, SnapshotStreamHKT, DeltaHKT>;
+export {};

package/lib/boot/index.d.ts

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

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>;