@omegup/msync 0.0.16 → 0.0.17

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;

package/lib/utils/map-object.d.ts

@@ -0,0 +1,41 @@
+import type { App, HKT, I, IdHKT, RORec, StrKey } from '../../types';
+export declare const map: <T, K extends string & keyof T, V extends RORec<K, unknown>>(x: Pick<T, K>, f: <P extends K>(v: T[P], k: P) => V[P]) => V;
+export type ExactPart<T, F extends HKT<T[StrKey<T>]>> = MapOPart<T, MappedHKT<T, F>>;
+export type ExactPart1<T, F extends HKT<StrKey<T>>> = {
+    readonly [K in StrKey<T>]: App<F, K>;
+};
+type s = string;
+export type MapKDom<RK extends MapKDom<RK, F>, F extends HKT<StrKey<RK>>> = MapO<RK, F> & {
+    readonly [P in s]?: readonly [keyof RK, unknown];
+};
+export type ExactKeys<K extends string> = Exact<RORec<K, 1>, IdHKT>;
+export type MapO<T, F extends HKT<StrKey<T>>> = MapOPart<T, F> & {
+    readonly [P: string]: readonly [StrKey<T>, unknown];
+};
+export type MapK<K extends s, F extends HKT<K>> = MapO<RORec<K>, F>;
+export type MapOPart<T, F extends HKT<StrKey<T>>, K extends keyof T = StrKey<T>> = {
+    readonly [P in K]: readonly [P, App<F, P & string>];
+};
+export type MapKPart1<T, F extends HKT<StrKey<T>>> = {
+    readonly [P in StrKey<T>]: App<F, P>;
+};
+export type Exact<T, F extends HKT<T[StrKey<T>]>> = MapO<T, MappedHKT<T, F>>;
+export interface MappedHKT<T, F extends HKT<T[StrKey<T>]>> extends HKT<StrKey<T>> {
+    readonly out: App<F, T[I<StrKey<T>, this>]>;
+}
+export declare const mapExactToObject0: <T, F extends HKT<StrKey<T>>, G extends HKT<StrKey<T>>>(x: MapO<T, F>, f: <P extends StrKey<T>>(v: App<F, P>, k: P) => App<G, P>) => MapKPart1<T, G>;
+export declare const mapExactToObject1: <K extends string, F extends HKT<K>, G extends HKT<K>>(x: MapK<K, F>, f: <P extends K>(v: App<F, P>, k: P) => App<G, P>) => MapKPart1<RORec<K>, G>;
+export interface WithKey1<K extends string, G extends HKT<K>> extends HKT<K> {
+    readonly out: readonly [I<K, this>, App<G, I<K, this>>];
+}
+export declare const mapExact0: <T, F extends HKT<StrKey<T>>, G extends HKT<StrKey<T>>>(x: MapO<T, F>, f: <P extends StrKey<T>>(v: App<F, P>, k: P) => App<G, P>) => MapO<T, G>;
+export declare const mapExact1: <K extends s, F extends HKT<K>, G extends HKT<K>>(x: MapK<K, F>, f: <P extends K>(v: App<F, P>, k: P) => App<G, P>) => MapK<K, G>;
+export declare const mapExactToObject: <T, F extends HKT<T[StrKey<T>]>, G extends HKT<StrKey<T>>>(x: Exact<T, F>, f: <P extends StrKey<T>>(v: App<F, T[P]>, k: P) => App<G, P>) => ExactPart1<T, G>;
+export declare const mapExact: <T, F extends HKT<T[StrKey<T>]>, G extends HKT<T[StrKey<T>]>>(x: Exact<T, F>, f: <P extends StrKey<T>>(v: App<F, T[P]>, k: P) => App<G, T[P]>) => Exact<T, G>;
+type Dom<T, V> = HKT<T[StrKey<T>] | V[StrKey<V>]>;
+export declare const spread: <T, V, F extends Dom<T, V>, E = unknown, No extends keyof V = never>(a: Exact<Omit<T, No>, F>, b: Exact<V, F>) => Exact<V & Omit<T, keyof V> & Pick<E, symbol & keyof E>, F>;
+export interface MergeHKT<T, V, F1 extends HKT<StrKey<Omit<T, No>>>, F2 extends HKT<StrKey<V>>, No extends keyof V = never> extends HKT<StrKey<V & Omit<T, No>>> {
+    readonly out: I<StrKey<V & Omit<T, No>>, this> extends StrKey<V> ? App<F2, I<StrKey<V>, this>> : App<F1, I<StrKey<Omit<T, No>>, this>>;
+}
+export declare const spread0: <T, V, F1 extends HKT<StrKey<Omit<T, No>>>, F2 extends HKT<StrKey<V>>, E = unknown, No extends keyof V = never>(a: MapO<Omit<T, No>, F1>, b: MapO<V, F2>) => MapO<V & Omit<T, No> & Pick<E, symbol & keyof E>, MergeHKT<T, V, F1, F2, No>>;
+export {};

