mongo-typed 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 SecureDataSystems
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,97 @@
+# mongo-typed
+
+TypeScript utility types for building strongly-typed MongoDB filters, and updates — without adding dependencies.
+
+## Overview
+
+`mongo-typed` provides type-safe MongoDB-style query and update utilities in TypeScript. It is designed to assist with building fully-typed data repository layers or services that interact with MongoDB-like syntax, without relying on external libraries or runtime packages.
+
+Whether you're working with an actual MongoDB database or implementing similar patterns in your application logic, `mongo-typed` gives you strong typing for common Mongo operations like filters, and updates.
+
+## Features
+
+- 🧠 Fully typed **filter** support (including `$and`, `$or`, `$in`, `$elemMatch`, etc.)
+- ✍️ Strongly typed **update** operations (e.g., `$set`, `$inc`, `$unset`, etc.)
+- 💡 No dependencies — pure TypeScript
+- 🔐 Helps catch invalid Mongo-like queries at compile time
+
+## Installation
+
+```bash
+pnpm add mongo-typed
+# or
+npm install mongo-typed
+# or
+yarn add mongo-typed
+```
+
+## Usage
+
+### Basic Filter Type
+
+```ts
+import { Filter } from 'mongo-typed';
+
+type User = {
+  _id: string;
+  email: string;
+  age: number;
+  roles: string[];
+};
+
+const query: Filter<User> = {
+  age: { $gte: 18 },
+  roles: { $in: ['admin', 'user'] },
+  $or: [
+    { email: /@example\.com$/ },
+    { email: { $exists: false } }
+  ]
+};
+```
+
+### Basic Update Type
+
+```ts
+import { Update } from 'mongo-typed';
+
+const update: Update<User> = {
+  $set: {
+    email: 'new@email.com'
+  },
+  $inc: {
+    age: 1
+  },
+  $unset: {
+    roles: true
+  }
+};
+```
+
+### Aggregation Types (Coming Soon)
+
+Aggregation support is in active development and aims to type:
+- `$match`
+- `$group`
+- `$project`
+- `$sort`, `$limit`, `$lookup`, and more
+
+## Why Use `mongo-typed`?
+
+TypeScript developers working with MongoDB often find themselves wishing for deeper type safety on filters and updates — especially in larger projects or those with repository abstraction layers.
+
+`mongo-typed` solves this by bringing compile-time validation of Mongo-style operations, helping prevent costly runtime errors due to typos or invalid operations.
+
+## Status
+
+- ✅ Filter types – stable
+- ✅ Update types – in progress
+- 🧪 Aggregation types – coming soon
+- 🔄 Actively maintained
+
+## Contributing
+
+Contributions and suggestions are welcome! Please open issues or PRs to help improve support for advanced MongoDB operators or aggregations.
+
+## License
+
+MIT

package/dist/array.d.ts

@@ -0,0 +1,2 @@
+export type RewrapArray<TOriginal, TWrapped> = TOriginal extends (infer U)[] ? RewrapArray<U, TWrapped>[] : TWrapped;
+export type UnwrapArray<T> = T extends (infer U)[] ? UnwrapArray<U> : T;

package/dist/array.js

@@ -0,0 +1 @@
+export {};

package/dist/bson-types.d.ts

