@sqb/builder 4.0.9 → 4.0.10

package/dist/Serializable.d.ts

@@ -0,0 +1,9 @@
+import type { SerializationType } from './enums';
+import type { SerializeContext } from './SerializeContext';
+export declare abstract class Serializable {
+    abstract _type: SerializationType;
+    /**
+     * Performs serialization
+     */
+    abstract _serialize(ctx: SerializeContext): string;
+}

package/dist/Serializable.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Serializable = void 0;
+class Serializable {
+}
+exports.Serializable = Serializable;

package/dist/SerializeContext.d.ts

@@ -0,0 +1,47 @@
+import { DefaultSerializeFunction, GenerateOptions, ParamOptions } from './types';
+export declare class SerializeContext implements GenerateOptions {
+    readonly reservedWords: string[];
+    dialect?: string;
+    prettyPrint?: boolean;
+    params?: Record<string, any>;
+    dialectVersion?: string;
+    strictParams?: boolean;
+    serializeHooks?: Function[];
+    paramOptions?: Record<string, ParamOptions> | ParamOptions[];
+    preparedParams?: Record<string, any> | any[];
+    returningFields?: {
+        field: string;
+        alias?: string;
+    }[];
+    strictParamGenId?: number;
+    constructor(opts?: GenerateOptions);
+    /**
+     * Performs a fallback mechanism, tries hook functions, extensions than default function to serialize
+     */
+    serialize(type: string, o: any, fallback: DefaultSerializeFunction): string;
+    /**
+     * Serializes object
+     */
+    anyToSQL(v: any): string;
+    /**
+     *
+     */
+    stringToSQL(val: string): string;
+    /**
+     *
+     */
+    booleanToSQL(val: any): string;
+    /**
+     *
+     */
+    numberToSQL(val: any): string;
+    /**
+     *
+     */
+    dateToSQL(date: Date): string;
+    /**
+     * Check if a string value is a reserved word
+     */
+    isReservedWord(s: string | undefined | null): boolean;
+    escapeReserved(s: string | undefined | null): string;
+}