package/lib/utils/merge/combiners.d.ts

@@ -0,0 +1,6 @@
+import type { Iterator, HasJob } from '../../types';
+export { mergeIterators } from './merge';
+export declare const firstWorksMerge: <Result, Info extends HasJob>(iters: Iterator<Result, Info>[]) => Iterator<Result, {
+    readonly key: string;
+    readonly value: Info;
+} & HasJob>;

package/lib/utils/merge/index.d.ts

@@ -0,0 +1,2 @@
+export { firstWorksMerge, mergeIterators } from './combiners';
+export { Machine, wrap } from '../../machine';

package/lib/utils/merge/merge.d.ts

@@ -0,0 +1,7 @@
+import type { IteratorResult, HasJob } from '../../types';
+import type { KEYS, Race, SourceIteratorResults, SourceResults } from './types';
+export declare const mergeIterators: <K extends KEYS, Result, Info extends Record<K, HasJob>>(params: {
+    sources: SourceIteratorResults<K, Result, Info>;
+    interrupt?: (key: KEYS) => boolean;
+    select?: Race<K, Result, Info>;
+}) => IteratorResult<Result, SourceResults<K, Info>>;

package/lib/utils/merge/next-winner.d.ts

@@ -0,0 +1,3 @@
+import type { NextFrame, HasJob } from '../../types';
+import type { KEYS, RaceWinner, SourceIteratorResults } from './types';
+export declare const nextWinner: <K extends KEYS, Result, Info extends Record<K, HasJob>>(previousWinner: RaceWinner<K, Result, Info>, previousWinnerNextFrame: NextFrame<Result, Info[K]>, sources: SourceIteratorResults<K, Result, Info>, interrupt?: (key: KEYS) => boolean) => Promise<RaceWinner<K, Result, Info>>;

package/lib/utils/merge/types.d.ts

@@ -0,0 +1,19 @@
+import type { Frame, IteratorResult, HasJob } from '../../types';
+export type KEYS = string;
+export type SourceIteratorResults<K extends KEYS, Result, Info extends Record<K, unknown>> = {
+    readonly [P in K]: IteratorResult<Result, Info[P]>;
+};
+export type SourceResults<K extends KEYS, Info extends Record<K, HasJob>> = {
+    readonly [P in K]: {
+        readonly key: P;
+        readonly value: Info[P];
+        readonly job: Info[P]['job'];
+    };
+}[K];
+export type RaceWinner<K extends KEYS, Result, Info extends Record<K, unknown>> = {
+    readonly [P in K]: {
+        readonly key: P;
+        readonly frame: Frame<Result, Info[P]>;
+    };
+}[K];
+export type Race<K extends KEYS, Result, Info extends Record<K, HasJob>> = (arg: SourceIteratorResults<K, Result, Info>) => PromiseLike<RaceWinner<K, Result, Info>>;

package/lib/utils/merge/utils.d.ts