@@ -0,0 +1,57 @@
+import { EnhancedOmit } from './types.js';
+export declare const BsonType: {
+    readonly array: "array";
+    readonly binData: "binData";
+    readonly bool: "bool";
+    readonly date: "date";
+    readonly dbPointer: "dbPointer";
+    readonly decimal: "decimal";
+    readonly double: "double";
+    readonly int: "int";
+    readonly javascript: "javascript";
+    readonly javascriptWithScope: "javascriptWithScope";
+    readonly long: "long";
+    readonly maxKey: "maxKey";
+    readonly minKey: "minKey";
+    readonly null: "null";
+    readonly object: "object";
+    readonly objectId: "objectId";
+    readonly regex: "regex";
+    readonly string: "string";
+    readonly symbol: "symbol";
+    readonly timestamp: "timestamp";
+    readonly undefined: "undefined";
+};
+export declare const BsonTypeNumeric: Readonly<{
+    readonly array: 4;
+    readonly binData: 5;
+    readonly bool: 8;
+    readonly date: 9;
+    readonly dbPointer: 12;
+    readonly decimal: 19;
+    readonly double: 1;
+    readonly int: 16;
+    readonly javascript: 13;
+    readonly javascriptWithScope: 15;
+    readonly long: 18;
+    readonly maxKey: 127;
+    readonly minKey: -1;
+    readonly null: 10;
+    readonly object: 3;
+    readonly objectId: 7;
+    readonly regex: 11;
+    readonly string: 2;
+    readonly symbol: 14;
+    readonly timestamp: 17;
+    readonly undefined: 6;
+}>;
+export declare type BsonType = typeof BsonType[keyof typeof BsonType];
+export declare type BsonTypeNumeric = (typeof BsonTypeNumeric)[keyof typeof BsonTypeNumeric];
+export declare type IntegerType = bigint | number;
+export declare type NumericType = IntegerType;
+export declare type RegExpOrString<T> = T extends string ? RegExp | T : T;
+/** Add an _id field to an object shaped type */
+export declare type WithId<TSchema> = EnhancedOmit<TSchema, '_id'> & {
+    _id: string;
+};
+export type NumericBsonType = 1 | 16 | 18 | 19 | 'decimal' | 'double' | 'int' | 'long';

package/dist/bson-types.js

@@ -0,0 +1,23 @@
+export const BsonType = {
+    array: 'array',
+    binData: 'binData',
+    bool: 'bool',
+    date: 'date',
+    dbPointer: 'dbPointer',
+    decimal: 'decimal',
+    double: 'double',
+    int: 'int',
+    javascript: 'javascript',
+    javascriptWithScope: 'javascriptWithScope',
+    long: 'long',
+    maxKey: 'maxKey',
+    minKey: 'minKey',
+    null: 'null',
+    object: 'object',
+    objectId: 'objectId',
+    regex: 'regex',
+    string: 'string',
+    symbol: 'symbol',
+    timestamp: 'timestamp',
+    undefined: 'undefined'
+};

package/dist/dot-notation.d.ts