package/dist/SerializeContext.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeContext = void 0;
+const enums_1 = require("./enums");
+const Serializable_1 = require("./Serializable");
+const extensions_1 = require("./extensions");
+class SerializeContext {
+    constructor(opts) {
+        this.reservedWords = [
+            'schema', 'table', 'field', 'index', 'foreign', 'key',
+            'select', 'insert', 'update', 'delete', 'with', 'merge',
+            'join', 'inner', 'outer', 'left', 'right', 'full',
+            'from', 'where', 'order', 'by', 'group', 'having',
+            'acs', 'ascending', 'dsc', 'descending', 'distinct',
+            'and', 'or', 'not', 'between', 'null', 'like', 'ilike',
+            'count', 'sum', 'average', 'avg', 'cascade', 'authorization',
+            'create', 'add', 'drop', 'alter', 'index', 'private', 'sequence',
+            'default', 'constraint', 'references', 'primary', 'foreign',
+            'user', 'password'
+        ];
+        if (opts)
+            Object.assign(this, opts);
+    }
+    /**
+     * Performs a fallback mechanism, tries hook functions, extensions than default function to serialize
+     */
+    serialize(type, o, fallback) {
+        if (this.serializeHooks) {
+            for (const hook of this.serializeHooks) {
+                const s = hook(this, type, o, fallback);
+                if (s != null)
+                    return s;
+            }
+        }
+        for (const ext of extensions_1.serializers) {
+            if (ext.dialect === this.dialect && ext.serialize) {
+                const s = ext.serialize(this, type, o, fallback);
+                if (s != null)
+                    return s;
+            }
+        }
+        return fallback(this, o);
+    }
+    /**
+     * Serializes object
+     */
+    anyToSQL(v) {
+        if (v == null)
+            return 'null';
+        if (Array.isArray(v)) {
+            const vv = v.map(x => this.anyToSQL(x));
+            return this.serialize(enums_1.SerializationType.ARRAY, vv, () => '(' + v.join(',')) + ')';
+        }
+        if (typeof v === 'object') {
+            if (v.isSerializable) {
+                const s = v._serialize(this);
+                return s ? (v.isQuery ? '(' + s + ')' : s) :
+                    /* istanbul ignore next */
+                    'null';
+            }
+            if (v instanceof Date) {
+                return this.serialize(enums_1.SerializationType.DATE_VALUE, v, () => this.dateToSQL(v));
+            }
+        }
+        if (typeof v === 'string') {
+            return this.serialize(enums_1.SerializationType.STRING_VALUE, v, () => this.stringToSQL(v));
+        }
+        if (typeof v === 'boolean') {
+            return this.serialize(enums_1.SerializationType.BOOLEAN_VALUE, v, () => this.booleanToSQL(v));
+        }
+        if (typeof v === 'number') {
+            return this.serialize(enums_1.SerializationType.NUMBER_VALUE, v, () => this.numberToSQL(v));
+        }
+        if (v instanceof Serializable_1.Serializable)
+            return v._serialize(this);
+        return v;
+    }
+    /**
+     *
+     */
+    stringToSQL(val) {
+        return '\'' + String(val).replace(/'/g, '\'\'') + '\'';
+    }
+    /**
+     *
+     */
+    booleanToSQL(val) {
+        return val ? 'true' : 'false';
+    }
+    /**
+     *
+     */
+    numberToSQL(val) {
+        return '' + val;
+    }
+    /**
+     *
+     */
+    dateToSQL(date) {
+        const d = date.getUTCDate();
+        const m = date.getUTCMonth() + 1;
+        const y = date.getUTCFullYear();
+        const h = date.getUTCHours();
+        const n = date.getUTCMinutes();
+        const s = date.getUTCSeconds();
+        let str = y + '-' + (m <= 9 ? '0' + m : m) + '-' + (d <= 9 ? '0' + d : d);
+        /* istanbul ignore else */
+        if (h + n + s)
+            str += ' ' + (h <= 9 ? '0' + h : h) + ':' +
+                (n <= 9 ? '0' + n : n) + ':' +
+                (s <= 9 ? '0' + s : s);
+        return '\'' + str + '\'';
+    }
+    /**
+     * Check if a string value is a reserved word
+     */
+    isReservedWord(s) {
+        if (!s)
+            return false;
+        if (this.reservedWords.includes(s.toLowerCase()))
+            return true;
+        for (const ext of extensions_1.serializers) {
+            if (ext.dialect === this.dialect && ext.isReservedWord) {
+                if (ext.isReservedWord(this, s))
+                    return true;
+            }
+        }
+        return false;
+    }
+    escapeReserved(s) {
+        if (!s)
+            return '';
+        if (this.isReservedWord(s))
+            return '"' + s + '"';
+        return s;
+    }
+}
+exports.SerializeContext = SerializeContext;

package/dist/classes.d.ts

@@ -0,0 +1,38 @@
+export * from './query/Query';
+export * from './query/ReturningQuery';
+export * from './query/SelectQuery';
+export * from './query/InsertQuery';
+export * from './query/UpdateQuery';
+export * from './query/DeleteQuery';
+export * from './sql-objects/FieldExpression';
+export * from './sql-objects/TableName';
+export * from './sql-objects/OrderColumn';
+export * from './sql-objects/GroupColumn';
+export * from './sql-objects/BaseField';
+export * from './sql-objects/Operator';
+export * from './sql-objects/CaseStatement';
+export * from './sql-objects/JoinStatement';
+export * from './sql-objects/RawStatement';
+export * from './sql-objects/CountStatement';
+export * from './sql-objects/operators/LogicalOperator';
+export * from './sql-objects/operators/OpAnd';
+export * from './sql-objects/operators/OpNotExists';
+export * from './sql-objects/operators/OpExists';
+export * from './sql-objects/operators/OpNotILike';
+export * from './sql-objects/operators/OpNotLike';
+export * from './sql-objects/operators/OpNotIn';
+export * from './sql-objects/operators/OpNotBetween';
+export * from './sql-objects/operators/OpNe';
+export * from './sql-objects/operators/OpILike';
+export * from './sql-objects/operators/OpLike';
+export * from './sql-objects/operators/OpIsNot';
+export * from './sql-objects/operators/OpIs';
+export * from './sql-objects/operators/OpIn';
+export * from './sql-objects/operators/OpBetween';
+export * from './sql-objects/operators/OpLte';
+export * from './sql-objects/operators/OpLt';
+export * from './sql-objects/operators/OpGte';
+export * from './sql-objects/operators/OpGt';
+export * from './sql-objects/operators/OpEq';
+export * from './sql-objects/operators/OpOr';
+export * from './sql-objects/operators/CompOperator';

