@snowtop/ent 0.1.0-alpha16 → 0.1.0-alpha160-test2

package/action/relative_value.d.ts

@@ -0,0 +1,47 @@
+import { Clause } from "../core/clause";
+export interface RelativeFieldValue<T = BigInt | number> {
+    delta: T;
+    sqlExpression: (col: string) => Clause;
+    eval: (curr: T) => T;
+}
+export interface RelativeNumberValue<T> {
+    add?: T;
+    subtract?: T;
+    divide?: T;
+    multiply?: T;
+    modulo?: T;
+}
+declare function addNumber(delta: number): RelativeFieldValue<number>;
+declare function addNumber(delta: BigInt): RelativeFieldValue<BigInt>;
+declare function subtractNumber(delta: number): RelativeFieldValue<number>;
+declare function subtractNumber(delta: BigInt): RelativeFieldValue<BigInt>;
+declare function multiplyNumber(delta: number): RelativeFieldValue<number>;
+declare function multiplyNumber(delta: BigInt): RelativeFieldValue<BigInt>;
+declare function divideNumber(delta: number): RelativeFieldValue<number>;
+declare function divideNumber(delta: BigInt): RelativeFieldValue<BigInt>;
+declare function moduloNumber(delta: number): RelativeFieldValue<number>;
+declare function moduloNumber(delta: BigInt): RelativeFieldValue<BigInt>;
+export declare const NumberOps: {
+    addNumber: typeof addNumber;
+    moduloNumber: typeof moduloNumber;
+    divideNumber: typeof divideNumber;
+    subtractNumber: typeof subtractNumber;
+    multiplyNumber: typeof multiplyNumber;
+};
+export declare function convertRelativeInput(rel: RelativeNumberValue<BigInt>, col: string, existing: BigInt): {
+    value: BigInt;
+    clause: Clause;
+};
+export declare function convertRelativeInput(rel: RelativeNumberValue<number>, col: string, existing: number): {
+    value: number;
+    clause: Clause;
+};
+export declare function maybeConvertRelativeInputPlusExpressions(rel: number | RelativeNumberValue<number>, col: string, existing: number, expressions: Map<string, Clause>): number;
+export declare function maybeConvertRelativeInputPlusExpressions(rel: number | RelativeNumberValue<number> | undefined, col: string, existing: number, expressions: Map<string, Clause>): number | undefined;
+export declare function maybeConvertRelativeInputPlusExpressions(rel: number | RelativeNumberValue<number> | null, col: string, existing: number | null, expressions: Map<string, Clause>): number | null;
+export declare function maybeConvertRelativeInputPlusExpressions(rel: number | RelativeNumberValue<number> | null | undefined, col: string, existing: number | null, expressions: Map<string, Clause>): number | undefined | null;
+export declare function maybeConvertRelativeInputPlusExpressions(rel: BigInt | RelativeNumberValue<BigInt>, col: string, existing: BigInt, expressions: Map<string, Clause>): BigInt;
+export declare function maybeConvertRelativeInputPlusExpressions(rel: BigInt | RelativeNumberValue<BigInt> | undefined, col: string, existing: BigInt, expressions: Map<string, Clause>): BigInt | undefined;
+export declare function maybeConvertRelativeInputPlusExpressions(rel: BigInt | RelativeNumberValue<BigInt> | null, col: string, existing: BigInt | null, expressions: Map<string, Clause>): BigInt | null;
+export declare function maybeConvertRelativeInputPlusExpressions(rel: BigInt | RelativeNumberValue<BigInt> | null | undefined, col: string, existing: BigInt | null, expressions: Map<string, Clause>): BigInt | null | undefined;
+export {};