@@ -0,0 +1,12 @@
+/** Dot notation that includes numeric array indices and properly maps for use in object keys */
+import { And, NonNullableField } from './types.js';
+export type DotNotation<T extends object, TAllowPlaceholder extends boolean = false, TPrefix extends string = '', TDepth extends number[] = []> = TDepth['length'] extends 9 ? never : T extends readonly (infer U)[] ? (`${TPrefix}${number}` | DotNotation<NonNullableField<U> extends object ? NonNullableField<U> : never, TAllowPlaceholder, `${TPrefix}${number}.`, [...TDepth, 1]> | DotNotation<NonNullableField<U> extends object ? NonNullableField<U> : never, TAllowPlaceholder, `${TPrefix}`, [...TDepth, 1]> | (TAllowPlaceholder extends true ? (`${TPrefix}$[${string}]` | `${TPrefix}$` | DotNotation<NonNullableField<U> extends object ? NonNullableField<U> : never, TAllowPlaceholder, `${TPrefix}$.`, [...TDepth, 1]> | DotNotation<NonNullableField<U> extends object ? NonNullableField<U> : never, TAllowPlaceholder, `${TPrefix}$[${string}].`, [...TDepth, 1]> | DotNotation<NonNullableField<U> extends object ? NonNullableField<U> : never, TAllowPlaceholder, `${TPrefix}$[].`, [...TDepth, 1]>) : never)) : {
+    [K in keyof T & string]: T[K] extends (...args: any[]) => any ? never : (`${TPrefix}${K}` | DotNotation<NonNullableField<T[K]> extends object ? NonNullableField<T[K]> : never, TAllowPlaceholder, `${TPrefix}${K}.`, [...TDepth, 1]>);
+}[keyof T & string];
+/** Resolves a dot-notated path to the corresponding type, including array indexing */
+export type DotPathValue<T, TPath extends string, TAllowPlaceholder extends boolean = false, TCheckInArray extends boolean = false, TIsInArray extends boolean = false, TDepth extends number[] = []> = TDepth['length'] extends 9 ? never : TPath extends `${infer Key}.${infer Rest}` ? T extends readonly (infer U)[] ? Key extends `${number}` ? DotPathValue<U, Rest, TAllowPlaceholder, TCheckInArray, TIsInArray, [...TDepth, 1]> : TAllowPlaceholder extends true ? Key extends `$[${string}]` | `$[]` | `$` ? DotPathValue<U, Rest, TAllowPlaceholder, TCheckInArray, true, [...TDepth, 1]> : never : never : Key extends keyof T ? DotPathValue<NonNullable<T[Key]>, Rest, TAllowPlaceholder, TCheckInArray, TIsInArray, [...TDepth, 1]> : never : T extends readonly (infer U)[] ? TPath extends `${number}` ? And<TIsInArray, TCheckInArray, U[], U> : TAllowPlaceholder extends true ? TPath extends `$[${string}]` | `$[]` | `$` ? TCheckInArray extends true ? U[] : U : TPath extends keyof U ? TCheckInArray extends true ? U[TPath][] : U[TPath] : never : TPath extends keyof U ? TCheckInArray extends true ? U[TPath][] : U[TPath] : never : TPath extends keyof T ? And<TIsInArray, TCheckInArray, T[TPath][], T[TPath]> : never;
+export type OnlyFieldsOfTypeDotNotation<T extends object, TFieldType, TAllowPlaceholder extends boolean = false, TCheckInArray extends boolean = false, TAssignableType = never> = {
+    [P in DotNotation<T, TAllowPlaceholder> as NonNullableField<DotPathValue<T, P, TAllowPlaceholder, TCheckInArray>> extends TFieldType ? P : never]?: [
+        TAssignableType
+    ] extends [never] ? DotPathValue<T, P, TAllowPlaceholder, TCheckInArray> : TAssignableType;
+};

package/dist/dot-notation.js

@@ -0,0 +1,2 @@
+/** Dot notation that includes numeric array indices and properly maps for use in object keys */
+export {};

package/dist/dot-notation.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dot-notation.spec.js

@@ -0,0 +1,48 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { describe, it } from 'node:test';
+describe('DotNotation', () => {
+    it('should include top-level keys', () => {
+    });
+    it('should include nested keys', () => {
+    });
+    it('should include array index paths', () => {
+    });
+    it('should include deep dot notation with mixed levels', () => {
+    });
+    it('should support placeholder paths if enabled', () => {
+    });
+    it('should stop recursion at max depth', () => {
+    });
+    it('should treat dates as simple types', () => {
+    });
+});
+describe('DotPathValue', () => {
+    it('should resolve top-level fields', () => {
+    });
+    it('should resolve nested fields', () => {
+    });
+    it('should resolve array index values', () => {
+    });
+    it('should resolve placeholder array paths (TCheckInArray = true)', () => {
+    });
+    it('should resolve placeholder array paths (TCheckInArray = false)', () => {
+    });
+    it('should resolve deeply nested placeholders (TCheckInArray = true)', () => {
+    });
+    it('should resolve deeply nested placeholders (TCheckInArray = false)', () => {
+    });
+});
+describe('OnlyFieldsOfTypeDotNotation', () => {
+    it('should include only number fields', () => {
+    });
+    it('should include only string fields', () => {
+    });
+    it('should include only boolean fields', () => {
+    });
+    it('should include only Date fields', () => {
+    });
+    it('should allow custom assignable type', () => {
+    });
+    it('should support placeholder dot notation when enabled', () => {
+    });
+});

package/dist/expr.d.ts