@@ -0,0 +1,4 @@
+import type { KEYS, RaceWinner, SourceIteratorResults } from './types';
+export declare const patch: <T, K extends keyof T>(x: T, k: K, v: T[K]) => T;
+export declare const restart: <K extends KEYS, Result, Info extends Record<K, unknown>>(sources: SourceIteratorResults<K, Result, Info>) => SourceIteratorResults<K, Result, Info>;
+export declare const race: <W, K extends KEYS, Result, Info extends Record<K, W>>(sources: SourceIteratorResults<K, Result, Info>) => Promise<RaceWinner<K, Result, Info>>;

package/lib/utils/tear-down.d.ts

@@ -0,0 +1,2 @@
+import type { Iterator } from '../types';
+export declare const addTeardown: <T, Info>(it: Iterator<T, Info>, tr?: () => void) => Iterator<T, Info>;

package/lib/watch.d.ts

@@ -0,0 +1,15 @@
+import type { BSON, Db, Timestamp } from 'mongodb';
+import type { O, StrKey, View } from '../types';
+import { type Field } from './field';
+import type { Model, Query } from './types';
+export declare const changeKeys: readonly ["fullDocument", "fullDocumentBeforeChange"];
+export type ChangeKey = (typeof changeKeys)[number];
+export type Change<T extends Model> = O<{
+    readonly fullDocument: T;
+    readonly fullDocumentBeforeChange: T;
+}>;
+export declare const subQ: <D extends O, C, DeltaD extends O>(a: Query<D, C>, f: Field<DeltaD, D>) => Query<DeltaD, C>;
+export declare const makeWatchStream: <V extends Model, K extends StrKey<V>>(db: Db, { collection, projection: p, hardMatch: m }: View<V, K>, startAt: Timestamp) => {
+    tryNext: () => Promise<import("mongodb").ChangeStreamDocument<BSON.Document> | null>;
+    close: () => Promise<void>;
+};

package/package.json

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

package/test/mongodb.d.ts

@@ -0,0 +1,9 @@
+import { Collection, MongoClient } from 'mongodb';
+import type { AsynIter, Iterator } from '../lib/types';
+import type { ID, doc } from '../types';
+import type { Db, OptionalUnlessRequiredId } from 'mongodb';
+export declare const run: <T, Info>(cont: Iterator<T, Info>) => Promise<never>;
+export declare const iterate: <T>([, next]: AsynIter<T>) => PromiseLike<never>;
+export declare const enablePreAndPostImages: <T extends doc>(coll: Collection<T>) => Promise<import("mongodb").Document>;
+export declare const prepare: (testName?: string) => Promise<MongoClient>;
+export declare const makeCol: <T extends ID>(docs: readonly OptionalUnlessRequiredId<T>[], database: Db, name?: string) => Promise<Collection<T>>;

package/test/uri.d.ts

@@ -0,0 +1 @@
+export declare const uri: string;

package/types/class.d.ts

@@ -0,0 +1 @@
+export declare const Type: unique symbol;

package/types/extern.d.ts

@@ -0,0 +1,3 @@
+export type { Type } from './class';
+export type { Arr, ID, N, O, Rec, StrKey, doc, OPick, OPickD, RORec, Replace } from './index';
+export type { AsLiteral, notArr, WriteonlyCollection, Collection, Timestamp } from './index';

package/types/global.d.ts

