@sqb/builder 4.26.0 → 5.0.0

package/{query/union-query.js → sql/union.js}

@@ -1,13 +1,8 @@
 import { SerializationType } from '../enums.js';
 import { Query } from './query.js';
-export class UnionQuery extends Query {
+class UnionClass extends Query {
     _queries;
     _unionType;
-    constructor(queries, unionType) {
-        super();
-        this._queries = queries;
-        this._unionType = unionType;
-    }
     get _type() {
         return SerializationType.UNION_QUERY;
     }
@@ -26,3 +21,12 @@ export class UnionQuery extends Query {
         return o.queries.join(o.unionType === 'all' ? '\nUNION ALL\n' : '\nUNION\n');
     }
 }
+export const Union = function (queries, unionType) {
+    if (!(this instanceof Union))
+        return new Union(queries, unionType);
+    Query.call(this);
+    this._queries = queries;
+    this._unionType = unionType;
+};
+Union.prototype = UnionClass.prototype;
+Union.prototype.constructor = Union;

package/sql/update.d.ts

@@ -0,0 +1,38 @@
+import { SerializationType } from '../enums.js';
+import { SerializeContext } from '../serialize-context.js';
+import { Raw } from './elements/raw.js';
+import { TableName } from './elements/table-name.js';
+import { LogicalOperator } from './operators/logical-operator.js';
+import { ReturningQuery } from './returning-query.js';
+import type { Select } from './select.js';
+declare class UpdateClass extends ReturningQuery {
+    _table: TableName | Raw;
+    _input: any;
+    _where?: LogicalOperator;
+    get _type(): SerializationType;
+    /**
+     * Defines "where" part of query
+     */
+    where(...operator: any[]): this;
+    /**
+     * Performs serialization
+     */
+    _serialize(ctx: SerializeContext): string;
+    /**
+     *
+     */
+    protected __serializeValues(ctx: SerializeContext): string;
+    /**
+     *
+     */
+    protected __serializeWhere(ctx: SerializeContext): string;
+}
+interface UpdateCtor {
+    new (tableName: string | TableName | Raw, input: Record<string, any> | Select | Raw): Update;
+    (tableName: string | TableName | Raw, input: Record<string, any> | Select | Raw): Update;
+    prototype: Update;
+}
+export declare const Update: UpdateCtor;
+export interface Update extends UpdateClass {
+}
+export {};

package/{query/update-query.js → sql/update.js}

@@ -1,33 +1,15 @@
 import { SerializationType } from '../enums.js';
 import { printArray } from '../helpers.js';
-import { OpAnd } from '../sql-objects/operators/op-and.js';
-import { TableName } from '../sql-objects/table-name.js';
-import { isRawStatement } from '../typeguards.js';
+import { Serializable } from '../serializable.js';
+import { isRaw } from '../type-guards.js';
+import { TableName } from './elements/table-name.js';
+import { And } from './operators/and.js';
+import { Query } from './query.js';
 import { ReturningQuery } from './returning-query.js';
-export class UpdateQuery extends ReturningQuery {
+class UpdateClass extends ReturningQuery {
     _table;
     _input;
     _where;
-    constructor(tableName, input) {
-        super();
-        if (!(tableName &&
-            (tableName instanceof TableName ||
-                typeof tableName === 'string' ||
-                isRawStatement(tableName)))) {
-            throw new TypeError('String or Raw instance required as first argument (tableName) for UpdateQuery');
-        }
-        if (!input ||
-            !((typeof input === 'object' && !Array.isArray(input)) || input.isSelect)) {
-            throw new TypeError('Object or Raw instance required as second argument (input) for UpdateQuery');
-        }
-        this._table =
-            tableName instanceof TableName
-                ? tableName
-                : typeof tableName === 'string'
-                    ? new TableName(tableName)
-                    : tableName;
-        this._input = input;
-    }
     get _type() {
         return SerializationType.UPDATE_QUERY;
     }
@@ -35,7 +17,7 @@ export class UpdateQuery extends ReturningQuery {
      * Defines "where" part of query
      */
     where(...operator) {
-        this._where = this._where || new OpAnd();
+        this._where = this._where || new And();
         this._where.add(...operator);
         return this;
     }
@@ -86,3 +68,30 @@ export class UpdateQuery extends ReturningQuery {
         s ? 'where ' + s : '');
     }
 }
+export const Update = function (tableName, input) {
+    if (!(this instanceof Update))
+        return new Update(tableName, input);
+    Query.call(this);
+    if (!(tableName &&
+        (tableName instanceof TableName ||
+            typeof tableName === 'string' ||
+            isRaw(tableName)))) {
+        throw new TypeError('String or Raw instance required as first argument (tableName) for Update');
+    }
+    if (!input ||
+        !((typeof input === 'object' && !Array.isArray(input)) ||
+            (input instanceof Serializable &&
+                (input._type === SerializationType.SELECT_QUERY ||
+                    input._type === SerializationType.RAW)))) {
+        throw new TypeError('Object or Raw instance required as second argument (input) for Update');
+    }
+    this._table =
+        tableName instanceof TableName
+            ? tableName
+            : typeof tableName === 'string'
+                ? new TableName(tableName)
+                : tableName;
+    this._input = input;
+};
+Update.prototype = UpdateClass.prototype;
+Update.prototype.constructor = Update;

package/type-guards.d.ts

@@ -0,0 +1,21 @@
+import type { Serializable } from './serializable.js';
+import type { Case, CompOperator, Count, Delete, Field, GroupColumn, Insert, Join, LogicalOperator, OrderColumn, Param, Query, Raw, ReturningColumn, Select, TableName, Update } from './sql/index.js';
+export declare function isSerializable(value: any): value is Serializable;
+export declare function isQuery(value: any): value is Query;
+export declare function isRaw(value: any): value is Raw;
+export declare function isSelect(value: any): value is Select;
+export declare function isInsert(value: any): value is Insert;
+export declare function isIUpdate(value: any): value is Update;
+export declare function isDelete(value: any): value is Delete;
+export declare function isJoin(value: any): value is Join;
+export declare function isCase(value: any): value is Case;
+export declare function isCount(value: any): value is Count;
+export declare function isParam(value: any): value is Param;
+export declare function isLogicalOperator(value: any): value is LogicalOperator;
+export declare function isCompOperator(value: any): value is CompOperator;
+export declare function isNot(value: any): value is CompOperator;
+export declare function isSelectColumn(value: any): value is Field;
+export declare function isOrderColumn(value: any): value is OrderColumn;
+export declare function isGroupColumn(value: any): value is GroupColumn;
+export declare function isReturningColumn(value: any): value is ReturningColumn;
+export declare function isTableName(value: any): value is TableName;

package/{typeguards.js → type-guards.js}

@@ -7,31 +7,31 @@ export function isQuery(value) {
         typeof value.generate === 'function' &&
         typeof value.values === 'function');
 }
-export function isRawStatement(value) {
+export function isRaw(value) {
     return isSerializable(value) && value._type === SerializationType.RAW;
 }
-export function isSelectQuery(value) {
+export function isSelect(value) {
     return (isSerializable(value) && value._type === SerializationType.SELECT_QUERY);
 }
-export function isInsertQuery(value) {
+export function isInsert(value) {
     return (isSerializable(value) && value._type === SerializationType.INSERT_QUERY);
 }
-export function isIUpdateQuery(value) {
+export function isIUpdate(value) {
     return (isSerializable(value) && value._type === SerializationType.UPDATE_QUERY);
 }
-export function isDeleteQuery(value) {
+export function isDelete(value) {
     return (isSerializable(value) && value._type === SerializationType.DELETE_QUERY);
 }
-export function isJoinStatement(value) {
+export function isJoin(value) {
     return isSerializable(value) && value._type === SerializationType.JOIN;
 }
-export function isCaseStatement(value) {
+export function isCase(value) {
     return (isSerializable(value) && value._type === SerializationType.CASE_STATEMENT);
 }
-export function isCountStatement(value) {
+export function isCount(value) {
     return (isSerializable(value) && value._type === SerializationType.COUNT_STATEMENT);
 }
-export function isParamExpression(value) {
+export function isParam(value) {
     return (isSerializable(value) &&
         value._type === SerializationType.EXTERNAL_PARAMETER);
 }
@@ -43,7 +43,7 @@ export function isCompOperator(value) {
     return (isSerializable(value) &&
         value._type === SerializationType.COMPARISON_EXPRESSION);
 }
-export function isNotOperator(value) {
+export function isNot(value) {
     return (isSerializable(value) &&
         value._type === SerializationType.NEGATIVE_EXPRESSION);
 }

package/classes.ns.d.ts

@@ -1,38 +0,0 @@
-export * from './query/delete-query.js';
-export * from './query/insert-query.js';
-export * from './query/query.js';
-export * from './query/returning-query.js';
-export * from './query/select-query.js';
-export * from './query/update-query.js';
-export * from './sql-objects/base-field.js';
-export * from './sql-objects/case-statement.js';
-export * from './sql-objects/count-statement.js';
-export * from './sql-objects/field-expression.js';
-export * from './sql-objects/group-column.js';
-export * from './sql-objects/join-statement.js';
-export * from './sql-objects/operator.js';
-export * from './sql-objects/operators/comp-operator.js';
-export * from './sql-objects/operators/logical-operator.js';
-export * from './sql-objects/operators/op-and.js';
-export * from './sql-objects/operators/op-between.js';
-export * from './sql-objects/operators/op-eq.js';
-export * from './sql-objects/operators/op-exists.js';
-export * from './sql-objects/operators/op-gt.js';
-export * from './sql-objects/operators/op-gte.js';
-export * from './sql-objects/operators/op-ilike.js';
-export * from './sql-objects/operators/op-in.js';
-export * from './sql-objects/operators/op-is.js';
-export * from './sql-objects/operators/op-is-not.js';
-export * from './sql-objects/operators/op-like.js';
-export * from './sql-objects/operators/op-lt.js';
-export * from './sql-objects/operators/op-lte.js';
-export * from './sql-objects/operators/op-ne.js';
-export * from './sql-objects/operators/op-not-between.js';
-export * from './sql-objects/operators/op-not-exists.js';
-export * from './sql-objects/operators/op-not-ilike.js';
-export * from './sql-objects/operators/op-not-in.js';
-export * from './sql-objects/operators/op-not-like.js';
-export * from './sql-objects/operators/op-or.js';
-export * from './sql-objects/order-column.js';
-export * from './sql-objects/raw-statement.js';
-export * from './sql-objects/table-name.js';

package/classes.ns.js

@@ -1,38 +0,0 @@
-export * from './query/delete-query.js';
-export * from './query/insert-query.js';
-export * from './query/query.js';
-export * from './query/returning-query.js';
-export * from './query/select-query.js';
-export * from './query/update-query.js';
-export * from './sql-objects/base-field.js';
-export * from './sql-objects/case-statement.js';
-export * from './sql-objects/count-statement.js';
-export * from './sql-objects/field-expression.js';
-export * from './sql-objects/group-column.js';
-export * from './sql-objects/join-statement.js';
-export * from './sql-objects/operator.js';
-export * from './sql-objects/operators/comp-operator.js';
-export * from './sql-objects/operators/logical-operator.js';
-export * from './sql-objects/operators/op-and.js';
-export * from './sql-objects/operators/op-between.js';
-export * from './sql-objects/operators/op-eq.js';
-export * from './sql-objects/operators/op-exists.js';
-export * from './sql-objects/operators/op-gt.js';
-export * from './sql-objects/operators/op-gte.js';
-export * from './sql-objects/operators/op-ilike.js';
-export * from './sql-objects/operators/op-in.js';
-export * from './sql-objects/operators/op-is.js';
-export * from './sql-objects/operators/op-is-not.js';
-export * from './sql-objects/operators/op-like.js';
-export * from './sql-objects/operators/op-lt.js';
-export * from './sql-objects/operators/op-lte.js';
-export * from './sql-objects/operators/op-ne.js';
-export * from './sql-objects/operators/op-not-between.js';
-export * from './sql-objects/operators/op-not-exists.js';
-export * from './sql-objects/operators/op-not-ilike.js';
-export * from './sql-objects/operators/op-not-in.js';
-export * from './sql-objects/operators/op-not-like.js';
-export * from './sql-objects/operators/op-or.js';
-export * from './sql-objects/order-column.js';
-export * from './sql-objects/raw-statement.js';
-export * from './sql-objects/table-name.js';

package/op.initializers.d.ts

@@ -1,89 +0,0 @@
-import { SelectQuery } from './query/select-query.js';
-import { Serializable } from './serializable.js';
-import { Operator } from './sql-objects/operator.js';
-import { OpAnd } from './sql-objects/operators/op-and.js';
-import { OpEq } from './sql-objects/operators/op-eq.js';
-import { OpExists } from './sql-objects/operators/op-exists.js';
-import { OpGt } from './sql-objects/operators/op-gt.js';
-import { OpGte } from './sql-objects/operators/op-gte.js';
-import { OpILike } from './sql-objects/operators/op-ilike.js';
-import { OpIn } from './sql-objects/operators/op-in.js';
-import { OpIs } from './sql-objects/operators/op-is.js';
-import { OpIsNot } from './sql-objects/operators/op-is-not.js';
-import { OpLike } from './sql-objects/operators/op-like.js';
-import { OpLt } from './sql-objects/operators/op-lt.js';
-import { OpLte } from './sql-objects/operators/op-lte.js';
-import { OpNe } from './sql-objects/operators/op-ne.js';
-import { OpNot } from './sql-objects/operators/op-not.js';
-import { OpNotExists } from './sql-objects/operators/op-not-exists.js';
-import { OpNotILike } from './sql-objects/operators/op-not-ilike.js';
-import { OpNotIn } from './sql-objects/operators/op-not-in.js';
-import { OpNotLike } from './sql-objects/operators/op-not-like.js';
-import { OpOr } from './sql-objects/operators/op-or.js';
-import { RawStatement } from './sql-objects/raw-statement.js';
-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 function Not(expression: Serializable): OpNot;
-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;
-    not: typeof Not;
-    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, Between, Eq, Eq as Equal, Exists, Gte as GreaterAnEqualTo, Gt as GreaterThan, Gt, Gte, Ilike, In, Is, IsNot, Like, Lte as LowerAndEqualTo, Lt as LowerThan, Lt, Lte, Ne, NotILike as Nilike, NotIn as Nin, NotLike as NLike, Not, NotBetween, Ne as NotEqual, NotExists, NotILike, NotIn, NotLike, Or, };

package/op.initializers.js

@@ -1,131 +0,0 @@
-import { WrapOps } from './sql-objects/operators/logical-operator.js';
-import { OpAnd } from './sql-objects/operators/op-and.js';
-import { OpBetween } from './sql-objects/operators/op-between.js';
-import { OpEq } from './sql-objects/operators/op-eq.js';
-import { OpExists } from './sql-objects/operators/op-exists.js';
-import { OpGt } from './sql-objects/operators/op-gt.js';
-import { OpGte } from './sql-objects/operators/op-gte.js';
-import { OpILike } from './sql-objects/operators/op-ilike.js';
-import { OpIn } from './sql-objects/operators/op-in.js';
-import { OpIs } from './sql-objects/operators/op-is.js';
-import { OpIsNot } from './sql-objects/operators/op-is-not.js';
-import { OpLike } from './sql-objects/operators/op-like.js';
-import { OpLt } from './sql-objects/operators/op-lt.js';
-import { OpLte } from './sql-objects/operators/op-lte.js';
-import { OpNe } from './sql-objects/operators/op-ne.js';
-import { OpNot } from './sql-objects/operators/op-not.js';
-import { OpNotBetween } from './sql-objects/operators/op-not-between.js';
-import { OpNotExists } from './sql-objects/operators/op-not-exists.js';
-import { OpNotILike } from './sql-objects/operators/op-not-ilike.js';
-import { OpNotIn } from './sql-objects/operators/op-not-in.js';
-import { OpNotLike } from './sql-objects/operators/op-not-like.js';
-import { OpOr } from './sql-objects/operators/op-or.js';
-function And(...args) {
-    return new OpAnd(...args);
-}
-function Or(...args) {
-    return new OpOr(...args);
-}
-function Eq(expression, value) {
-    return new OpEq(expression, value);
-}
-function Ne(expression, value) {
-    return new OpNe(expression, value);
-}
-function Gt(expression, value) {
-    return new OpGt(expression, value);
-}
-function Gte(expression, value) {
-    return new OpGte(expression, value);
-}
-function Lt(expression, value) {
-    return new OpLt(expression, value);
-}
-function Lte(expression, value) {
-    return new OpLte(expression, value);
-}
-function Between(expression, value1, value2) {
-    const values = Array.isArray(value1) ? value1 : [value1, value2];
-    return new OpBetween(expression, values);
-}
-function NotBetween(expression, value1, value2) {
-    const values = Array.isArray(value1) ? value1 : [value1, value2];
-    return new OpNotBetween(expression, values);
-}
-function In(expression, value) {
-    return new OpIn(expression, value);
-}
-function NotIn(expression, value) {
-    return new OpNotIn(expression, value);
-}
-function Like(expression, value) {
-    return new OpLike(expression, value);
-}
-function NotLike(expression, value) {
-    return new OpNotLike(expression, value);
-}
-function Ilike(expression, value) {
-    return new OpILike(expression, value);
-}
-function NotILike(expression, value) {
-    return new OpNotILike(expression, value);
-}
-function Is(expression, value) {
-    return new OpIs(expression, value);
-}
-function IsNot(expression, value) {
-    return new OpIsNot(expression, value);
-}
-function Exists(expression) {
-    return new OpExists(expression);
-}
-function NotExists(expression) {
-    return new OpNotExists(expression);
-}
-function Not(expression) {
-    return new OpNot(expression);
-}
-const op = {
-    and: And,
-    or: Or,
-    eq: Eq,
-    '=': Eq,
-    ne: Ne,
-    '!=': Ne,
-    gt: Gt,
-    '>': Gt,
-    gte: Gte,
-    '>=': Gte,
-    lt: Lt,
-    '<': Lt,
-    lte: Lte,
-    '<=': Lte,
-    between: Between,
-    btw: Between,
-    notBetween: NotBetween,
-    nbtw: NotBetween,
-    '!between': NotBetween,
-    '!btw': NotBetween,
-    in: In,
-    notIn: NotIn,
-    nin: NotIn,
-    '!in': NotIn,
-    like: Like,
-    not: Not,
-    notLike: NotLike,
-    nlike: NotLike,
-    '!like': NotLike,
-    ilike: Ilike,
-    notILike: NotILike,
-    nilike: NotILike,
-    '!ilike': NotILike,
-    is: Is,
-    isNot: IsNot,
-    '!is': IsNot,
-    exists: Exists,
-    notExists: NotExists,
-    '!exists': NotExists,
-};
-Object.assign(WrapOps, op);
-export { op };
-export { And, Between, Eq, Eq as Equal, Exists, Gte as GreaterAnEqualTo, Gt as GreaterThan, Gt, Gte, Ilike, In, Is, IsNot, Like, Lte as LowerAndEqualTo, Lt as LowerThan, Lt, Lte, Ne, NotILike as Nilike, NotIn as Nin, NotLike as NLike, Not, NotBetween, Ne as NotEqual, NotExists, NotILike, NotIn, NotLike, Or, };

package/query/insert-query.d.ts

@@ -1,23 +0,0 @@
-import { SerializationType } from '../enums.js';
-import { SerializeContext } from '../serialize-context.js';
-import type { RawStatement } from '../sql-objects/raw-statement.js';
-import { TableName } from '../sql-objects/table-name.js';
-import { ReturningQuery } from './returning-query.js';
-export declare class InsertQuery extends ReturningQuery {
-    _table: TableName | RawStatement;
-    _input: any;
-    constructor(tableName: string | RawStatement, input: any);
-    get _type(): SerializationType;
-    /**
-     * Performs serialization
-     */
-    _serialize(ctx: SerializeContext): string;
-    /**
-     *
-     */
-    protected __serializeColumns(ctx: SerializeContext): string;
-    /**
-     *
-     */
-    protected __serializeValues(ctx: SerializeContext): string;
-}

package/query/query.d.ts

@@ -1,25 +0,0 @@
-import { EventEmitter } from 'events';
-import { Serializable } from '../serializable.js';
-import { GenerateOptions, GenerateResult } from '../types.js';
-export declare interface Query extends EventEmitter {
-}
-export interface QueryCommentArgs {
-    comment: string;
-    dialect?: string[];
-}
-export interface QueryIndexHintArgs {
-    index: string[];
-    dialect?: string[];
-}
-export declare abstract class Query extends Serializable {
-    protected _comment: QueryCommentArgs[];
-    protected _params?: Record<string, any>;
-    constructor();
-    /**
-     * Generates Sql script
-     */
-    generate(options?: GenerateOptions): GenerateResult;
-    values(obj: any): this;
-    comment(args: QueryCommentArgs): this;
-    comment(text: string, dialect?: string[]): this;
-}

package/query/returning-query.d.ts

@@ -1,14 +0,0 @@
-import { SerializeContext } from '../serialize-context.js';
-import { ReturningColumn } from '../sql-objects/returning-column.js';
-import { Query } from './query.js';
-export declare abstract class ReturningQuery extends Query {
-    _returningColumns?: ReturningColumn[];
-    /**
-     *
-     */
-    returning(...columns: string[]): this;
-    /**
-     *
-     */
-    protected __serializeReturning(ctx: SerializeContext): string;
-}

package/query/update-query.d.ts

@@ -1,29 +0,0 @@
-import { SerializationType } from '../enums.js';
-import { SerializeContext } from '../serialize-context.js';
-import { LogicalOperator } from '../sql-objects/operators/logical-operator.js';
-import { RawStatement } from '../sql-objects/raw-statement.js';
-import { TableName } from '../sql-objects/table-name.js';
-import { ReturningQuery } from './returning-query.js';
-export declare class UpdateQuery extends ReturningQuery {
-    _table: TableName | RawStatement;
-    _input: any;
-    _where?: LogicalOperator;
-    constructor(tableName: string | TableName | RawStatement, input: any);
-    get _type(): SerializationType;
-    /**
-     * Defines "where" part of query
-     */
-    where(...operator: any[]): this;
-    /**
-     * Performs serialization
-     */
-    _serialize(ctx: SerializeContext): string;
-    /**
-     *
-     */
-    protected __serializeValues(ctx: SerializeContext): string;
-    /**
-     *
-     */
-    protected __serializeWhere(ctx: SerializeContext): string;
-}

package/sql-objects/base-field.d.ts

@@ -1,7 +0,0 @@
-import { Expression } from './expression.js';
-export declare abstract class BaseField extends Expression {
-    _field: string;
-    _schema?: string;
-    _table?: string;
-    _descending?: boolean;
-}

package/sql-objects/base-field.js

@@ -1,7 +0,0 @@
-import { Expression } from './expression.js';
-export class BaseField extends Expression {
-    _field = '';
-    _schema;
-    _table;
-    _descending;
-}

package/sql-objects/coalesce-statement.d.ts

@@ -1,22 +0,0 @@
-import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
-import { SerializeContext } from '../serialize-context.js';
-export declare class CoalesceStatement extends Serializable {
-    _expressions: any[];
-    _alias?: string;
-    constructor(...expressions: any[]);
-    get _type(): SerializationType;
-    /**
-     * Sets alias to case expression.
-     */
-    as(alias: string): this;
-    /**
-     * Performs serialization
-     *
-     * @param {Object} ctx
-     * @return {string}
-     * @override
-     */
-    _serialize(ctx: SerializeContext): string;
-    protected __defaultSerialize(ctx: SerializeContext, o: any): string;
-}