@@ -0,0 +1,334 @@
+import { NumericBsonType } from './bson-types.js';
+import { DotNotation } from './dot-notation.js';
+export type ArrayExpr<TInput extends object> = Array<unknown> | FieldRef<TInput> | {
+    $concatArrays: ArrayExpr<TInput>[];
+} | {
+    $filter: {
+        as?: string;
+        cond: BooleanExpr<TInput>;
+        input: ArrayExpr<TInput>;
+    };
+} | {
+    $literal: Array<unknown>;
+} | {
+    $map: {
+        as?: string;
+        in: Expr<TInput>;
+        input: ArrayExpr<TInput>;
+    };
+} | {
+    $range: [NumericExpr<TInput>, NumericExpr<TInput>, NumericExpr<TInput>?];
+} | {
+    $reduce: {
+        in: Expr<TInput>;
+        initialValue: Expr<TInput>;
+        input: ArrayExpr<TInput>;
+    };
+} | {
+    $reverseArray: ArrayExpr<TInput>;
+} | {
+    $setDifference: [ArrayExpr<TInput>, ArrayExpr<TInput>];
+} | {
+    $setIntersection: [ArrayExpr<TInput>, ArrayExpr<TInput>];
+} | {
+    $setUnion: [ArrayExpr<TInput>, ArrayExpr<TInput>];
+} | {
+    $slice: [ArrayExpr<TInput>, NumericExpr<TInput>, NumericExpr<TInput>?];
+} | {
+    $zip: {
+        defaults?: ArrayExpr<TInput>;
+        inputs: ArrayExpr<TInput>[];
+        useLongestLength?: boolean;
+    };
+};
+export type BooleanExpr<TInput extends object> = boolean | FieldRef<TInput> | {
+    $allElementsTrue: ArrayExpr<TInput>;
+} | {
+    $and: ArrayExpr<TInput>;
+} | {
+    $anyElementTrue: ArrayExpr<TInput>;
+} | {
+    $eq: [Expr<TInput>, Expr<TInput>];
+} | {
+    $gt: [Expr<TInput>, Expr<TInput>];
+} | {
+    $gte: [Expr<TInput>, Expr<TInput>];
+} | {
+    $in: [Expr<TInput>, ArrayExpr<TInput>];
+} | {
+    $literal: boolean;
+} | {
+    $lt: [Expr<TInput>, Expr<TInput>];
+} | {
+    $lte: [Expr<TInput>, Expr<TInput>];
+} | {
+    $ne: [Expr<TInput>, Expr<TInput>];
+} | {
+    $nin: [Expr<TInput>, ArrayExpr<TInput>];
+} | {
+    $nor: Expr<TInput>[];
+} | {
+    $not: Expr<TInput>;
+} | {
+    $or: Expr<TInput>[];
+} | {
+    $regexMatch: {
+        input: StringExpr<TInput>;
+        options?: StringExpr<TInput>;
+        regex: StringExpr<TInput>;
+    };
+} | {
+    $setEquals: [ArrayExpr<TInput>, ArrayExpr<TInput>];
+} | {
+    $setIsSubset: [ArrayExpr<TInput>, ArrayExpr<TInput>];
+};
+export interface ConditionalExpr<TInput extends object> {
+    $cond?: [
+        Expr<TInput>,
+        Expr<TInput>,
+        Expr<TInput>
+    ] | {
+        else: Expr<TInput>;
+        if: Expr<TInput>;
+        then: Expr<TInput>;
+    };
+    $ifNull?: [Expr<TInput>, Expr<TInput>];
+    $switch: {
+        branches: {
+            case: Expr<TInput>;
+            then: Expr<TInput>;
+        }[];
+        default: Expr<TInput>;
+    };
+}
+export type DateExpr<TInput extends object> = Date | FieldRef<TInput> | {
+    $dateFromParts: {
+        day?: NumericExpr<TInput>;
+        hour?: NumericExpr<TInput>;
+        millisecond?: NumericExpr<TInput>;
+        minute?: NumericExpr<TInput>;
+        month?: NumericExpr<TInput>;
+        second?: NumericExpr<TInput>;
+        timezone?: StringExpr<TInput>;
+        year: NumericExpr<TInput>;
+    };
+} | {
+    $dateFromString: {
+        dateString: StringExpr<TInput>;
+        format?: StringExpr<TInput>;
+        onError?: Expr<TInput>;
+        onNull?: Expr<TInput>;
+        timezone?: StringExpr<TInput>;
+    };
+} | {
+    $literal: Date;
+};
+export interface DatePartsExpr<TInput extends object> {
+    $dateToParts: {
+        date: DateExpr<TInput>;
+        iso8601?: BooleanExpr<TInput>;
+        timezone?: StringExpr<TInput>;
+    };
+}
+export interface DateTimezoneExpr<TInput extends object> {
+    date: DateExpr<TInput>;
+    timezone: StringExpr<TInput>;
+}
+export type Expr<T extends object> = ArrayExpr<T> | BooleanExpr<T> | ConditionalExpr<T> | DateExpr<T> | DatePartsExpr<T> | NumericExpr<T> | StringExpr<T> | TypeExpr<T> | VariableExpr<T>;
+export type FieldPaths<T extends object> = DotNotation<T> extends infer U ? U & string : never;
+export type FieldRef<T extends object> = `$${FieldPaths<T>}`;
+export type NumericExpr<TInput extends object> = FieldRef<TInput> | number | {
+    $abs: NumericExpr<TInput>;
+} | {
+    $acos: NumericExpr<TInput>;
+} | {
+    $acosh: NumericExpr<TInput>;
+} | {
+    $add: (DateExpr<TInput> | NumericExpr<TInput>)[];
+} | {
+    $asin: NumericExpr<TInput>;
+} | {
+    $asinh: NumericExpr<TInput>;
+} | {
+    $atan: NumericExpr<TInput>;
+} | {
+    $atanh: NumericExpr<TInput>;
+} | {
+    $ceil: NumericExpr<TInput>;
+} | {
+    $convert: {
+        input: Expr<TInput>;
+        onError?: Expr<TInput>;
+        onNull?: Expr<TInput>;
+        to: NumericBsonType | {
+            type: NumericBsonType;
+        };
+    };
+} | {
+    $cos: NumericExpr<TInput>;
+} | {
+    $cosh: NumericExpr<TInput>;
+} | {
+    $dateDiff: {
+        endDate: DateExpr<TInput>;
+        startDate: DateExpr<TInput>;
+        timezone?: StringExpr<TInput>;
+        unit: StringExpr<TInput>;
+    };
+} | {
+    $dayOfMonth?: DateExpr<TInput> | DateTimezoneExpr<TInput>;
+} | {
+    $dayOfWeek?: DateExpr<TInput> | DateTimezoneExpr<TInput>;
+} | {
+    $dayOfYear?: DateExpr<TInput> | DateTimezoneExpr<TInput>;
+} | {
+    $degreesToRadians: NumericExpr<TInput>;
+} | {
+    $divide: [NumericExpr<TInput>, NumericExpr<TInput>];
+} | {
+    $exp: NumericExpr<TInput>;
+} | {
+    $floor: NumericExpr<TInput>;
+} | {
+    $hour?: DateExpr<TInput> | DateTimezoneExpr<TInput>;
+} | {
+    $isoDayOfWeek?: DateExpr<TInput> | DateTimezoneExpr<TInput>;
+} | {
+    $isoWeek?: DateExpr<TInput> | DateTimezoneExpr<TInput>;
+} | {
+    $isoWeekYear?: DateExpr<TInput> | DateTimezoneExpr<TInput>;
+} | {
+    $literal: number;
+} | {
+    $ln: NumericExpr<TInput>;
+} | {
+    $log10: NumericExpr<TInput>;
+} | {
+    $log: [NumericExpr<TInput>, NumericExpr<TInput>];
+} | {
+    $millisecond?: DateExpr<TInput> | DateTimezoneExpr<TInput>;
+} | {
+    $minute?: DateExpr<TInput> | DateTimezoneExpr<TInput>;
+} | {
+    $mod: [NumericExpr<TInput>, NumericExpr<TInput>];
+} | {
+    $month?: DateExpr<TInput> | DateTimezoneExpr<TInput>;
+} | {
+    $multiply: NumericExpr<TInput>[];
+} | {
+    $pow: [NumericExpr<TInput>, NumericExpr<TInput>];
+} | {
+    $radiansToDegrees: NumericExpr<TInput>;
+} | {
+    $rand: Record<string, never>;
+} | {
+    $round: [NumericExpr<TInput>, NumericExpr<TInput>] | NumericExpr<TInput>;
+} | {
+    $second?: DateExpr<TInput> | DateTimezoneExpr<TInput>;
+} | {
+    $sin: NumericExpr<TInput>;
+} | {
+    $sinh: NumericExpr<TInput>;
+} | {
+    $size: ArrayExpr<TInput>;
+} | {
+    $sqrt: NumericExpr<TInput>;
+} | {
+    $strLenBytes: StringExpr<TInput>;
+} | {
+    $strLenCP: StringExpr<TInput>;
+} | {
+    $subtract: [DateExpr<TInput>, DateExpr<TInput>];
+} | {
+    $subtract: [DateExpr<TInput> | NumericExpr<TInput>, NumericExpr<TInput>];
+} | {
+    $tan: NumericExpr<TInput>;
+} | {
+    $tanh: NumericExpr<TInput>;
+} | {
+    $toDecimal: Expr<TInput>;
+} | {
+    $toDouble: Expr<TInput>;
+} | {
+    $toInt: Expr<TInput>;
+} | {
+    $toLong: Expr<TInput>;
+} | {
+    $trunc: [NumericExpr<TInput>, NumericExpr<TInput>] | NumericExpr<TInput>;
+} | {
+    $week?: DateExpr<TInput> | DateTimezoneExpr<TInput>;
+} | {
+    $year?: DateExpr<TInput> | DateTimezoneExpr<TInput>;
+};
+export type StringExpr<TInput extends object> = FieldRef<TInput> | string | {
+    $concat: StringExpr<TInput>[];
+} | {
+    $dateToString: {
+        date: DateExpr<TInput>;
+        format?: StringExpr<TInput>;
+        onNull?: Expr<TInput>;
+        timezone?: StringExpr<TInput>;
+    };
+} | {
+    $literal: string;
+} | {
+    $ltrim: {
+        chars?: StringExpr<TInput>;
+        input: StringExpr<TInput>;
+    };
+} | {
+    $replaceAll: {
+        find: StringExpr<TInput>;
+        input: StringExpr<TInput>;
+        replacement: StringExpr<TInput>;
+    };
+} | {
+    $replaceOne: {
+        find: StringExpr<TInput>;
+        input: StringExpr<TInput>;
+        replacement: StringExpr<TInput>;
+    };
+} | {
+    $rtrim: {
+        chars?: StringExpr<TInput>;
+        input: StringExpr<TInput>;
+    };
+} | {
+    $substr: [StringExpr<TInput>, NumericExpr<TInput>, NumericExpr<TInput>];
+} | {
+    $substrBytes: [StringExpr<TInput>, NumericExpr<TInput>, NumericExpr<TInput>];
+} | {
+    $substrCP: [StringExpr<TInput>, NumericExpr<TInput>, NumericExpr<TInput>];
+} | {
+    $toLower: StringExpr<TInput>;
+} | {
+    $toString: Expr<TInput>;
+} | {
+    $toUpper: StringExpr<TInput>;
+} | {
+    $trim: {
+        chars?: StringExpr<TInput>;
+        input: StringExpr<TInput>;
+    };
+};
+export interface TypeExpr<TInput extends object> {
+    $type?: Expr<TInput>;
+}
+export type VariableExpr<TInput extends object> = {
+    $let?: {
+        in: Expr<TInput>;
+        vars: Record<string, Expr<TInput>>;
+    };
+} | {
+    $map?: {
+        as: string;
+        in: Expr<TInput>;
+        input: ArrayExpr<TInput>;
+    };
+} | {
+    $reduce?: {
+        in: Expr<TInput>;
+        initialValue: Expr<TInput>;
+        input: ArrayExpr<TInput>;
+    };
+};

package/dist/expr.js

@@ -0,0 +1 @@
+export {};

package/dist/expr.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/expr.spec.js

@@ -0,0 +1 @@
+export {};