@@ -0,0 +1,44 @@
+import type { App, AppMap, AppMapRW, HKT, PromiseHKT } from './hkt';
+import type { RORec, StrKey } from './json';
+export type AsNum<R> = R extends `${infer A extends number}` ? A : never;
+export type GetDom<Dom = unknown> = readonly [readonly Dom[], keyof any];
+declare global {
+    type Entry<T, K extends keyof T = keyof T> = readonly [string, T[string & K]] & {
+        [k in K]: readonly [string & k, T[k]];
+    }[K];
+    interface ObjectConstructor {
+        entries<T, _ = 0>(object?: T): readonly Entry<T>[];
+        fromEntries<T, _ = 0>(entries: readonly Entry<T>[]): T;
+        keys<T, _ extends 1>(obj: T): readonly StrKey<T>[];
+    }
+    interface ReadonlyArray<T> {
+        includes<T, V extends T>(this: ReadonlyArray<V>, item: T, fromIndex?: number): item is V;
+        map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
+        map<K extends string, T extends RORec<K>, U extends RORec<K>, _ extends 2 = 2>(this: readonly Entry<T, K>[], callbackfn: <P extends K>(value: [P, T[P]], index: number, array: this) => readonly [P, U[P]], thisArg?: any): readonly Entry<U, K>[];
+        map<V extends ReadonlyArray<unknown>, F extends HKT<unknown>, G extends HKT<unknown>, _ extends 1 = 1>(this: AppMap<F, V>, callbackfn: <I extends keyof V>(value: App<F, V[I]>, index: AsNum<I>, array: V) => App<G, V[I]>, thisArg?: any): AppMapRW<G, V>;
+        reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
+        reduce<V extends ReadonlyArray<unknown>, F extends HKT, U>(this: AppMap<F, V>, callbackfn: <I extends keyof V>(previousValue: U, currentValue: App<F, V[I]>, currentIndex: AsNum<I>, array: V) => U, initialValue: U): U;
+        map<V extends ReadonlyArray<Dom>, F extends HKT<Dom>, G extends HKT<GetDom<Dom>>, Dom = unknown, _ extends 0 = 0>(this: AppMap<F, V, Dom>, callbackfn: <I extends keyof V>(value: App<F, V[I] & Dom>, index: AsNum<I>, array: V) => App<G, [V, I]>, thisArg?: any): AppMapRW<G, {
+            [I in keyof V]: [V, I];
+        }, GetDom<Dom>>;
+    }
+    interface Array<T> extends ReadonlyArray<T> {
+        includes<T, V extends T>(this: ReadonlyArray<V>, item: T, fromIndex?: number): item is V;
+        map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
+        map<K extends string, T extends RORec<K>, U extends RORec<K>, _ extends 2 = 2>(this: readonly Entry<T, K>[], callbackfn: <P extends K>(value: [P, T[P]], index: number, array: this) => readonly [P, U[P]], thisArg?: any): readonly Entry<U, K>[];
+        map<V extends ReadonlyArray<unknown>, F extends HKT<unknown>, G extends HKT<unknown>, _ extends 1 = 1>(this: AppMap<F, V>, callbackfn: <I extends keyof V>(value: App<F, V[I]>, index: AsNum<I>, array: V) => App<G, V[I]>, thisArg?: any): AppMapRW<G, V>;
+        reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
+        reduce<V extends ReadonlyArray<unknown>, F extends HKT, U>(this: AppMap<F, V>, callbackfn: <I extends keyof V>(previousValue: U, currentValue: App<F, V[I]>, currentIndex: AsNum<I>, array: V) => U, initialValue: U): U;
+        map<V extends ReadonlyArray<Dom>, F extends HKT<Dom>, G extends HKT<GetDom<Dom>>, Dom = unknown, _ extends 0 = 0>(this: AppMap<F, V, Dom>, callbackfn: <I extends keyof V>(value: App<F, V[I] & Dom>, index: AsNum<I>, array: V) => App<G, [V, I]>, thisArg?: any): AppMapRW<G, {
+            [I in keyof V]: [V, I];
+        }, GetDom<Dom>>;
+    }
+    interface PromiseConstructor {
+        all<T extends readonly unknown[] | []>(values: AppMap<PromiseHKT, T>): Promise<T>;
+        race<T extends readonly unknown[] | [], _ extends 0 = 0>(values: AppMap<PromiseHKT, T>): Promise<T[number]>;
+        all<T extends readonly unknown[] | []>(values: T): Promise<{
+            -readonly [P in keyof T]: Awaited<T[P]>;
+        }>;
+        race<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
+    }
+}