package/dist/classes.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./query/Query"), exports);
+tslib_1.__exportStar(require("./query/ReturningQuery"), exports);
+tslib_1.__exportStar(require("./query/SelectQuery"), exports);
+tslib_1.__exportStar(require("./query/InsertQuery"), exports);
+tslib_1.__exportStar(require("./query/UpdateQuery"), exports);
+tslib_1.__exportStar(require("./query/DeleteQuery"), exports);
+tslib_1.__exportStar(require("./sql-objects/FieldExpression"), exports);
+tslib_1.__exportStar(require("./sql-objects/TableName"), exports);
+tslib_1.__exportStar(require("./sql-objects/OrderColumn"), exports);
+tslib_1.__exportStar(require("./sql-objects/GroupColumn"), exports);
+tslib_1.__exportStar(require("./sql-objects/BaseField"), exports);
+tslib_1.__exportStar(require("./sql-objects/Operator"), exports);
+tslib_1.__exportStar(require("./sql-objects/CaseStatement"), exports);
+tslib_1.__exportStar(require("./sql-objects/JoinStatement"), exports);
+tslib_1.__exportStar(require("./sql-objects/RawStatement"), exports);
+tslib_1.__exportStar(require("./sql-objects/CountStatement"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/LogicalOperator"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpAnd"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpNotExists"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpExists"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpNotILike"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpNotLike"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpNotIn"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpNotBetween"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpNe"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpILike"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpLike"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpIsNot"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpIs"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpIn"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpBetween"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpLte"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpLt"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpGte"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpGt"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpEq"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/OpOr"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/CompOperator"), exports);

package/dist/enums.d.ts

@@ -0,0 +1,84 @@
+export declare enum JoinType {
+    INNER = "inner",
+    LEFT = "left",
+    LEFT_OUTER = "left outer",
+    RIGHT = "right",
+    RIGHT_OUTER = "right outer",
+    OUTER = "outer",
+    FULL_OUTER = "full outer"
+}
+export declare enum SerializationType {
+    SELECT_QUERY = "select_query",
+    SELECT_QUERY_COLUMNS = "select_query.columns",
+    SELECT_QUERY_FROM = "select_query.from",
+    SELECT_QUERY_JOIN = "select_query.join",
+    SELECT_QUERY_GROUPBY = "select_query.groupby",
+    SELECT_QUERY_ORDERBY = "select_query.orderby",
+    INSERT_QUERY = "insert_query",
+    INSERT_QUERY_COLUMNS = "insert_query.columns",
+    INSERT_QUERY_VALUES = "insert_query.values",
+    UPDATE_QUERY = "update_query",
+    UPDATE_QUERY_VALUES = "update_query.values",
+    DELETE_QUERY = "delete_query",
+    SELECT_COLUMN = "select_column",
+    GROUP_COLUMN = "group_column",
+    ORDER_COLUMN = "order_column",
+    RETURNING_COLUMN = "returning_column",
+    TABLE_NAME = "table_name",
+    JOIN = "join",
+    JOIN_CONDITIONS = "join_conditions",
+    RAW = "raw",
+    CASE_STATEMENT = "case_expression",
+    COUNT_STATEMENT = "count_expression",
+    CONDITIONS_BLOCK = "conditions_block",
+    COMPARISON_EXPRESSION = "comparison_expression",
+    LOGICAL_EXPRESSION = "logical_expression",
+    RETURNING_BLOCK = "returning_block",
+    DATE_VALUE = "date_value",
+    STRING_VALUE = "string_value",
+    BOOLEAN_VALUE = "boolean_value",
+    NUMBER_VALUE = "number_value",
+    EXTERNAL_PARAMETER = "external_parameter",
+    ARRAY = "array"
+}
+export declare enum OperatorType {
+    and = "and",
+    or = "or",
+    eq = "eq",
+    ne = "ne",
+    gt = "gt",
+    gte = "gte",
+    lt = "lt",
+    lte = "lte",
+    between = "between",
+    notBetween = "notBetween",
+    in = "in",
+    notIn = "notIn",
+    like = "like",
+    notLike = "nlike",
+    iLike = "iLike",
+    notILike = "nIlike",
+    is = "is",
+    isNot = "isNot",
+    exists = "exists",
+    notExists = "notExists"
+}
+export declare enum DataType {
+    BOOL = "BOOL",
+    CHAR = "CHAR",
+    VARCHAR = "VARCHAR",
+    SMALLINT = "SMALLINT",
+    INTEGER = "INTEGER",
+    BIGINT = "BIGINT",
+    FLOAT = "FLOAT",
+    DOUBLE = "DOUBLE",
+    NUMBER = "NUMBER",
+    DATE = "DATE",
+    TIMESTAMP = "TIMESTAMP",
+    TIMESTAMPTZ = "TIMESTAMPTZ",
+    TIME = "TIME",
+    BINARY = "BINARY",
+    TEXT = "TEXT",
+    GUID = "GUID",
+    JSON = "JSON"
+}

