@enspirit/bmg-js 1.0.1 → 1.0.2

package/dist/{src/operators → operators}/_helpers.d.ts

@@ -1,142 +1,142 @@
-import { OperationalOperand, RelationOperand, Renaming, RenamingFunc, Tuple, JoinKeys, AttrName } from "@/types";
-/**
- * Generates a unique string key for a tuple, used for equality comparison and deduplication.
- * Handles nested relations by converting them to sorted tuple keys.
- *
- * @example
- * tupleKey({ name: 'Alice', age: 30 })
- * // => '[["age",30],["name","Alice"]]'
- *
- * @example
- * tupleKey({ id: 1, items: Bmg([{ x: 1 }, { x: 2 }]) })
- * // => '[["id",1],["items",[...]]]' (nested relation converted to sorted keys)
- */
-export declare const tupleKey: (tuple: Tuple) => string;
-/**
- * Removes duplicate tuples from an array, preserving order of first occurrence.
- * Uses tupleKey() for equality comparison.
- *
- * @example
- * deduplicate([
- *   { id: 1, name: 'Alice' },
- *   { id: 2, name: 'Bob' },
- *   { id: 1, name: 'Alice' },  // duplicate
- * ])
- * // => [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
- */
-export declare const deduplicate: (tuples: Tuple[]) => Tuple[];
-/**
- * Converts a RelationOperand (Relation or Tuple[]) to an OperationalOperand
- * that provides a uniform interface for iteration and output.
- *
- * @example
- * // With array input, output remains array
- * const op = toOperationalOperand([{ id: 1 }]);
- * [...op.tuples()];        // => [{ id: 1 }]
- * op.output([{ id: 2 }]);  // => [{ id: 2 }]
- *
- * @example
- * // With Relation input, output is a new Relation
- * const op = toOperationalOperand(Bmg([{ id: 1 }]));
- * [...op.tuples()];        // => [{ id: 1 }]
- * op.output([{ id: 2 }]);  // => Bmg([{ id: 2 }])
- */
-export declare const toOperationalOperand: (operand: RelationOperand) => OperationalOperand;
-/**
- * Converts a Renaming (object or function) to a RenamingFunc.
- *
- * @example
- * // Object renaming
- * const fn = toRenamingFunc({ name: 'fullName', age: 'years' });
- * fn('name');  // => 'fullName'
- * fn('age');   // => 'years'
- * fn('other'); // => 'other' (unchanged)
- *
- * @example
- * // Function renaming (passed through)
- * const fn = toRenamingFunc(attr => attr.toUpperCase());
- * fn('name'); // => 'NAME'
- */
-export declare const toRenamingFunc: (renaming: Renaming) => RenamingFunc;
-export declare const error: (msg: string) => never;
-/**
- * Finds attribute names that exist in both left and right tuple arrays.
- * Used for natural joins when no explicit keys are provided.
- *
- * @example
- * const left = [{ id: 1, name: 'Alice', city: 'NYC' }];
- * const right = [{ city: 'NYC', country: 'USA' }];
- * getCommonAttrs(left, right);
- * // => ['city']
- *
- * @example
- * const left = [{ a: 1, b: 2 }];
- * const right = [{ b: 2, c: 3 }];
- * getCommonAttrs(left, right);
- * // => ['b']
- */
-export declare const getCommonAttrs: (left: Tuple[], right: Tuple[]) => AttrName[];
-/**
- * Normalizes JoinKeys to a Record<AttrName, AttrName> mapping left attrs to right attrs.
- *
- * @example
- * // undefined => use common attributes
- * normalizeKeys(undefined, [{ id: 1, city: 'NYC' }], [{ city: 'NYC' }]);
- * // => { city: 'city' }
- *
- * @example
- * // Array of common attribute names
- * normalizeKeys(['city', 'country'], leftTuples, rightTuples);
- * // => { city: 'city', country: 'country' }
- *
- * @example
- * // Object mapping left attr to right attr
- * normalizeKeys({ city: 'location' }, leftTuples, rightTuples);
- * // => { city: 'location' }
- */
-export declare const normalizeKeys: (keys: JoinKeys | undefined, leftTuples: Tuple[], rightTuples: Tuple[]) => Record<AttrName, AttrName>;
-/**
- * Checks if two tuples match on the specified key mapping.
- *
- * @example
- * const keyMap = { city: 'location' };
- * tuplesMatch({ id: 1, city: 'NYC' }, { location: 'NYC', pop: 8 }, keyMap);
- * // => true (left.city === right.location)
- *
- * @example
- * const keyMap = { city: 'city' };
- * tuplesMatch({ city: 'NYC' }, { city: 'LA' }, keyMap);
- * // => false
- */
-export declare const tuplesMatch: (left: Tuple, right: Tuple, keyMap: Record<AttrName, AttrName>) => boolean;
-/**
- * Creates a string key from a tuple's join attributes for fast Set-based lookups.
- * Used by matching/not_matching for efficient semi-join operations.
- *
- * @example
- * const keyMap = { first: 'fname', last: 'lname' };
- *
- * // Left side uses left attr names (keys of keyMap)
- * matchKey({ id: 1, first: 'John', last: 'Doe' }, keyMap, 'left');
- * // => '"John"|"Doe"'
- *
- * // Right side uses right attr names (values of keyMap)
- * matchKey({ fname: 'John', lname: 'Doe', age: 30 }, keyMap, 'right');
- * // => '"John"|"Doe"'
- */
-export declare const matchKey: (tuple: Tuple, keyMap: Record<AttrName, AttrName>, side: 'left' | 'right') => string;
-/**
- * Removes join key attributes from a right tuple when merging.
- * Used to avoid duplicate columns in join results.
- *
- * @example
- * const keyMap = { city: 'location' };
- * projectOutKeys({ location: 'NYC', country: 'USA', pop: 8 }, keyMap);
- * // => { country: 'USA', pop: 8 }  (location removed)
- *
- * @example
- * const keyMap = { a: 'a', b: 'b' };
- * projectOutKeys({ a: 1, b: 2, c: 3 }, keyMap);
- * // => { c: 3 }  (a and b removed)
- */
-export declare const projectOutKeys: (tuple: Tuple, keyMap: Record<AttrName, AttrName>) => Tuple;
+import { OperationalOperand, RelationOperand, Renaming, RenamingFunc, Tuple, JoinKeys, AttrName } from "@/types";
+/**
+ * Generates a unique string key for a tuple, used for equality comparison and deduplication.
+ * Handles nested relations by converting them to sorted tuple keys.
+ *
+ * @example
+ * tupleKey({ name: 'Alice', age: 30 })
+ * // => '[["age",30],["name","Alice"]]'
+ *
+ * @example
+ * tupleKey({ id: 1, items: Bmg([{ x: 1 }, { x: 2 }]) })
+ * // => '[["id",1],["items",[...]]]' (nested relation converted to sorted keys)
+ */
+export declare const tupleKey: (tuple: Tuple) => string;
+/**
+ * Removes duplicate tuples from an array, preserving order of first occurrence.
+ * Uses tupleKey() for equality comparison.
+ *
+ * @example
+ * deduplicate([
+ *   { id: 1, name: 'Alice' },
+ *   { id: 2, name: 'Bob' },
+ *   { id: 1, name: 'Alice' },  // duplicate
+ * ])
+ * // => [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
+ */
+export declare const deduplicate: (tuples: Tuple[]) => Tuple[];
+/**
+ * Converts a RelationOperand (Relation or Tuple[]) to an OperationalOperand
+ * that provides a uniform interface for iteration and output.
+ *
+ * @example
+ * // With array input, output remains array
+ * const op = toOperationalOperand([{ id: 1 }]);
+ * [...op.tuples()];        // => [{ id: 1 }]
+ * op.output([{ id: 2 }]);  // => [{ id: 2 }]
+ *
+ * @example
+ * // With Relation input, output is a new Relation
+ * const op = toOperationalOperand(Bmg([{ id: 1 }]));
+ * [...op.tuples()];        // => [{ id: 1 }]
+ * op.output([{ id: 2 }]);  // => Bmg([{ id: 2 }])
+ */
+export declare const toOperationalOperand: (operand: RelationOperand) => OperationalOperand;
+/**
+ * Converts a Renaming (object or function) to a RenamingFunc.
+ *
+ * @example
+ * // Object renaming
+ * const fn = toRenamingFunc({ name: 'fullName', age: 'years' });
+ * fn('name');  // => 'fullName'
+ * fn('age');   // => 'years'
+ * fn('other'); // => 'other' (unchanged)
+ *
+ * @example
+ * // Function renaming (passed through)
+ * const fn = toRenamingFunc(attr => attr.toUpperCase());
+ * fn('name'); // => 'NAME'
+ */
+export declare const toRenamingFunc: (renaming: Renaming) => RenamingFunc;
+export declare const error: (msg: string) => never;
+/**
+ * Finds attribute names that exist in both left and right tuple arrays.
+ * Used for natural joins when no explicit keys are provided.
+ *
+ * @example
+ * const left = [{ id: 1, name: 'Alice', city: 'NYC' }];
+ * const right = [{ city: 'NYC', country: 'USA' }];
+ * getCommonAttrs(left, right);
+ * // => ['city']
+ *
+ * @example
+ * const left = [{ a: 1, b: 2 }];
+ * const right = [{ b: 2, c: 3 }];
+ * getCommonAttrs(left, right);
+ * // => ['b']
+ */
+export declare const getCommonAttrs: (left: Tuple[], right: Tuple[]) => AttrName[];
+/**
+ * Normalizes JoinKeys to a Record<AttrName, AttrName> mapping left attrs to right attrs.
+ *
+ * @example
+ * // undefined => use common attributes
+ * normalizeKeys(undefined, [{ id: 1, city: 'NYC' }], [{ city: 'NYC' }]);
+ * // => { city: 'city' }
+ *
+ * @example
+ * // Array of common attribute names
+ * normalizeKeys(['city', 'country'], leftTuples, rightTuples);
+ * // => { city: 'city', country: 'country' }
+ *
+ * @example
+ * // Object mapping left attr to right attr
+ * normalizeKeys({ city: 'location' }, leftTuples, rightTuples);
+ * // => { city: 'location' }
+ */
+export declare const normalizeKeys: (keys: JoinKeys | undefined, leftTuples: Tuple[], rightTuples: Tuple[]) => Record<AttrName, AttrName>;
+/**
+ * Checks if two tuples match on the specified key mapping.
+ *
+ * @example
+ * const keyMap = { city: 'location' };
+ * tuplesMatch({ id: 1, city: 'NYC' }, { location: 'NYC', pop: 8 }, keyMap);
+ * // => true (left.city === right.location)
+ *
+ * @example
+ * const keyMap = { city: 'city' };
+ * tuplesMatch({ city: 'NYC' }, { city: 'LA' }, keyMap);
+ * // => false
+ */
+export declare const tuplesMatch: (left: Tuple, right: Tuple, keyMap: Record<AttrName, AttrName>) => boolean;
+/**
+ * Creates a string key from a tuple's join attributes for fast Set-based lookups.
+ * Used by matching/not_matching for efficient semi-join operations.
+ *
+ * @example
+ * const keyMap = { first: 'fname', last: 'lname' };
+ *
+ * // Left side uses left attr names (keys of keyMap)
+ * matchKey({ id: 1, first: 'John', last: 'Doe' }, keyMap, 'left');
+ * // => '"John"|"Doe"'
+ *
+ * // Right side uses right attr names (values of keyMap)
+ * matchKey({ fname: 'John', lname: 'Doe', age: 30 }, keyMap, 'right');
+ * // => '"John"|"Doe"'
+ */
+export declare const matchKey: (tuple: Tuple, keyMap: Record<AttrName, AttrName>, side: 'left' | 'right') => string;
+/**
+ * Removes join key attributes from a right tuple when merging.
+ * Used to avoid duplicate columns in join results.
+ *
+ * @example
+ * const keyMap = { city: 'location' };
+ * projectOutKeys({ location: 'NYC', country: 'USA', pop: 8 }, keyMap);
+ * // => { country: 'USA', pop: 8 }  (location removed)
+ *
+ * @example
+ * const keyMap = { a: 'a', b: 'b' };
+ * projectOutKeys({ a: 1, b: 2, c: 3 }, keyMap);
+ * // => { c: 3 }  (a and b removed)
+ */
+export declare const projectOutKeys: (tuple: Tuple, keyMap: Record<AttrName, AttrName>) => Tuple;

