@snowtop/ent 0.1.12 → 0.1.14-test1

package/action/action.d.ts

@@ -24,7 +24,7 @@ export interface Builder<TEnt extends Ent<TViewer>, TViewer extends Viewer = Vie
     getInput(): Data;
     orchestrator: BuilderOrchestrator;
 }
-export interface Executor extends Iterable<DataOperation>, Iterator<DataOperation> {
+export interface Executor extends Iterable<DataOperation<Ent>>, Iterator<DataOperation<Ent>> {
     placeholderID: ID;
     resolveValue(val: any): Ent | null;
     builderOpChanged(builder: Builder<any>): boolean;

package/action/executor.d.ts

@@ -40,7 +40,7 @@ export declare class ComplexExecutor<T extends Ent> implements Executor {
     private executors;
     private changedOps;
     builder?: Builder<Ent> | undefined;
-    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation[], dependencies: Map<ID, Builder<T>>, changesets: Changeset[], options?: OrchestratorOptions<T, Data, Viewer>, complexOptions?: ComplexExecutorOptions | undefined);
+    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation<T>[], dependencies: Map<ID, Builder<T>>, changesets: Changeset[], options?: OrchestratorOptions<T, Data, Viewer>, complexOptions?: ComplexExecutorOptions | undefined);
     [Symbol.iterator](): this;
     private handleCreatedEnt;
     next(): IteratorResult<DataOperation<Ent>>;
@@ -51,5 +51,5 @@ export declare class ComplexExecutor<T extends Ent> implements Executor {
     preFetch?(queryer: Queryer, context: Context): Promise<void>;
     postFetch?(queryer: Queryer, context: Context): Promise<void>;
 }
-export declare function executeOperations(executor: Executor, context?: Context, trackOps?: true): Promise<DataOperation<Ent<Viewer<Ent<any> | null, ID | null>>>[]>;
+export declare function executeOperations(executor: Executor, context?: Context, trackOps?: true): Promise<DataOperation<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>[]>;
 export {};

package/action/experimental_action.js

@@ -64,11 +64,11 @@ class BaseAction {
     }
     async save() {
         await this.builder.save();
-        return await this.builder.editedEnt();
+        return this.builder.editedEnt();
     }
     async saveX() {
         await this.builder.saveX();
-        return await this.builder.editedEntX();
+        return this.builder.editedEntX();
     }
     getInput() {
         return this.input;

package/action/operations.d.ts

@@ -3,62 +3,62 @@ import { Viewer, Ent, ID, Data, DataOptions, EditRowOptions, LoadEntOptions, Con
 import { Executor } from "../action/action";
 import { WriteOperation, Builder } from "../action";
 import { AssocEdgeData, parameterizedQueryOptions } from "../core/ent";
-export interface UpdatedOperation {
+export interface UpdatedOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     operation: WriteOperation;
-    builder: Builder<any>;
+    builder: Builder<TEnt, TViewer>;
 }
-export interface DataOperation<T extends Ent = Ent> {
-    builder: Builder<T>;
+export interface DataOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+    builder: Builder<TEnt, TViewer>;
     preFetch?(queryer: Queryer, context?: Context): Promise<void>;
     performWriteSync(queryer: SyncQueryer, context?: Context): void;
     performWrite(queryer: Queryer, context?: Context): Promise<void>;
     placeholderID?: ID;
     returnedRow?(): Data | null;
-    createdEnt?(viewer: Viewer): T | null;
+    createdEnt?(viewer: Viewer): TEnt | null;
     shortCircuit?(executor: Executor): boolean;
-    updatedOperation?(): UpdatedOperation | null;
+    updatedOperation?(): UpdatedOperation<TEnt, TViewer> | null;
     resolve?(executor: Executor): void;
     postFetch?(queryer: Queryer, context?: Context): Promise<void>;
 }
-export declare class DeleteNodeOperation implements DataOperation {
+export declare class DeleteNodeOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> implements DataOperation<TEnt, TViewer> {
     private id;
-    readonly builder: Builder<Ent>;
+    readonly builder: Builder<TEnt, TViewer>;
     private options;
-    constructor(id: ID, builder: Builder<Ent>, options: DataOptions);
+    constructor(id: ID, builder: Builder<TEnt, TViewer>, options: DataOptions);
     performWrite(queryer: Queryer, context?: Context): Promise<void>;
     performWriteSync(queryer: SyncQueryer, context?: Context): void;
 }
-export declare class RawQueryOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> implements DataOperation<TEnt> {
+export declare class RawQueryOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> implements DataOperation<TEnt, TViewer> {
     builder: Builder<TEnt, TViewer>;
     private queries;
     constructor(builder: Builder<TEnt, TViewer>, queries: (string | parameterizedQueryOptions)[]);
     performWrite(queryer: Queryer, context?: Context): Promise<void>;
     performWriteSync(queryer: SyncQueryer, context?: Context): void;
 }
-export interface EditNodeOptions<T extends Ent> extends EditRowOptions {
+export interface EditNodeOptions<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends EditRowOptions {
     fieldsToResolve: string[];
-    loadEntOptions: LoadEntOptions<T>;
+    loadEntOptions: LoadEntOptions<TEnt>;
     key: string;
     onConflict?: CreateRowOptions["onConflict"];
-    builder: Builder<T>;
+    builder: Builder<TEnt, TViewer>;
 }
-export declare class NoOperation<T extends Ent> implements DataOperation<T> {
-    builder: Builder<any>;
+export declare class NoOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> implements DataOperation<TEnt, TViewer> {
+    builder: Builder<TEnt, TViewer>;
     private row;
-    constructor(builder: Builder<any>, existingEnt?: Ent | null);
+    constructor(builder: Builder<TEnt, TViewer>, existingEnt?: Ent | null);
     performWrite(queryer: Queryer, context?: Context): Promise<void>;
     performWriteSync(queryer: SyncQueryer, context?: Context): void;
     returnedRow(): Data | null;
 }
-export declare class EditNodeOperation<T extends Ent> implements DataOperation {
-    options: EditNodeOptions<T>;
+export declare class EditNodeOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> implements DataOperation<TEnt, TViewer> {
+    options: EditNodeOptions<TEnt, TViewer>;
     private existingEnt;
     private row;
     placeholderID?: ID | undefined;
     private updatedOp;
-    builder: Builder<T>;
+    builder: Builder<TEnt, TViewer>;
     private resolved;
-    constructor(options: EditNodeOptions<T>, existingEnt?: Ent | null);
+    constructor(options: EditNodeOptions<TEnt, TViewer>, existingEnt?: Ent | null);
     resolve<T extends Ent>(executor: Executor): void;
     private hasData;
     private buildOnConflictQuery;
@@ -67,8 +67,8 @@ export declare class EditNodeOperation<T extends Ent> implements DataOperation {
     private reloadRow;
     performWriteSync(queryer: SyncQueryer, context?: Context): void;
     returnedRow(): Data | null;
-    createdEnt(viewer: Viewer): T | null;
-    updatedOperation(): UpdatedOperation | null;
+    createdEnt(viewer: Viewer): TEnt | null;
+    updatedOperation(): UpdatedOperation<TEnt, TViewer> | null;
 }
 export interface AssocEdgeInputOptions extends AssocEdgeOptions {
     time?: Date;
@@ -85,8 +85,8 @@ export interface AssocEdgeInput extends AssocEdgeInputOptions {
     id2: ID;
     id2Type: string;
 }
-export declare class EdgeOperation implements DataOperation {
-    builder: Builder<any>;
+export declare class EdgeOperation<TViewer extends Viewer = Viewer> implements DataOperation<any, TViewer> {
+    builder: Builder<any, TViewer>;
     edgeInput: AssocEdgeInput;
     private options;
     private edgeData;
@@ -102,33 +102,33 @@ export declare class EdgeOperation implements DataOperation {
     private performInsertWriteSync;
     private resolveImpl;
     resolve(executor: Executor): void;
-    symmetricEdge(): EdgeOperation;
-    inverseEdge(edgeData: AssocEdgeData): EdgeOperation;
+    symmetricEdge(): EdgeOperation<TViewer>;
+    inverseEdge(edgeData: AssocEdgeData): EdgeOperation<TViewer>;
     private static resolveIDs;
     private static isBuilder;
     private static resolveData;
-    static inboundEdge<T extends Ent, T2 extends Ent>(builder: Builder<T>, edgeType: string, id1: Builder<T2> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation;
-    static outboundEdge<T extends Ent, T2 extends Ent>(builder: Builder<T>, edgeType: string, id2: Builder<T2> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation;
-    static removeInboundEdge<T extends Ent>(builder: Builder<T>, edgeType: string, id1: ID, options?: AssocEdgeInputOptions): EdgeOperation;
-    static removeOutboundEdge<T extends Ent>(builder: Builder<T>, edgeType: string, id2: ID, options?: AssocEdgeInputOptions): EdgeOperation;
+    static inboundEdge<T extends Ent<TViewer>, T2 extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<T, TViewer>, edgeType: string, id1: Builder<T2, TViewer> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation<TViewer>;
+    static outboundEdge<T extends Ent<TViewer>, T2 extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<T, TViewer>, edgeType: string, id2: Builder<T2, TViewer> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation<TViewer>;
+    static removeInboundEdge<T extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<T, TViewer>, edgeType: string, id1: ID, options?: AssocEdgeInputOptions): EdgeOperation<TViewer>;
+    static removeOutboundEdge<T extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<T, TViewer>, edgeType: string, id2: ID, options?: AssocEdgeInputOptions): EdgeOperation<TViewer>;
 }
-export declare class ConditionalOperation<T extends Ent = Ent> implements DataOperation<T> {
-    protected op: DataOperation<T>;
+export declare class ConditionalOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> implements DataOperation<TEnt, TViewer> {
+    protected op: DataOperation<TEnt, TViewer>;
     private conditionalBuilder;
     placeholderID?: ID | undefined;
     protected shortCircuited: boolean;
-    readonly builder: Builder<T>;
-    constructor(op: DataOperation<T>, conditionalBuilder: Builder<any>);
+    readonly builder: Builder<TEnt, TViewer>;
+    constructor(op: DataOperation<TEnt, TViewer>, conditionalBuilder: Builder<TEnt, TViewer>);
     shortCircuit(executor: Executor): boolean;
     preFetch(queryer: Queryer, context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<void>;
     performWriteSync(queryer: SyncQueryer, context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined): void;
     performWrite(queryer: Queryer, context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<void>;
     returnedRow(): Data | null;
-    updatedOperation(): UpdatedOperation | null;
+    updatedOperation(): UpdatedOperation<TEnt, TViewer> | null;
     resolve(executor: Executor): void;
     postFetch(queryer: Queryer, context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<void>;
 }
-export declare class ConditionalNodeOperation<T extends Ent> extends ConditionalOperation<T> {
-    createdEnt(viewer: Viewer): T | null;
-    updatedOperation(): UpdatedOperation | null;
+export declare class ConditionalNodeOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends ConditionalOperation<TEnt, TViewer> {
+    createdEnt(viewer: Viewer): TEnt | null;
+    updatedOperation(): UpdatedOperation<TEnt, TViewer> | null;
 }

package/action/operations.js

@@ -358,7 +358,7 @@ class EdgeOperation {
     async performDeleteWrite(q, edgeData, edge, context) {
         const params = this.getDeleteRowParams(edgeData, edge, context);
         if (params.op === schema_1.SQLStatementOperation.Delete) {
-            return (0, ent_1.deleteRows)(q, params.options, params.clause);
+            return (0, ent_1.deleteRows)(q, { ...params.options, context }, params.clause);
         }
         else {
             if (params.op !== schema_1.SQLStatementOperation.Update) {
@@ -369,13 +369,14 @@ class EdgeOperation {
                 whereClause: params.clause,
                 fields: params.updateData,
                 fieldsToLog: params.updateData,
+                context,
             });
         }
     }
     performDeleteWriteSync(q, edgeData, edge, context) {
         const params = this.getDeleteRowParams(edgeData, edge, context);
         if (params.op === schema_1.SQLStatementOperation.Delete) {
-            return (0, ent_1.deleteRowsSync)(q, params.options, params.clause);
+            return (0, ent_1.deleteRowsSync)(q, { ...params.options, context }, params.clause);
         }
         else {
             if (params.op !== schema_1.SQLStatementOperation.Update) {
@@ -385,6 +386,7 @@ class EdgeOperation {
                 tableName: params.options.tableName,
                 whereClause: params.clause,
                 fields: params.updateData,
+                context,
             });
         }
     }

package/action/orchestrator.d.ts

@@ -21,14 +21,14 @@ export interface OrchestratorOptions<TEnt extends Ent<TViewer>, TInput extends D
     expressions?: Map<string, clause.Clause>;
     fieldInfo: FieldInfoMap;
 }
-interface edgeInputDataOpts {
+interface edgeInputDataOpts<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     edgeType: string;
-    id: Builder<Ent> | ID;
+    id: Builder<TEnt, TViewer> | ID;
     nodeType?: string;
     options?: AssocEdgeInputOptions;
 }
-export interface EdgeInputData extends edgeInputDataOpts {
-    isBuilder(id: Builder<Ent> | ID): id is Builder<Ent>;
+export interface EdgeInputData<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends edgeInputDataOpts<TEnt, TViewer> {
+    isBuilder(id: Builder<TEnt, TViewer> | ID): id is Builder<TEnt, TViewer>;
 }
 export declare enum edgeDirection {
     inboundEdge = 0,
@@ -62,7 +62,7 @@ export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data
     addOutboundEdge<T2 extends Ent>(id2: ID | Builder<T2, any>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
     removeInboundEdge(id1: ID, edgeType: string, options?: AssocEdgeOptions): void;
     removeOutboundEdge(id2: ID, edgeType: string, options?: AssocEdgeOptions): void;
-    getInputEdges(edgeType: string, op: WriteOperation): EdgeInputData[];
+    getInputEdges(edgeType: string, op: WriteOperation): EdgeInputData<any, TViewer>[];
     clearInputEdges(edgeType: string, op: WriteOperation, id?: ID): void;
     private buildMainOp;
     private getEdgeOperation;
@@ -108,24 +108,24 @@ export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data
     editedEnt(): Promise<TEnt | null>;
     editedEntX(): Promise<TEnt>;
 }
-export declare class EntChangeset<T extends Ent> implements Changeset {
+export declare class EntChangeset<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> implements Changeset {
     viewer: Viewer;
     private builder;
     readonly placeholderID: ID;
     private conditionalOverride;
-    operations: DataOperation[];
+    operations: DataOperation<any, TViewer>[];
     dependencies?: Map<ID, Builder<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>, Ent<Viewer<Ent<any> | null, ID | null>> | null>> | undefined;
     changesets?: Changeset[] | undefined;
     private options?;
     private _executor;
-    constructor(viewer: Viewer, builder: Builder<T>, placeholderID: ID, conditionalOverride: boolean, operations: DataOperation[], dependencies?: Map<ID, Builder<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>, Ent<Viewer<Ent<any> | null, ID | null>> | null>> | undefined, changesets?: Changeset[] | undefined, options?: OrchestratorOptions<T, Data, Viewer<Ent<any> | null, ID | null>, MaybeNull<T>> | undefined);
-    static changesetFrom(builder: Builder<any, any, any>, ops: DataOperation[]): EntChangeset<any>;
-    static changesetFromQueries(builder: Builder<any, any, any>, queries: Array<string | parameterizedQueryOptions>): EntChangeset<any>;
+    constructor(viewer: Viewer, builder: Builder<TEnt, TViewer>, placeholderID: ID, conditionalOverride: boolean, operations: DataOperation<any, TViewer>[], dependencies?: Map<ID, Builder<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>, Ent<Viewer<Ent<any> | null, ID | null>> | null>> | undefined, changesets?: Changeset[] | undefined, options?: OrchestratorOptions<TEnt, Data, TViewer, MaybeNull<TEnt>> | undefined);
+    static changesetFrom<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, ops: DataOperation<any, TViewer>[]): EntChangeset<any, TViewer>;
+    static changesetFromQueries<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, queries: Array<string | parameterizedQueryOptions>): EntChangeset<any, TViewer>;
     private static changesetFromEdgeOp;
-    static changesetFromOutboundEdge(builder: Builder<any, any, any>, edgeType: string, id2: Builder<any> | ID, nodeType: string, options?: AssocEdgeInputOptions): Promise<EntChangeset<any>>;
-    static changesetFromInboundEdge(builder: Builder<any, any, any>, edgeType: string, id1: Builder<any> | ID, nodeType: string, options?: AssocEdgeInputOptions): Promise<EntChangeset<any>>;
-    static changesetRemoveFromOutboundEdge(builder: Builder<any, any, any>, edgeType: string, id2: ID, options?: AssocEdgeInputOptions): Promise<EntChangeset<any>>;
-    static changesetRemoveFromInboundEdge(builder: Builder<any, any, any>, edgeType: string, id1: ID, options?: AssocEdgeInputOptions): Promise<EntChangeset<any>>;
+    static changesetFromOutboundEdge<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, edgeType: string, id2: Builder<any, TViewer> | ID, nodeType: string, options?: AssocEdgeInputOptions): Promise<EntChangeset<any, TViewer>>;
+    static changesetFromInboundEdge<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, edgeType: string, id1: Builder<any, TViewer> | ID, nodeType: string, options?: AssocEdgeInputOptions): Promise<EntChangeset<any, TViewer>>;
+    static changesetRemoveFromOutboundEdge<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, edgeType: string, id2: ID, options?: AssocEdgeInputOptions): Promise<EntChangeset<any, TViewer>>;
+    static changesetRemoveFromInboundEdge<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, edgeType: string, id1: ID, options?: AssocEdgeInputOptions): Promise<EntChangeset<any, TViewer>>;
     executor(): Executor;
 }
 export {};

package/core/base.d.ts

@@ -26,21 +26,16 @@ export interface PrimableLoader<K, V> extends Loader<K, V> {
     prime(d: V): void;
     primeAll?(d: V): void;
 }
+export type QueryOptions = Required<Pick<LoadRowsOptions, "clause" | "fields" | "tableName">> & Pick<LoadRowsOptions, "orderby" | "join">;
 interface cache {
     getLoader<K, V>(name: string, create: () => Loader<K, V>): Loader<K, V>;
     getLoaderWithLoadMany<K, V>(name: string, create: () => LoaderWithLoadMany<K, V>): LoaderWithLoadMany<K, V>;
-    getCachedRows(options: queryOptions): Data[] | null;
-    getCachedRow(options: queryOptions): Data | null;
-    primeCache(options: queryOptions, rows: Data[]): void;
-    primeCache(options: queryOptions, rows: Data): void;
+    getCachedRows(options: QueryOptions): Data[] | null;
+    getCachedRow(options: QueryOptions): Data | null;
+    primeCache(options: QueryOptions, rows: Data[]): void;
+    primeCache(options: QueryOptions, rows: Data): void;
     clearCache(): void;
 }
-interface queryOptions {
-    fields: string[];
-    tableName: string;
-    clause: clause.Clause;
-    orderby?: OrderBy;
-}
 export interface Context<TViewer extends Viewer = Viewer> {
     getViewer(): TViewer;
     cache?: cache;
@@ -67,6 +62,7 @@ export interface EntConstructor<TEnt extends Ent, TViewer extends Viewer = Viewe
 export type ID = string | number;
 export interface DataOptions {
     tableName: string;
+    alias?: string;
     context?: Context;
 }
 export interface SelectBaseDataOptions extends DataOptions {
@@ -79,6 +75,11 @@ export interface SelectDataOptions extends SelectBaseDataOptions {
 }
 export interface QueryableDataOptions extends SelectBaseDataOptions, QueryDataOptions {
 }
+interface JoinOptions<T2 extends Data = Data, K2 = keyof T2> {
+    tableName: string;
+    alias?: string;
+    clause: clause.Clause<T2, K2>;
+}
 export interface QueryDataOptions<T extends Data = Data, K = keyof T> {
     distinct?: boolean;
     clause: clause.Clause<T, K>;
@@ -86,6 +87,7 @@ export interface QueryDataOptions<T extends Data = Data, K = keyof T> {
     groupby?: K;
     limit?: number;
     disableTransformations?: boolean;
+    join?: JoinOptions;
 }
 export interface LoadRowOptions extends QueryableDataOptions {
 }

package/core/clause.d.ts

@@ -1,6 +1,6 @@
 import { Data, ID, SelectDataOptions } from "./base";
 export interface Clause<T extends Data = Data, K = keyof T> {
-    clause(idx: number): string;
+    clause(idx: number, alias?: string): string;
     columns(): K[];
     values(): any[];
     instanceKey(): string;
@@ -19,7 +19,7 @@ export declare class inClause<T extends Data, K = keyof T> implements Clause<T,
     protected op: InClauseOperator;
     static getPostgresInClauseValuesThreshold(): number;
     constructor(col: K, value: any[], type?: string);
-    clause(idx: number): string;
+    clause(idx: number, alias?: string): string;
     columns(): K[];
     values(): any[];
     logValues(): any[];
@@ -124,5 +124,6 @@ export declare function Subtract<T extends Data, K = keyof T>(col: K, value: any
 export declare function Multiply<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
 export declare function Divide<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
 export declare function Modulo<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
-export declare function getCombinedClause<V extends Data = Data, K = keyof V>(options: Omit<SelectDataOptions, "key">, cls: Clause<V, K>): Clause<V, K>;
+export declare function getCombinedClause<V extends Data = Data, K = keyof V>(options: Pick<SelectDataOptions, "clause">, cls: Clause<V, K>, checkIntersection?: boolean): Clause<V, K>;
+export declare function Expression<T extends Data, K = keyof T>(expression: string): Clause<T, K>;
 export {};