package/types/hkt.d.ts

@@ -0,0 +1,56 @@
+import type { UBefore } from "../lib/types";
+import type { Rec } from "./json";
+export interface HKT<in Dom = unknown, out Im = unknown> {
+    readonly in: (x: Dom) => void;
+    readonly out: Im;
+}
+export type App<F extends HKT<X>, X> = (F & {
+    readonly in: (x: X) => void;
+})['out'];
+export type I<Dom, F extends HKT<Dom>> = F['in'] extends (x: infer X extends Dom) => void ? X : never;
+export interface ArrHKT<Dom = unknown> extends HKT<Dom> {
+    readonly out: readonly I<Dom, this>[];
+}
+export interface IdHKT<Dom = unknown> extends HKT<Dom> {
+    readonly out: I<Dom, this>;
+}
+export interface RConstHKT<Im, Dom = Im> extends HKT<Im, HKT<Dom, Im>> {
+    readonly out: ConstHKT<I<Im, this>, Dom>;
+}
+export interface ConstHKT<Im, Dom = unknown> extends HKT<Dom, Im> {
+    readonly out: Im;
+}
+type ApplyF<Dom, Im, T extends [Dom, HKT<Dom, Im>]> = App<T[1], T[0]>;
+export interface ApplyHKT<Dom, Im> extends HKT<[Dom, HKT<Dom, Im>], Im> {
+    readonly out: ApplyF<Dom, Im, I<[Dom, HKT<Dom, Im>], this>>;
+}
+export interface µ<X extends [HKT<A, B>, HKT<B, C>], A = unknown, B = unknown, C = unknown> extends HKT<A, C> {
+    readonly out: App<X[1], App<X[0], I<A, this>>>;
+}
+export type AppMap<F extends HKT<Dom>, X extends readonly Dom[], Dom = unknown> = readonly App<F, Dom>[] & {
+    [I in keyof X]: App<F, X[I]>;
+};
+export type AppMapRW<F extends HKT<Dom>, X extends readonly Dom[], Dom = unknown> = App<F, Dom>[] & {
+    [I in keyof X]: App<F, X[I]>;
+};
+export interface PromiseHKT<Dom = unknown> extends HKT<Dom> {
+    readonly out: PromiseLike<I<Dom, this>>;
+}
+export interface DeepFieldHKT<R, T, K extends keyof T, F extends HKT<R, T>> extends HKT<R, T[K]> {
+    readonly out: App<F, I<R, this>>[K];
+}
+export interface FieldHKT<K extends string> extends DeepFieldHKT<Record<K, unknown>, Record<K, unknown>, K, IdHKT<Record<K, unknown>>> {
+}
+export interface RecordHKT<K extends string, Dom = unknown> extends HKT<Dom, Record<K, Dom>> {
+    readonly out: Record<K, I<Dom, this>>;
+}
+export interface RecHKT<K extends string, Dom = unknown, E = unknown> extends HKT<Dom, Rec<K, Dom>> {
+    readonly out: Rec<K, I<Dom, this>> & E;
+}
+export interface UBeforeHKT<Dom = unknown> extends HKT<Dom, UBefore<Dom>> {
+    readonly out: UBefore<I<Dom, this>>;
+}
+export interface And<E> extends HKT {
+    readonly out: E & I<unknown, this>;
+}
+export {};

package/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './global';
+export * from './json';
+export * from './hkt';
+export * from './class';
+export * from './view';
+export * from './mongo';

package/types/json.d.ts