package/dist/{src/operators → operators}/allbut.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, AttrName } from "../types";
-export declare const allbut: (operand: RelationOperand, attrs: AttrName[]) => RelationOperand;
+import { RelationOperand, AttrName } from "../types";
+export declare const allbut: (operand: RelationOperand, attrs: AttrName[]) => RelationOperand;

package/dist/{src/operators → operators}/autowrap.d.ts

@@ -1,2 +1,2 @@
-import { AutowrapOptions, RelationOperand } from "../types";
-export declare const autowrap: (operand: RelationOperand, options?: AutowrapOptions) => RelationOperand;
+import { AutowrapOptions, RelationOperand } from "../types";
+export declare const autowrap: (operand: RelationOperand, options?: AutowrapOptions) => RelationOperand;

package/dist/{src/operators → operators}/constants.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, Tuple } from "../types";
-export declare const constants: (operand: RelationOperand, consts: Tuple) => RelationOperand;
+import { RelationOperand, Tuple } from "../types";
+export declare const constants: (operand: RelationOperand, consts: Tuple) => RelationOperand;

package/dist/{src/operators → operators}/cross_product.d.ts

@@ -1,3 +1,3 @@
-import { RelationOperand } from "../types";
-export declare const cross_product: (left: RelationOperand, right: RelationOperand) => RelationOperand;
-export { cross_product as cross_join };
+import { RelationOperand } from "../types";
+export declare const cross_product: (left: RelationOperand, right: RelationOperand) => RelationOperand;
+export { cross_product as cross_join };