package/dist/enums.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataType = exports.OperatorType = exports.SerializationType = exports.JoinType = void 0;
+var JoinType;
+(function (JoinType) {
+    JoinType["INNER"] = "inner";
+    JoinType["LEFT"] = "left";
+    JoinType["LEFT_OUTER"] = "left outer";
+    JoinType["RIGHT"] = "right";
+    JoinType["RIGHT_OUTER"] = "right outer";
+    JoinType["OUTER"] = "outer";
+    JoinType["FULL_OUTER"] = "full outer";
+})(JoinType = exports.JoinType || (exports.JoinType = {}));
+var SerializationType;
+(function (SerializationType) {
+    SerializationType["SELECT_QUERY"] = "select_query";
+    SerializationType["SELECT_QUERY_COLUMNS"] = "select_query.columns";
+    SerializationType["SELECT_QUERY_FROM"] = "select_query.from";
+    SerializationType["SELECT_QUERY_JOIN"] = "select_query.join";
+    SerializationType["SELECT_QUERY_GROUPBY"] = "select_query.groupby";
+    SerializationType["SELECT_QUERY_ORDERBY"] = "select_query.orderby";
+    SerializationType["INSERT_QUERY"] = "insert_query";
+    SerializationType["INSERT_QUERY_COLUMNS"] = "insert_query.columns";
+    SerializationType["INSERT_QUERY_VALUES"] = "insert_query.values";
+    SerializationType["UPDATE_QUERY"] = "update_query";
+    SerializationType["UPDATE_QUERY_VALUES"] = "update_query.values";
+    SerializationType["DELETE_QUERY"] = "delete_query";
+    SerializationType["SELECT_COLUMN"] = "select_column";
+    SerializationType["GROUP_COLUMN"] = "group_column";
+    SerializationType["ORDER_COLUMN"] = "order_column";
+    SerializationType["RETURNING_COLUMN"] = "returning_column";
+    SerializationType["TABLE_NAME"] = "table_name";
+    SerializationType["JOIN"] = "join";
+    SerializationType["JOIN_CONDITIONS"] = "join_conditions";
+    SerializationType["RAW"] = "raw";
+    SerializationType["CASE_STATEMENT"] = "case_expression";
+    SerializationType["COUNT_STATEMENT"] = "count_expression";
+    SerializationType["CONDITIONS_BLOCK"] = "conditions_block";
+    SerializationType["COMPARISON_EXPRESSION"] = "comparison_expression";
+    SerializationType["LOGICAL_EXPRESSION"] = "logical_expression";
+    SerializationType["RETURNING_BLOCK"] = "returning_block";
+    SerializationType["DATE_VALUE"] = "date_value";
+    SerializationType["STRING_VALUE"] = "string_value";
+    SerializationType["BOOLEAN_VALUE"] = "boolean_value";
+    SerializationType["NUMBER_VALUE"] = "number_value";
+    SerializationType["EXTERNAL_PARAMETER"] = "external_parameter";
+    SerializationType["ARRAY"] = "array";
+})(SerializationType = exports.SerializationType || (exports.SerializationType = {}));
+var OperatorType;
+(function (OperatorType) {
+    OperatorType["and"] = "and";
+    OperatorType["or"] = "or";
+    OperatorType["eq"] = "eq";
+    OperatorType["ne"] = "ne";
+    OperatorType["gt"] = "gt";
+    OperatorType["gte"] = "gte";
+    OperatorType["lt"] = "lt";
+    OperatorType["lte"] = "lte";
+    OperatorType["between"] = "between";
+    OperatorType["notBetween"] = "notBetween";
+    OperatorType["in"] = "in";
+    OperatorType["notIn"] = "notIn";
+    OperatorType["like"] = "like";
+    OperatorType["notLike"] = "nlike";
+    OperatorType["iLike"] = "iLike";
+    OperatorType["notILike"] = "nIlike";
+    OperatorType["is"] = "is";
+    OperatorType["isNot"] = "isNot";
+    OperatorType["exists"] = "exists";
+    OperatorType["notExists"] = "notExists";
+})(OperatorType = exports.OperatorType || (exports.OperatorType = {}));
+var DataType;
+(function (DataType) {
+    DataType["BOOL"] = "BOOL";
+    DataType["CHAR"] = "CHAR";
+    DataType["VARCHAR"] = "VARCHAR";
+    DataType["SMALLINT"] = "SMALLINT";
+    DataType["INTEGER"] = "INTEGER";
+    DataType["BIGINT"] = "BIGINT";
+    DataType["FLOAT"] = "FLOAT";
+    DataType["DOUBLE"] = "DOUBLE";
+    DataType["NUMBER"] = "NUMBER";
+    DataType["DATE"] = "DATE";
+    DataType["TIMESTAMP"] = "TIMESTAMP";
+    DataType["TIMESTAMPTZ"] = "TIMESTAMPTZ";
+    DataType["TIME"] = "TIME";
+    DataType["BINARY"] = "BINARY";
+    DataType["TEXT"] = "TEXT";
+    DataType["GUID"] = "GUID";
+    DataType["JSON"] = "JSON";
+})(DataType = exports.DataType || (exports.DataType = {}));