package/action/relative_value.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maybeConvertRelativeInputPlusExpressions = exports.convertRelativeInput = exports.NumberOps = void 0;
+const clause_1 = require("../core/clause");
+function addNumber(delta) {
+    return {
+        delta,
+        sqlExpression(col) {
+            return (0, clause_1.Add)(col, delta);
+        },
+        eval(curr) {
+            // @ts-expect-error
+            return curr + delta;
+        },
+    };
+}
+function subtractNumber(delta) {
+    return {
+        delta,
+        sqlExpression(col) {
+            return (0, clause_1.Subtract)(col, delta);
+        },
+        eval(curr) {
+            // @ts-expect-error
+            return curr - delta;
+        },
+    };
+}
+function multiplyNumber(delta) {
+    return {
+        delta,
+        sqlExpression(col) {
+            return (0, clause_1.Multiply)(col, delta);
+        },
+        eval(curr) {
+            // @ts-expect-error
+            return curr * delta;
+        },
+    };
+}
+function divideNumber(delta) {
+    return {
+        delta,
+        sqlExpression(col) {
+            return (0, clause_1.Divide)(col, delta);
+        },
+        eval(curr) {
+            // @ts-expect-error
+            return curr / delta;
+        },
+    };
+}
+function moduloNumber(delta) {
+    return {
+        delta,
+        sqlExpression(col) {
+            return (0, clause_1.Modulo)(col, delta);
+        },
+        eval(curr) {
+            // @ts-expect-error
+            return curr % delta;
+        },
+    };
+}
+exports.NumberOps = {
+    addNumber,
+    moduloNumber,
+    divideNumber,
+    subtractNumber,
+    multiplyNumber,
+};
+function convertRelativeInput(rel, col, existing) {
+    if (Object.keys(rel).length !== 1) {
+        throw new Error(`only 1 key is expected. ${Object.keys(rel).length} given`);
+    }
+    const ret = (relField) => {
+        return {
+            value: relField.eval(existing),
+            clause: relField.sqlExpression(col),
+        };
+    };
+    if (rel.add !== undefined) {
+        // @ts-expect-error
+        return ret(addNumber(rel.add));
+    }
+    if (rel.subtract !== undefined) {
+        // @ts-expect-error
+        return ret(subtractNumber(rel.subtract));
+    }
+    if (rel.multiply !== undefined) {
+        // @ts-expect-error
+        return ret(multiplyNumber(rel.multiply));
+    }
+    if (rel.divide !== undefined) {
+        // @ts-expect-error
+        return ret(divideNumber(rel.divide));
+    }
+    if (rel.modulo !== undefined) {
+        // @ts-expect-error
+        return ret(moduloNumber(rel.modulo));
+    }
+    throw new Error(`error in convertRelativeInput. shouldn't have gotten here`);
+}
+exports.convertRelativeInput = convertRelativeInput;
+function maybeConvertRelativeInputPlusExpressions(rel, col, existing, expressions) {
+    if (rel === null) {
+        return rel;
+    }
+    if (rel === undefined) {
+        return rel;
+    }
+    if (typeof rel === "bigint" || typeof rel === "number") {
+        return rel;
+    }
+    // // TODO is this the behavior we want? should we coalesce as 0?
+    // if (existing === null) {
+    //   throw new Error(`cannot perform a relative operation on null`);
+    // }
+    // @ts-ignore
+    // shouldn't be failing like it currently is. it thinks rel can be bigint  and it shouldn't be???
+    const { clause, value } = convertRelativeInput(rel, col, existing);
+    expressions.set(col, clause);
+    return value;
+}
+exports.maybeConvertRelativeInputPlusExpressions = maybeConvertRelativeInputPlusExpressions;

package/action/transaction.d.ts

@@ -0,0 +1,10 @@
+import { Ent, Viewer } from "../core/base";
+import { Action, Builder } from "./action";
+type ActionAny = Action<Ent<Viewer<any, any>>, Builder<Ent<Viewer<any, any>>, Viewer<any, any>, any>, Viewer<any, any>, any, any>;
+export declare class Transaction {
+    private viewer;
+    private actions;
+    constructor(viewer: Viewer, actions: ActionAny[]);
+    run(): Promise<void>;
+}
+export {};