package/dist/{src/operators → operators}/exclude.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, Predicate } from "../types";
-export declare const exclude: (operand: RelationOperand, p: Predicate) => RelationOperand;
+import { RelationOperand, Predicate } from "../types";
+export declare const exclude: (operand: RelationOperand, p: Predicate) => RelationOperand;

package/dist/{src/operators → operators}/extend.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, Extension } from "../types";
-export declare const extend: (operand: RelationOperand, extension: Extension) => RelationOperand;
+import { RelationOperand, Extension } from "../types";
+export declare const extend: (operand: RelationOperand, extension: Extension) => RelationOperand;

package/dist/{src/src/operators → operators}/group.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, AttrName } from "../types";
-export declare const group: (operand: RelationOperand, attrs: AttrName[], as: AttrName) => RelationOperand;
+import { RelationOperand, AttrName } from "../types";
+export declare const group: (operand: RelationOperand, attrs: AttrName[], as: AttrName) => RelationOperand;

package/dist/{src/operators → operators}/image.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, JoinKeys, AttrName } from "../types";
-export declare const image: (left: RelationOperand, right: RelationOperand, as: AttrName, keys?: JoinKeys) => RelationOperand;
+import { RelationOperand, JoinKeys, AttrName } from "../types";
+export declare const image: (left: RelationOperand, right: RelationOperand, as: AttrName, keys?: JoinKeys) => RelationOperand;