package/dist/extensions.d.ts

@@ -0,0 +1,4 @@
+import { SerializerExtension } from './types';
+export declare let serializers: SerializerExtension[];
+export declare function registerSerializer(...extension: SerializerExtension[]): void;
+export declare function unRegisterSerializer(...extension: SerializerExtension[]): void;

package/dist/extensions.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unRegisterSerializer = exports.registerSerializer = exports.serializers = void 0;
+exports.serializers = [];
+function registerSerializer(...extension) {
+    for (const ext of extension) {
+        if (!ext.dialect)
+            throw new TypeError('A SerializerExtension must contain "dialect" property');
+        exports.serializers.push(ext);
+    }
+}
+exports.registerSerializer = registerSerializer;
+function unRegisterSerializer(...extension) {
+    exports.serializers = exports.serializers.filter(x => !extension.includes(x));
+}
+exports.unRegisterSerializer = unRegisterSerializer;

package/dist/helpers.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Prints array with line feeding
+ */
+export declare function printArray(arr: string[], sep?: string, lfLen?: number): string;

package/dist/helpers.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printArray = void 0;
+/**
+ * Prints array with line feeding
+ */
+function printArray(arr, sep, lfLen) {
+    let out = '';
+    let line = '';
+    let k = 0;
+    lfLen = lfLen || 60;
+    sep = sep || ',';
+    for (const s of arr) {
+        /* istanbul ignore next */
+        if (s === undefined)
+            continue;
+        line += (k > 0 ? sep : '');
+        if (line.length > lfLen) {
+            out += (out ? '\n' : '') + line;
+            line = '';
+        }
+        else
+            line += line ? ' ' : '';
+        line += s;
+        k++;
+    }
+    if (line)
+        out += (out ? '\n' : '') + line;
+    return out;
+}
+exports.printArray = printArray;

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export { registerSerializer, unRegisterSerializer } from './extensions';
+export * from './helpers';
+export * from './Serializable';
+export * from './SerializeContext';
+export * from './query/Query';
+export * from './query/SelectQuery';
+export * from './query/InsertQuery';
+export * from './query/UpdateQuery';
+export * from './query/DeleteQuery';
+export * from './sql-objects/Operator';
+export * from './sql-objects/operators/LogicalOperator';
+export * from './sql-objects/operators/CompOperator';
+export * from './sql-objects/JoinStatement';
+export * from './types';
+export * from './enums';
+export * from './sqlobject.initializers';
+export * from './op.initializers';
+export * from './typeguards';
+export { op } from './op.initializers';
+export * as classes from './classes';

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classes = exports.op = exports.unRegisterSerializer = exports.registerSerializer = void 0;
+const tslib_1 = require("tslib");
+var extensions_1 = require("./extensions");
+Object.defineProperty(exports, "registerSerializer", { enumerable: true, get: function () { return extensions_1.registerSerializer; } });
+Object.defineProperty(exports, "unRegisterSerializer", { enumerable: true, get: function () { return extensions_1.unRegisterSerializer; } });
+tslib_1.__exportStar(require("./helpers"), exports);
+tslib_1.__exportStar(require("./Serializable"), exports);
+tslib_1.__exportStar(require("./SerializeContext"), exports);
+tslib_1.__exportStar(require("./query/Query"), exports);
+tslib_1.__exportStar(require("./query/SelectQuery"), exports);
+tslib_1.__exportStar(require("./query/InsertQuery"), exports);
+tslib_1.__exportStar(require("./query/UpdateQuery"), exports);
+tslib_1.__exportStar(require("./query/DeleteQuery"), exports);
+tslib_1.__exportStar(require("./sql-objects/Operator"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/LogicalOperator"), exports);
+tslib_1.__exportStar(require("./sql-objects/operators/CompOperator"), exports);
+tslib_1.__exportStar(require("./sql-objects/JoinStatement"), exports);
+tslib_1.__exportStar(require("./types"), exports);
+tslib_1.__exportStar(require("./enums"), exports);
+tslib_1.__exportStar(require("./sqlobject.initializers"), exports);
+tslib_1.__exportStar(require("./op.initializers"), exports);
+tslib_1.__exportStar(require("./typeguards"), exports);
+var op_initializers_1 = require("./op.initializers");
+Object.defineProperty(exports, "op", { enumerable: true, get: function () { return op_initializers_1.op; } });
+exports.classes = tslib_1.__importStar(require("./classes"));

package/dist/op.initializers.d.ts

@@ -0,0 +1,86 @@
+import { OpAnd } from './sql-objects/operators/OpAnd';
+import { OpOr } from './sql-objects/operators/OpOr';
+import { OpEq } from './sql-objects/operators/OpEq';
+import { OpGt } from './sql-objects/operators/OpGt';
+import { OpGte } from './sql-objects/operators/OpGte';
+import { OpLt } from './sql-objects/operators/OpLt';
+import { OpLte } from './sql-objects/operators/OpLte';
+import { OpIn } from './sql-objects/operators/OpIn';
+import { OpIs } from './sql-objects/operators/OpIs';
+import { OpIsNot } from './sql-objects/operators/OpIsNot';
+import { OpLike } from './sql-objects/operators/OpLike';
+import { OpILike } from './sql-objects/operators/OpILike';
+import { OpNe } from './sql-objects/operators/OpNe';
+import { OpNotIn } from './sql-objects/operators/OpNotIn';
+import { OpNotLike } from './sql-objects/operators/OpNotLike';
+import { OpNotILike } from './sql-objects/operators/OpNotILike';
+import { OpExists } from './sql-objects/operators/OpExists';
+import { OpNotExists } from './sql-objects/operators/OpNotExists';
+import { Operator } from './sql-objects/Operator';
+import { RawStatement } from './sql-objects/RawStatement';
+import { Serializable } from './Serializable';
+import { SelectQuery } from './query/SelectQuery';
+declare function And(...args: (Operator | RawStatement)[]): OpAnd;
+declare function Or(...args: (Operator | RawStatement)[]): OpOr;
+declare function Eq(expression: string | Serializable, value: any): OpEq;
+declare function Ne(expression: string | Serializable, value: any): OpNe;
+declare function Gt(expression: string | Serializable, value: any): OpGt;
+declare function Gte(expression: string | Serializable, value: any): OpGte;
+declare function Lt(expression: string | Serializable, value: any): OpLt;
+declare function Lte(expression: string | Serializable, value: any): OpLte;
+declare function Between(expression: string | Serializable, values: any[]): any;
+declare function Between(expression: string | Serializable, value1: any, value2: any): any;
+declare function NotBetween(expression: string | Serializable, values: any[]): any;
+declare function NotBetween(expression: string | Serializable, value1: any, value2: any): any;
+declare function In(expression: string | Serializable, value: any): OpIn;
+declare function NotIn(expression: string | Serializable, value: any): OpNotIn;
+declare function Like(expression: string | Serializable, value: any): OpLike;
+declare function NotLike(expression: string | Serializable, value: any): OpNotLike;
+declare function Ilike(expression: string | Serializable, value: any): OpILike;
+declare function NotILike(expression: string | Serializable, value: any): OpNotILike;
+declare function Is(expression: string | Serializable, value: any): OpIs;
+declare function IsNot(expression: string | Serializable, value: any): OpIsNot;
+declare function Exists(expression: SelectQuery): OpExists;
+declare function NotExists(expression: SelectQuery): OpNotExists;
+declare const op: {
+    and: typeof And;
+    or: typeof Or;
+    eq: typeof Eq;
+    '=': typeof Eq;
+    ne: typeof Ne;
+    '!=': typeof Ne;
+    gt: typeof Gt;
+    '>': typeof Gt;
+    gte: typeof Gte;
+    '>=': typeof Gte;
+    lt: typeof Lt;
+    '<': typeof Lt;
+    lte: typeof Lte;
+    '<=': typeof Lte;
+    between: typeof Between;
+    btw: typeof Between;
+    notBetween: typeof NotBetween;
+    nbtw: typeof NotBetween;
+    '!between': typeof NotBetween;
+    '!btw': typeof NotBetween;
+    in: typeof In;
+    notIn: typeof NotIn;
+    nin: typeof NotIn;
+    '!in': typeof NotIn;
+    like: typeof Like;
+    notLike: typeof NotLike;
+    nlike: typeof NotLike;
+    '!like': typeof NotLike;
+    ilike: typeof Ilike;
+    notILike: typeof NotILike;
+    nilike: typeof NotILike;
+    '!ilike': typeof NotILike;
+    is: typeof Is;
+    isNot: typeof IsNot;
+    '!is': typeof IsNot;
+    exists: typeof Exists;
+    notExists: typeof NotExists;
+    '!exists': typeof NotExists;
+};
+export { op };
+export { And, Or, Eq, Eq as Equal, Ne, Ne as NotEqual, Gt, Gt as GreaterThan, Gte, Gte as GreaterAnEqualTo, Lt, Lt as LowerThan, Lte, Lte as LowerAndEqualTo, Between, NotBetween, In, NotIn, NotIn as Nin, Like, NotLike, NotLike as NLike, Ilike, NotILike, NotILike as Nilike, Is, IsNot, Exists, NotExists };