package/action/transaction.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = void 0;
+const executor_1 = require("./executor");
+class Transaction {
+    constructor(viewer, 
+    // independent operations
+    actions) {
+        this.viewer = viewer;
+        this.actions = actions;
+    }
+    async run() {
+        const changesets = [];
+        await Promise.all(this.actions.map(async (action) => {
+            const c = await action.changeset();
+            changesets.push(c);
+        }));
+        const executor = new executor_1.ComplexExecutor(this.viewer, "", // no placeholder, no opers
+        [], new Map(), changesets);
+        await executor.execute();
+    }
+}
+exports.Transaction = Transaction;

package/auth/auth.d.ts

@@ -2,7 +2,7 @@
 import { Viewer } from "../core/base";
 import { RequestContext } from "../core/context";
 import { IncomingMessage, ServerResponse } from "http";
-export declare type AuthViewer = Viewer | null;
+export type AuthViewer = Viewer | null;
 export interface AuthHandler {
     authViewer(ctx: RequestContext): AuthViewer | Promise<AuthViewer>;
 }

package/core/base.d.ts

@@ -1,23 +1,34 @@
 import * as clause from "./clause";
-export interface Loader<T, V> {
+import { ObjectLoaderFactory } from "./loaders";
+import { OrderBy } from "./query_impl";
+export interface Loader<K, V> {
     context?: Context;
-    load(key: T): Promise<V>;
-    loadMany?(keys: T[]): Promise<(V | null)[]>;
+    load(key: K): Promise<V>;
+    loadMany?(keys: K[]): Promise<(V | null)[]>;
     clearAll(): any;
 }
-export interface LoaderFactory<T, V> {
+export interface LoaderWithLoadMany<T, V> extends Loader<T, V> {
+    loadMany(keys: T[]): Promise<V[]>;
+}
+export interface LoaderFactory<K, V> {
     name: string;
-    createLoader(context?: Context): Loader<T, V>;
+    createLoader(context?: Context): Loader<K, V>;
+}
+interface LoaderFactoryWithLoaderMany<T, V> extends LoaderFactory<T, V> {
+    createLoader(context?: Context): LoaderWithLoadMany<T, V>;
 }
 export interface ConfigurableLoaderFactory<T, V> extends LoaderFactory<T, V> {
     createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): Loader<T, V>;
 }
-export declare type EdgeQueryableDataOptions = Partial<Pick<QueryableDataOptions, "limit" | "orderby" | "clause">>;
-export interface PrimableLoader<T, V> extends Loader<T, V> {
-    prime(d: Data): void;
+export type EdgeQueryableDataOptions = Partial<Pick<QueryableDataOptions, "limit" | "orderby" | "clause" | "disableTransformations">>;
+export type EdgeQueryableDataOptionsConfigureLoader = Pick<EdgeQueryableDataOptions, "disableTransformations">;
+export interface PrimableLoader<K, V> extends Loader<K, V> {
+    prime(d: V): void;
+    primeAll?(d: V): void;
 }
 interface cache {
-    getLoader<T, V>(name: string, create: () => Loader<T, V>): Loader<T, V>;
+    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;
@@ -28,7 +39,7 @@ interface queryOptions {
     fields: string[];
     tableName: string;
     clause: clause.Clause;
-    orderby?: string;
+    orderby?: OrderBy;
 }
 export interface Context<TViewer extends Viewer = Viewer> {
     getViewer(): TViewer;
@@ -45,6 +56,7 @@ export interface Ent<TViewer extends Viewer = Viewer> {
     viewer: TViewer;
     getPrivacyPolicy(): PrivacyPolicy<this, TViewer>;
     nodeType: string;
+    __setRawDBData<T extends Data = Data>(data: T): any;
 }
 export declare type Data = {
     [key: string]: any;
@@ -52,7 +64,7 @@ export declare type Data = {
 export interface EntConstructor<TEnt extends Ent, TViewer extends Viewer = Viewer> {
     new (viewer: TViewer, data: Data): TEnt;
 }
-export declare type ID = string | number;
+export type ID = string | number;
 export interface DataOptions {
     tableName: string;
     context?: Context;
@@ -62,44 +74,60 @@ export interface SelectBaseDataOptions extends DataOptions {
 }
 export interface SelectDataOptions extends SelectBaseDataOptions {
     key: string;
+    keyType?: string;
     clause?: clause.Clause | (() => clause.Clause | undefined);
 }
 export interface QueryableDataOptions extends SelectBaseDataOptions, QueryDataOptions {
 }
-export interface QueryDataOptions {
+export interface QueryDataOptions<T extends Data = Data, K = keyof T> {
     distinct?: boolean;
-    clause: clause.Clause;
-    orderby?: string;
-    groupby?: string;
+    clause: clause.Clause<T, K>;
+    orderby?: OrderBy;
+    groupby?: K;
     limit?: number;
+    disableTransformations?: boolean;
 }
 export interface LoadRowOptions extends QueryableDataOptions {
 }
 export interface LoadRowsOptions extends QueryableDataOptions {
 }
+interface OnConflictOptions {
+    onConflictCols: string[];
+    onConflictConstraint?: string;
+    updateCols?: string[];
+}
 export interface CreateRowOptions extends DataOptions {
     fields: Data;
     fieldsToLog?: Data;
+    onConflict?: OnConflictOptions;
 }
-export interface EditRowOptions extends CreateRowOptions {
-    key: string;
+export interface EditRowOptions extends Omit<CreateRowOptions, "onConflict"> {
+    whereClause: clause.Clause;
+    expressions?: Map<string, clause.Clause>;
 }
-interface LoadableEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> {
-    loaderFactory: LoaderFactory<any, Data | null>;
+interface LoadableEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer, TData extends Data = Data> {
+    loaderFactory: ObjectLoaderFactory<TData>;
     ent: EntConstructor<TEnt, TViewer>;
 }
-export interface LoadEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> extends LoadableEntOptions<TEnt, TViewer>, SelectBaseDataOptions {
+export interface LoaderFactoryWithOptions<T extends Data = Data> extends LoaderFactoryWithLoaderMany<any, T | null> {
+    options?: SelectDataOptions;
+}
+export interface LoadEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer, TData extends Data = Data> extends LoadableEntOptions<TEnt, TViewer, TData>, SelectBaseDataOptions {
     fieldPrivacy?: Map<string, PrivacyPolicy>;
 }
-export interface LoadCustomEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> extends SelectBaseDataOptions {
+export interface SelectCustomDataOptions<T extends Data = Data> extends SelectBaseDataOptions {
+    loaderFactory: ObjectLoaderFactory<T>;
+    prime?: boolean;
+}
+export interface LoadCustomEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer, TData extends Data = Data> extends SelectCustomDataOptions<TData> {
     ent: EntConstructor<TEnt, TViewer>;
     fieldPrivacy?: Map<string, PrivacyPolicy>;
 }
-export interface LoaderInfo {
+export interface LoaderInfo<T = Data> {
     tableName: string;
     fields: string[];
     nodeType: string;
-    loaderFactory: LoaderFactory<any, Data | null>;
+    loaderFactory: LoaderFactory<ID, T | null>;
 }
 export interface EditEntOptions<T extends Ent> extends LoadableEntOptions<T>, EditRowOptions {
 }
@@ -127,4 +155,9 @@ export interface PrivacyPolicyRule<TEnt extends Ent = Ent, TViewer = Viewer> {
 export interface PrivacyPolicy<TEnt extends Ent = Ent, TViewer = Viewer> {
     rules: PrivacyPolicyRule<TEnt, TViewer>[];
 }
+export declare enum WriteOperation {
+    Insert = "insert",
+    Edit = "edit",
+    Delete = "delete"
+}
 export {};

package/core/base.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DenyWithReason = exports.Deny = exports.Skip = exports.Allow = void 0;
+exports.WriteOperation = exports.DenyWithReason = exports.Deny = exports.Skip = exports.Allow = void 0;
 // Privacy
 var privacyResult;
 (function (privacyResult) {
@@ -53,3 +53,9 @@ function DenyWithReason(e) {
     };
 }
 exports.DenyWithReason = DenyWithReason;
+var WriteOperation;
+(function (WriteOperation) {
+    WriteOperation["Insert"] = "insert";
+    WriteOperation["Edit"] = "edit";
+    WriteOperation["Delete"] = "delete";
+})(WriteOperation = exports.WriteOperation || (exports.WriteOperation = {}));

package/core/clause.d.ts

@@ -1,61 +1,125 @@
-export interface Clause {
+import { Data, ID, SelectDataOptions } from "./base";
+export interface Clause<T extends Data = Data, K = keyof T> {
     clause(idx: number): string;
+    columns(): K[];
     values(): any[];
     instanceKey(): string;
     logValues(): any[];
+    compositeOp?: string;
 }
 export interface SensitiveValue {
     value(): any;
     logValue(): any;
 }
-declare class simpleClause implements Clause {
-    protected col: string;
+type InClauseOperator = "IN" | "NOT IN";
+export declare class inClause<T extends Data, K = keyof T> implements Clause<T, K> {
+    private col;
     private value;
-    private op;
-    private handleSqliteNull?;
-    constructor(col: string, value: any, op: string, handleSqliteNull?: Clause | undefined);
+    private type;
+    protected op: InClauseOperator;
+    static getPostgresInClauseValuesThreshold(): number;
+    constructor(col: K, value: any[], type?: string);
     clause(idx: number): string;
-    private sqliteNull;
+    columns(): K[];
     values(): any[];
     logValues(): any[];
     instanceKey(): string;
 }
-declare class compositeClause implements Clause {
-    private clauses;
-    private sep;
-    constructor(clauses: Clause[], sep: string);
-    clause(idx: number): string;
-    values(): any[];
-    logValues(): any[];
-    instanceKey(): string;
+export declare class notInClause<T extends Data, K = keyof T> extends inClause<T, K> {
+    protected op: InClauseOperator;
 }
-export declare function ArrayEq(col: string, value: any): Clause;
-export declare function ArrayNotEq(col: string, value: any): Clause;
-export declare function ArrayGreater(col: string, value: any): Clause;
-export declare function ArrayLess(col: string, value: any): Clause;
-export declare function ArrayGreaterEq(col: string, value: any): Clause;
-export declare function ArrayLessEq(col: string, value: any): Clause;
-export declare function Eq(col: string, value: any): Clause;
-export declare function NotEq(col: string, value: any): Clause;
-export declare function Greater(col: string, value: any): simpleClause;
-export declare function Less(col: string, value: any): simpleClause;
-export declare function GreaterEq(col: string, value: any): simpleClause;
-export declare function LessEq(col: string, value: any): simpleClause;
-export declare function And(...args: Clause[]): compositeClause;
-export declare function AndOptional(...args: (Clause | undefined)[]): Clause;
-export declare function Or(...args: Clause[]): compositeClause;
-export declare function In(col: string, ...values: any): Clause;
+/**
+ * creates a clause to determine if the given value is contained in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayContainsValue<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+/**
+ * creates a clause to determine if every item in the list is stored in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayContains<T extends Data, K = keyof T>(col: K, value: any[]): Clause<T, K>;
+/**
+ * creates a clause to determine if the given value is NOT contained in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayNotContainsValue<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+/**
+ * creates a clause to determine if every item in the list is NOT stored in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayNotContains<T extends Data, K = keyof T>(col: K, value: any[]): Clause<T, K>;
+/**
+ * creates a clause to determine if the arrays overlap, that is, do they have any elements in common
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayOverlaps<T extends Data, K = keyof T>(col: K, value: any[]): Clause<T, K>;
+/**
+ * creates a clause to determine if the arrays do not overlap, that is, do they have any elements in common
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayNotOverlaps<T extends Data, K = keyof T>(col: K, value: any[]): Clause<T, K>;
+/**
+ * @deprecated use PostgresArrayContainsValue
+ */
+export declare function ArrayEq<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+/**
+ * @deprecated use PostgresNotArrayContains
+ */
+export declare function ArrayNotEq<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+export declare function Eq<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+export declare function NotEq<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+export declare function Greater<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+export declare function Less<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+export declare function GreaterEq<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+export declare function LessEq<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+export declare function And<T extends Data, K = keyof T>(...args: Clause<T, K>[]): Clause<T, K>;
+export declare function AndOptional<T extends Data, K = keyof T>(...args: (Clause<T, K> | undefined)[]): Clause<T, K>;
+export declare function Or<T extends Data, K = keyof T>(...args: Clause<T, K>[]): Clause<T, K>;
+export declare function OrOptional<T extends Data, K = keyof T>(...args: (Clause<T, K> | undefined)[]): Clause<T, K>;
+/**
+ * @deprecated use UUidIn, TextIn, IntegerIn, or TypeIn
+ */
+export declare function In<T extends Data, K = keyof T>(col: K, ...values: any): Clause<T, K>;
+/**
+ * @deprecated use UUidIn, TextIn, IntegerIn, or TypeIn
+ */
+export declare function In<T extends Data, K = keyof T>(col: K, values: any[], type?: string): Clause<T, K>;
+export declare function UuidIn<T extends Data, K = keyof T>(col: K, values: ID[]): Clause<T, K>;
+export declare function IntegerIn<T extends Data, K = keyof T>(col: K, values: number[]): Clause<T, K>;
+export declare function TextIn<T extends Data, K = keyof T>(col: K, values: any[]): Clause<T, K>;
+export declare function DBTypeIn<T extends Data, K = keyof T>(col: K, values: any[], typ: string): Clause<T, K>;
+export declare function UuidNotIn<T extends Data, K = keyof T>(col: K, values: ID[]): Clause<T, K>;
+export declare function IntegerNotIn<T extends Data, K = keyof T>(col: K, values: number[]): Clause<T, K>;
+export declare function TextNotIn<T extends Data, K = keyof T>(col: K, values: any[]): Clause<T, K>;
+export declare function DBTypeNotIn<T extends Data, K = keyof T>(col: K, values: any[], typ: string): Clause<T, K>;
 interface TsQuery {
     language: "english" | "french" | "german" | "simple";
     value: string;
 }
-export declare function TsQuery(col: string, val: string | TsQuery): Clause;
-export declare function PlainToTsQuery(col: string, val: string | TsQuery): Clause;
-export declare function PhraseToTsQuery(col: string, val: string | TsQuery): Clause;
-export declare function WebsearchToTsQuery(col: string, val: string | TsQuery): Clause;
-export declare function TsVectorColTsQuery(col: string, val: string | TsQuery): Clause;
-export declare function TsVectorPlainToTsQuery(col: string, val: string | TsQuery): Clause;
-export declare function TsVectorPhraseToTsQuery(col: string, val: string | TsQuery): Clause;
-export declare function TsVectorWebsearchToTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function TsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery): Clause<T, K>;
+export declare function PlainToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery): Clause<T, K>;
+export declare function PhraseToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery): Clause<T, K>;
+export declare function WebsearchToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery): Clause<T, K>;
+export declare function TsVectorColTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery): Clause<T, K>;
+export declare function TsVectorPlainToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery): Clause<T, K>;
+export declare function TsVectorPhraseToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery): Clause<T, K>;
+export declare function TsVectorWebsearchToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery): Clause<T, K>;
 export declare function sensitiveValue(val: any): SensitiveValue;
+export declare function JSONObjectFieldKeyASJSON<T extends Data, K = keyof T>(col: K, field: string): keyof T;
+export declare function JSONObjectFieldKeyAsText<T extends Data, K = keyof T>(col: K, field: string): keyof T;
+type predicate = "==" | ">" | "<" | "!=" | ">=" | "<=";
+export declare function JSONPathValuePredicate<T extends Data, K = keyof T>(dbCol: K, path: string, val: any, pred: predicate): Clause<T, K>;
+export declare function PaginationMultipleColsSubQuery<T extends Data, K = keyof T>(col: K, op: string, tableName: string, uniqueCol: K, val: any): Clause<T, K>;
+export declare function Add<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+export declare function Subtract<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+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 {};