package/dist/{src/operators → operators}/index.d.ts

@@ -1,30 +1,30 @@
-export * from './restrict';
-export * from './where';
-export * from './exclude';
-export * from './constants';
-export * from './rename';
-export * from './prefix';
-export * from './suffix';
-export * from './project';
-export * from './allbut';
-export * from './extend';
-export * from './union';
-export * from './minus';
-export * from './intersect';
-export * from './matching';
-export * from './not_matching';
-export * from './join';
-export * from './left_join';
-export * from './cross_product';
-export * from './image';
-export * from './summarize';
-export * from './group';
-export * from './ungroup';
-export * from './wrap';
-export * from './unwrap';
-export * from './autowrap';
-export * from './transform';
-export * from './isRelation';
-export * from './isEqual';
-export * from './one';
-export * from './yByX';
+export * from './restrict';
+export * from './where';
+export * from './exclude';
+export * from './constants';
+export * from './rename';
+export * from './prefix';
+export * from './suffix';
+export * from './project';
+export * from './allbut';
+export * from './extend';
+export * from './union';
+export * from './minus';
+export * from './intersect';
+export * from './matching';
+export * from './not_matching';
+export * from './join';
+export * from './left_join';
+export * from './cross_product';
+export * from './image';
+export * from './summarize';
+export * from './group';
+export * from './ungroup';
+export * from './wrap';
+export * from './unwrap';
+export * from './autowrap';
+export * from './transform';
+export * from './isRelation';
+export * from './isEqual';
+export * from './one';
+export * from './yByX';