@@ -0,0 +1,54 @@
+import type { Timestamp } from 'mongodb';
+import { Type } from './class';
+export { Type } from './class';
+export type U = undefined;
+export type N = null | U;
+export type jsonPrim = number | null | string | boolean | Timestamp | Date;
+export type notObj = jsonPrim | U;
+export type notArr = notObj | O;
+export type jsonItem = unknown;
+export type rawItem = jsonPrim | raw | U;
+export type Undef<I extends N> = I | (I extends never ? I : notObj);
+export declare const object: unique symbol;
+export declare const array: unique symbol;
+export interface JsonArr {
+    [Type]: typeof array;
+    readonly [_: number]: jsonItem | U;
+}
+export type A = {
+    [Type]: typeof array;
+};
+export type Arr<T, N extends number = number> = A & {
+    readonly [_ in N]: T;
+};
+type Obj = {
+    [Type]: typeof object;
+};
+export type O<T = unknown> = Obj & T;
+export type RORec<K extends keyof never, T = unknown> = {
+    readonly [P in K]: T;
+};
+export type Par<K extends string, V extends Rec<K, jsonItem>> = {
+    readonly [k in K]?: V[k] | N;
+};
+export type Rec<K extends string, T = unknown> = O<RORec<K, T>>;
+export type O2 = readonly [O, O];
+export type O3 = readonly [O, O, O];
+export type ID = {
+    readonly _id: string;
+};
+export type doc = O & ID;
+export interface RawObj {
+    readonly [_: string]: rawItem | U;
+}
+export type raw = readonly rawItem[] | RawObj;
+export type StrKey<T> = string & keyof T;
+export type Replace<R, V> = Omit<R, StrKey<V>> & V & O;
+export type AsLiteral<T extends keyof any | boolean, V = NoUnion<T>> = T extends keyof any ? {} extends {
+    [K in T]: 1;
+} ? never : V : V;
+type NoUnion<T, V = T> = T extends unknown ? ([V] extends [T] ? T : never) : never;
+export type Literal<K> = string extends K ? never : K;
+export type RemoveSignature<T> = {
+    [K in keyof T as Literal<K>]: T[K];
+};

package/types/mongo.d.ts

@@ -0,0 +1,24 @@
+import 'mongodb';
+import { BSON } from 'mongodb';
+export declare const RawStage: unique symbol;
+declare module 'mongodb' {
+    interface Collection<TSchema extends BSON.Document = BSON.Document> {
+        [RawStage]: {
+            (_: 2): TSchema;
+            (_: 1, x: TSchema): TSchema;
+        };
+        s: {
+            db: Db;
+        };
+    }
+    interface Db {
+        s: {
+            client?: MongoClient;
+        };
+        client: MongoClient;
+    }
+    interface Timestamp {
+        toExtendedJSON(): BSON.TimestampExtended;
+    }
+}
+export * from 'mongodb';

package/types/view.d.ts

@@ -0,0 +1,35 @@
+import type { Collection, Db } from 'mongodb';
+import type { Del, Expr, Model, Query } from '../lib/types';
+import type { ExactKeys } from '../lib/utils/map-object';
+import type { O, StrKey } from './json';
+import type { RawStage } from './mongo';
+interface CommonCollection {
+    readonly s: {
+        readonly db: Db;
+    };
+    collectionName: string;
+    namespace: string;
+    dbName: string;
+    createIndex: Collection['createIndex'];
+}
+export interface ReadonlyCollection<out Out> extends CommonCollection {
+    [RawStage](_: 2): Out;
+}
+export interface WriteonlyCollection<in R> extends CommonCollection {
+    [RawStage]: {
+        (_: 1, x: R): unknown;
+    };
+}
+export interface RWCollection<in R extends O, out Out extends O = R> extends CommonCollection {
+    [RawStage](_: 2): Out;
+    [RawStage](_: 1, x: R): unknown;
+}
+export type OPick<V, K extends StrKey<V>, E extends StrKey<V> = never> = O & Pick<V, K | E>;
+export type OPickD<V extends Model, K extends StrKey<V>> = OPick<V, K, 'deletedAt' | '_id'>;
+export type View<V extends Model, K extends StrKey<V>> = {
+    collection: ReadonlyCollection<V | Del>;
+    projection: ExactKeys<K>;
+    match?: Expr<boolean, OPickD<V, K>>;
+    hardMatch?: Query<V>;
+};
+export {};