package/dist/{src/src/operators → operators}/intersect.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand } from "../types";
-export declare const intersect: (left: RelationOperand, right: RelationOperand) => RelationOperand;
+import { RelationOperand } from "../types";
+export declare const intersect: (left: RelationOperand, right: RelationOperand) => RelationOperand;

package/dist/{src/src/operators → operators}/isEqual.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand } from "../types";
-export declare const isEqual: (left: RelationOperand, right: RelationOperand) => boolean;
+import { RelationOperand } from "../types";
+export declare const isEqual: (left: RelationOperand, right: RelationOperand) => boolean;

package/dist/{src/operators → operators}/isRelation.d.ts

@@ -1 +1 @@
-export declare const isRelation: (op: any) => boolean;
+export declare const isRelation: (op: any) => boolean;

package/dist/{src/operators → operators}/join.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, JoinKeys } from "../types";
-export declare const join: (left: RelationOperand, right: RelationOperand, keys?: JoinKeys) => RelationOperand;
+import { RelationOperand, JoinKeys } from "../types";
+export declare const join: (left: RelationOperand, right: RelationOperand, keys?: JoinKeys) => RelationOperand;

package/dist/{src/operators → operators}/left_join.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, JoinKeys } from "../types";
-export declare const left_join: (left: RelationOperand, right: RelationOperand, keys?: JoinKeys) => RelationOperand;
+import { RelationOperand, JoinKeys } from "../types";
+export declare const left_join: (left: RelationOperand, right: RelationOperand, keys?: JoinKeys) => RelationOperand;

package/dist/{src/src/operators → operators}/matching.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, JoinKeys } from "../types";
-export declare const matching: (left: RelationOperand, right: RelationOperand, keys?: JoinKeys) => RelationOperand;
+import { RelationOperand, JoinKeys } from "../types";
+export declare const matching: (left: RelationOperand, right: RelationOperand, keys?: JoinKeys) => RelationOperand;

package/dist/{src/src/operators → operators}/minus.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand } from "../types";
-export declare const minus: (left: RelationOperand, right: RelationOperand) => RelationOperand;
+import { RelationOperand } from "../types";
+export declare const minus: (left: RelationOperand, right: RelationOperand) => RelationOperand;

package/dist/{src/src/operators → operators}/not_matching.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, JoinKeys } from "../types";
-export declare const not_matching: (left: RelationOperand, right: RelationOperand, keys?: JoinKeys) => RelationOperand;
+import { RelationOperand, JoinKeys } from "../types";
+export declare const not_matching: (left: RelationOperand, right: RelationOperand, keys?: JoinKeys) => RelationOperand;

package/dist/{src/operators → operators}/one.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, Tuple } from "../types";
-export declare const one: (operand: RelationOperand) => Tuple;
+import { RelationOperand, Tuple } from "../types";
+export declare const one: (operand: RelationOperand) => Tuple;

package/dist/{src/operators → operators}/prefix.d.ts

@@ -1,2 +1,2 @@
-import { PrefixOptions, RelationOperand } from "../types";
-export declare const prefix: (operand: RelationOperand, pfx: string, options?: PrefixOptions) => RelationOperand;
+import { PrefixOptions, RelationOperand } from "../types";
+export declare const prefix: (operand: RelationOperand, pfx: string, options?: PrefixOptions) => RelationOperand;

package/dist/{src/src/operators → operators}/project.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, AttrName } from "../types";
-export declare const project: (operand: RelationOperand, attrs: AttrName[]) => RelationOperand;
+import { RelationOperand, AttrName } from "../types";
+export declare const project: (operand: RelationOperand, attrs: AttrName[]) => RelationOperand;

package/dist/{src/operators → operators}/rename.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, Renaming } from "../types";
-export declare const rename: (operand: RelationOperand, renaming: Renaming) => RelationOperand;
+import { RelationOperand, Renaming } from "../types";
+export declare const rename: (operand: RelationOperand, renaming: Renaming) => RelationOperand;

package/dist/{src/operators → operators}/restrict.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, Predicate } from "../types";
-export declare const restrict: (operand: RelationOperand, p: Predicate) => RelationOperand;
+import { RelationOperand, Predicate } from "../types";
+export declare const restrict: (operand: RelationOperand, p: Predicate) => RelationOperand;

package/dist/{src/operators → operators}/suffix.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, SuffixOptions } from "../types";
-export declare const suffix: (operand: RelationOperand, sfx: string, options?: SuffixOptions) => RelationOperand;
+import { RelationOperand, SuffixOptions } from "../types";
+export declare const suffix: (operand: RelationOperand, sfx: string, options?: SuffixOptions) => RelationOperand;

package/dist/{src/operators → operators}/summarize.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, AttrName, Aggregators } from "../types";
-export declare const summarize: (operand: RelationOperand, by: AttrName[], aggs: Aggregators) => RelationOperand;
+import { RelationOperand, AttrName, Aggregators } from "../types";
+export declare const summarize: (operand: RelationOperand, by: AttrName[], aggs: Aggregators) => RelationOperand;

package/dist/{src/operators → operators}/transform.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, Transformation } from "../types";
-export declare const transform: (operand: RelationOperand, transformation: Transformation) => RelationOperand;
+import { RelationOperand, Transformation } from "../types";
+export declare const transform: (operand: RelationOperand, transformation: Transformation) => RelationOperand;

package/dist/{src/src/operators → operators}/ungroup.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, AttrName } from "../types";
-export declare const ungroup: (operand: RelationOperand, attr: AttrName) => RelationOperand;
+import { RelationOperand, AttrName } from "../types";
+export declare const ungroup: (operand: RelationOperand, attr: AttrName) => RelationOperand;

package/dist/{src/operators → operators}/union.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand } from "../types";
-export declare const union: (left: RelationOperand, right: RelationOperand) => RelationOperand;
+import { RelationOperand } from "../types";
+export declare const union: (left: RelationOperand, right: RelationOperand) => RelationOperand;

package/dist/{src/operators → operators}/unwrap.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, AttrName } from "../types";
-export declare const unwrap: (operand: RelationOperand, attr: AttrName) => RelationOperand;
+import { RelationOperand, AttrName } from "../types";
+export declare const unwrap: (operand: RelationOperand, attr: AttrName) => RelationOperand;

package/dist/{src/operators → operators}/where.d.ts

@@ -1 +1 @@
-export { restrict as where } from './restrict';
+export { restrict as where } from './restrict';

package/dist/{src/operators → operators}/wrap.d.ts

@@ -1,2 +1,2 @@
-import { RelationOperand, AttrName } from "../types";
-export declare const wrap: (operand: RelationOperand, attrs: AttrName[], as: AttrName) => RelationOperand;
+import { RelationOperand, AttrName } from "../types";
+export declare const wrap: (operand: RelationOperand, attrs: AttrName[], as: AttrName) => RelationOperand;

package/dist/{src/operators → operators}/yByX.d.ts

@@ -1,2 +1,2 @@
-import { AttrName, RelationOperand, Tuple } from "../types";
-export declare const yByX: (operand: RelationOperand, y: AttrName, x: AttrName) => Tuple;
+import { AttrName, RelationOperand, Tuple } from "../types";
+export declare const yByX: (operand: RelationOperand, y: AttrName, x: AttrName) => Tuple;

package/dist/{src/src/support → support}/toPredicateFunc.d.ts

@@ -1,2 +1,2 @@
-import { Predicate, PredicateFunc } from '../types';
-export declare const toPredicateFunc: (p: Predicate) => PredicateFunc;
+import { Predicate, PredicateFunc } from '../types';
+export declare const toPredicateFunc: (p: Predicate) => PredicateFunc;