kysely 0.2.4 → 0.2.5

package/lib/operation-node/table-node.d.ts

@@ -5,6 +5,9 @@ export interface TableNode extends OperationNode {
     readonly schema?: IdentifierNode;
     readonly table: IdentifierNode;
 }
+/**
+ * @internal
+ */
 export declare const tableNode: Readonly<{
     is(node: OperationNode): node is TableNode;
     create(table: string): TableNode;

package/lib/operation-node/table-node.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.tableNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const identifier_node_1 = require("./identifier-node");
+/**
+ * @internal
+ */
 exports.tableNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'TableNode';

package/lib/operation-node/unique-constraint-node.d.ts

@@ -6,6 +6,9 @@ export interface UniqueConstraintNode extends OperationNode {
     readonly columns: ReadonlyArray<ColumnNode>;
     readonly name?: IdentifierNode;
 }
+/**
+ * @internal
+ */
 export declare const uniqueConstraintNode: Readonly<{
     is(node: OperationNode): node is UniqueConstraintNode;
     create(columns: string[], constraintName?: string | undefined): UniqueConstraintNode;

package/lib/operation-node/unique-constraint-node.js

@@ -4,6 +4,9 @@ exports.uniqueConstraintNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const column_node_1 = require("./column-node");
 const identifier_node_1 = require("./identifier-node");
+/**
+ * @internal
+ */
 exports.uniqueConstraintNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'UniqueConstraintNode';

package/lib/operation-node/update-query-node.d.ts

@@ -17,6 +17,9 @@ export interface UpdateQueryNode extends OperationNode {
     readonly returning?: ReturningNode;
     readonly with?: WithNode;
 }
+/**
+ * @internal
+ */
 export declare const updateQueryNode: Readonly<{
     is(node: OperationNode): node is UpdateQueryNode;
     create(table: TableExpressionNode, withNode?: WithNode | undefined): UpdateQueryNode;

package/lib/operation-node/update-query-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateQueryNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.updateQueryNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'UpdateQueryNode';

package/lib/operation-node/value-list-node.d.ts

@@ -8,6 +8,9 @@ export interface ValueListNode extends OperationNode {
     readonly kind: 'ValueListNode';
     readonly values: ReadonlyArray<ListNodeItem>;
 }
+/**
+ * @internal
+ */
 export declare const valueListNode: Readonly<{
     is(node: OperationNode): node is ValueListNode;
     create(values: ReadonlyArray<ListNodeItem>): ValueListNode;

package/lib/operation-node/value-list-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.valueListNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.valueListNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'ValueListNode';

package/lib/operation-node/value-node.d.ts

@@ -5,6 +5,9 @@ export interface ValueNode extends OperationNode {
     readonly value: PrimitiveValue;
     readonly immediate?: boolean;
 }
+/**
+ * @internal
+ */
 export declare const valueNode: Readonly<{
     is(node: OperationNode): node is ValueNode;
     create(value: PrimitiveValue): ValueNode;

package/lib/operation-node/value-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.valueNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.valueNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'ValueNode';

package/lib/operation-node/where-node.d.ts

@@ -8,6 +8,9 @@ export interface WhereNode extends OperationNode {
     readonly kind: 'WhereNode';
     readonly where: WhereChildNode;
 }
+/**
+ * @internal
+ */
 export declare const whereNode: Readonly<{
     is(node: OperationNode): node is WhereNode;
     create(filter: WhereChildNode): WhereNode;

package/lib/operation-node/where-node.js

@@ -4,6 +4,9 @@ exports.whereNode = void 0;
 const object_utils_1 = require("../util/object-utils");
 const and_node_1 = require("./and-node");
 const or_node_1 = require("./or-node");
+/**
+ * @internal
+ */
 exports.whereNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'WhereNode';

package/lib/operation-node/with-node.d.ts

@@ -4,6 +4,9 @@ export interface WithNode extends OperationNode {
     readonly kind: 'WithNode';
     readonly expressions: ReadonlyArray<CommonTableExpressionNode>;
 }
+/**
+ * @internal
+ */
 export declare const withNode: Readonly<{
     is(node: OperationNode): node is WithNode;
     create(expression: CommonTableExpressionNode): WithNode;

package/lib/operation-node/with-node.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withNode = void 0;
 const object_utils_1 = require("../util/object-utils");
+/**
+ * @internal
+ */
 exports.withNode = object_utils_1.freeze({
     is(node) {
         return node.kind === 'WithNode';

package/lib/parser/with-parser.js

@@ -4,7 +4,7 @@ exports.parseCommonTableExpression = void 0;
 const identifier_node_1 = require("../operation-node/identifier-node");
 const common_table_expression_node_1 = require("../operation-node/common-table-expression-node");
 const query_creator_1 = require("../query-creator");
-const query_executor_1 = require("../util/query-executor");
+const query_executor_1 = require("../query-executor/query-executor");
 function parseCommonTableExpression(name, expression) {
     const builder = expression(new query_creator_1.QueryCreator(new query_executor_1.NeverExecutingQueryExecutor()));
     return common_table_expression_node_1.commonTableExpressionNode.create(identifier_node_1.identifierNode.create(name), builder.toOperationNode());

package/lib/query-builder/query-builder.d.ts

@@ -14,7 +14,7 @@ import { AnyColumn, ManyResultRowType, SingleResultRowType } from './type-utils'
 import { OrderByExpression } from '../parser/order-by-parser';
 import { MutationObject } from '../parser/mutation-parser';
 import { Compilable } from '../util/compilable';
-import { QueryExecutor } from '../util/query-executor';
+import { QueryExecutor } from '../query-executor/query-executor';
 /**
  * The main query builder class.
  *
@@ -32,7 +32,7 @@ import { QueryExecutor } from '../util/query-executor';
  */
 export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements OperationNodeSource, Compilable {
     #private;
-    constructor({ queryNode, executor }: QueryBuilderConstructorArgs);
+    constructor(args: QueryBuilderConstructorArgs);
     /**
      * Adds a `where` clause to the query.
      *
@@ -579,7 +579,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * person.id
      * ```
      */
-    select<S extends SelectExpression<DB, TB>>(selections: S[]): QueryBuilderWithSelection<DB, TB, O, S>;
+    select<S extends SelectExpression<DB, TB>>(selections: ReadonlyArray<S>): QueryBuilderWithSelection<DB, TB, O, S>;
     select<S extends SelectExpression<DB, TB>>(selection: S): QueryBuilderWithSelection<DB, TB, O, S>;
     /**
      * Adds `distinct on` selections to the select clause.
@@ -603,7 +603,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * where "pet"."name" = $1
      * ```
      */
-    distinctOn<S extends SelectExpression<DB, TB>>(selections: S[]): QueryBuilder<DB, TB, O>;
+    distinctOn<S extends SelectExpression<DB, TB>>(selections: ReadonlyArray<S>): QueryBuilder<DB, TB, O>;
     distinctOn<S extends SelectExpression<DB, TB>>(selection: S): QueryBuilder<DB, TB, O>;
     /**
      *
@@ -675,7 +675,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * select "person".*, "pet".* from "person", "pet"
      * ```
      */
-    selectAll<T extends TB>(table: T[]): SelectAllQueryBuilder<DB, TB, O, T>;
+    selectAll<T extends TB>(table: ReadonlyArray<T>): SelectAllQueryBuilder<DB, TB, O, T>;
     selectAll<T extends TB>(table: T): SelectAllQueryBuilder<DB, TB, O, T>;
     selectAll<T extends TB>(): SelectAllQueryBuilder<DB, TB, O, T>;
     /**
@@ -944,7 +944,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * ```
      */
     onConflictDoNothing(column: AnyColumn<DB, TB>): QueryBuilder<DB, TB, O>;
-    onConflictDoNothing(columns: AnyColumn<DB, TB>[]): QueryBuilder<DB, TB, O>;
+    onConflictDoNothing(columns: ReadonlyArray<AnyColumn<DB, TB>>): QueryBuilder<DB, TB, O>;
     /**
      * Ignores an insert if the column (or columns) given as the first
      * argument conflicts with the current rows in the database and
@@ -988,7 +988,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * ```
      */
     onConflictUpdate(column: AnyColumn<DB, TB>, updates: MutationObject<DB, TB>): QueryBuilder<DB, TB, O>;
-    onConflictUpdate(columns: AnyColumn<DB, TB>[], updates: MutationObject<DB, TB>): QueryBuilder<DB, TB, O>;
+    onConflictUpdate(columns: ReadonlyArray<AnyColumn<DB, TB>>, updates: MutationObject<DB, TB>): QueryBuilder<DB, TB, O>;
     /**
      * Sets the values to update for an `updateTable` query.
      *
@@ -1127,7 +1127,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      *   .executeTakeFirst()
      * ```
      */
-    returning<S extends SelectExpression<DB, TB>>(selections: S[]): QueryBuilderWithReturning<DB, TB, O, S>;
+    returning<S extends SelectExpression<DB, TB>>(selections: ReadonlyArray<S>): QueryBuilderWithReturning<DB, TB, O, S>;
     returning<S extends SelectExpression<DB, TB>>(selection: S): QueryBuilderWithReturning<DB, TB, O, S>;
     /**
      * Adds a `returning *` to an insert/update/delete query on databases
@@ -1319,7 +1319,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * group by "first_name"
      * ```
      */
-    groupBy(orderBy: ReferenceExpression<DB, TB>[]): QueryBuilder<DB, TB, O>;
+    groupBy(orderBy: ReadonlyArray<ReferenceExpression<DB, TB>>): QueryBuilder<DB, TB, O>;
     groupBy(orderBy: ReferenceExpression<DB, TB>): QueryBuilder<DB, TB, O>;
     /**
      * Adds a limit clause to the query.

package/lib/query-builder/query-builder.js

@@ -18,7 +18,7 @@ const prevent_await_1 = require("../util/prevent-await");
 const limit_node_1 = require("../operation-node/limit-node");
 const offset_node_1 = require("../operation-node/offset-node");
 const object_utils_1 = require("../util/object-utils");
-const query_executor_1 = require("../util/query-executor");
+const query_executor_1 = require("../query-executor/query-executor");
 /**
  * The main query builder class.
  *
@@ -37,9 +37,9 @@ const query_executor_1 = require("../util/query-executor");
 class QueryBuilder {
     #queryNode;
     #executor;
-    constructor({ queryNode, executor }) {
-        this.#queryNode = queryNode;
-        this.#executor = executor;
+    constructor(args) {
+        this.#queryNode = args.queryNode;
+        this.#executor = args.executor;
     }
     where(...args) {
         ensureCanHaveWhereClause(this.#queryNode);
@@ -427,14 +427,14 @@ class QueryBuilder {
         ensureCanHaveOnConflict(this.#queryNode);
         return new QueryBuilder({
             executor: this.#executor,
-            queryNode: insert_query_node_1.insertQueryNode.cloneWithOnConflictDoNothing(this.#queryNode, object_utils_1.asArray(columns).map(reference_parser_1.parseColumnName)),
+            queryNode: insert_query_node_1.insertQueryNode.cloneWithOnConflictDoNothing(this.#queryNode, object_utils_1.asReadonlyArray(columns).map(reference_parser_1.parseColumnName)),
         });
     }
     onConflictUpdate(columns, updates) {
         ensureCanHaveOnConflict(this.#queryNode);
         return new QueryBuilder({
             executor: this.#executor,
-            queryNode: insert_query_node_1.insertQueryNode.cloneWithOnConflictUpdate(this.#queryNode, object_utils_1.asArray(columns).map(reference_parser_1.parseColumnName), update_set_parser_1.parseUpdateObject(updates)),
+            queryNode: insert_query_node_1.insertQueryNode.cloneWithOnConflictUpdate(this.#queryNode, object_utils_1.asReadonlyArray(columns).map(reference_parser_1.parseColumnName), update_set_parser_1.parseUpdateObject(updates)),
         });
     }
     /**

package/lib/query-builder/sub-query-builder.d.ts

@@ -1,4 +1,4 @@
-import { NeverExecutingQueryExecutor } from '../util/query-executor';
+import { NeverExecutingQueryExecutor } from '../query-executor/query-executor';
 import { TableExpression, QueryBuilderWithTable } from '../parser/table-parser';
 export declare class SubQueryBuilder<DB, TB extends keyof DB> {
     #private;

package/lib/query-builder/sub-query-builder.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubQueryBuilder = void 0;
 const query_builder_1 = require("./query-builder");
 const select_query_node_1 = require("../operation-node/select-query-node");
-const query_executor_1 = require("../util/query-executor");
+const query_executor_1 = require("../query-executor/query-executor");
 const table_parser_1 = require("../parser/table-parser");
 const with_schema_transformer_1 = require("../transformers/with-schema-transformer");
 class SubQueryBuilder {

package/lib/query-compiler/default-query-compiler.d.ts

@@ -57,6 +57,7 @@ import { AlterColumnNode } from '../operation-node/alter-column-node';
 import { AddConstraintNode } from '../operation-node/add-constraint-node';
 import { DropConstraintNode } from '../operation-node/drop-constraint-node';
 import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node';
+import { ColumnDefinitionNode } from '../operation-node/column-definition-node';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     compileQuery(node: CompileEntryPointNode): CompiledQuery;
@@ -88,7 +89,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitOperator(node: OperatorNode): void;
     protected visitTable(node: TableNode): void;
     protected visitCreateTable(node: CreateTableNode): void;
-    protected visitAddColumn(node: AddColumnNode): void;
+    protected visitColumnDefinition(node: ColumnDefinitionNode): void;
     protected visitReferences(node: ReferencesNode): void;
     protected visitDropTable(node: DropTableNode): void;
     protected visitDataType(node: DataTypeNode): void;
@@ -113,6 +114,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitWith(node: WithNode): void;
     protected visitCommonTableExpression(node: CommonTableExpressionNode): void;
     protected visitAlterTable(node: AlterTableNode): void;
+    protected visitAddColumn(node: AddColumnNode): void;
     protected visitRenameColumn(node: RenameColumnNode): void;
     protected visitDropColumn(node: DropColumnNode): void;
     protected visitAlterColumn(node: AlterColumnNode): void;

package/lib/query-compiler/default-query-compiler.js

@@ -275,15 +275,10 @@ class DefaultQueryCompiler extends operation_node_visitor_1.OperationNodeVisitor
         }
         this.visitNode(node.table);
         this.append(' (');
-        this.compileList([
-            ...node.columns,
-            ...(node.primaryKeyConstraint ? [node.primaryKeyConstraint] : []),
-            ...(node.uniqueConstraints ?? []),
-            ...(node.checkConstraints ?? []),
-        ]);
+        this.compileList([...node.columns, ...(node.constraints ?? [])]);
         this.append(')');
     }
-    visitAddColumn(node) {
+    visitColumnDefinition(node) {
         this.visitNode(node.column);
         this.append(' ');
         if (node.isAutoIncrementing) {
@@ -325,7 +320,7 @@ class DefaultQueryCompiler extends operation_node_visitor_1.OperationNodeVisitor
         this.append('references ');
         this.visitNode(node.table);
         this.append(' (');
-        this.visitNode(node.column);
+        this.compileList(node.columns);
         this.append(')');
         if (node.onDelete) {
             this.append(' on delete ');
@@ -499,7 +494,9 @@ class DefaultQueryCompiler extends operation_node_visitor_1.OperationNodeVisitor
             this.visitNode(node.name);
             this.append(' ');
         }
-        this.append('foreign key ');
+        this.append('foreign key (');
+        this.compileList(node.columns);
+        this.append(') ');
         this.visitNode(node.references);
     }
     visitList(node) {
@@ -545,6 +542,10 @@ class DefaultQueryCompiler extends operation_node_visitor_1.OperationNodeVisitor
             this.visitNode(node.alterColumn);
         }
     }
+    visitAddColumn(node) {
+        this.append('add column ');
+        this.visitNode(node.column);
+    }
     visitRenameColumn(node) {
         this.append('rename column ');
         this.visitNode(node.column);

package/lib/query-compiler/query-compiler.d.ts

@@ -1,3 +1,4 @@
+import { AlterTableNode } from '../operation-node/alter-table-node';
 import { CreateIndexNode } from '../operation-node/create-index-node';
 import { CreateSchemaNode } from '../operation-node/create-schema-node';
 import { CreateTableNode } from '../operation-node/create-table-node';
@@ -7,7 +8,7 @@ import { DropTableNode } from '../operation-node/drop-table-node';
 import { QueryNode } from '../operation-node/query-node';
 import { RawNode } from '../operation-node/raw-node';
 import { CompiledQuery } from './compiled-query';
-export declare type CompileEntryPointNode = QueryNode | CreateTableNode | CreateIndexNode | DropTableNode | DropIndexNode | CreateSchemaNode | DropSchemaNode | RawNode;
+export declare type CompileEntryPointNode = QueryNode | CreateTableNode | CreateIndexNode | AlterTableNode | DropTableNode | DropIndexNode | CreateSchemaNode | DropSchemaNode | RawNode;
 export interface QueryCompiler {
     compileQuery(node: CompileEntryPointNode): CompiledQuery;
 }

package/lib/query-creator.d.ts

@@ -1,7 +1,7 @@
 import { QueryBuilder } from './query-builder/query-builder';
 import { QueryBuilderWithTable, TableExpression, TableReference } from './parser/table-parser';
 import { InsertResultTypeTag, DeleteResultTypeTag, UpdateResultTypeTag } from './query-builder/type-utils';
-import { QueryExecutor } from './util/query-executor';
+import { QueryExecutor } from './query-executor/query-executor';
 import { RawBuilder } from './raw-builder/raw-builder';
 import { CommonTableExpression, QueryCreatorWithCommonTableExpression } from './parser/with-parser';
 import { WithNode } from './operation-node/with-node';
@@ -238,7 +238,7 @@ export declare class QueryCreator<DB> {
      * ```
      *
      * @example
-     * `withSchema` is smart enough to not add schema for aliases
+     * `withSchema` is smart enough to not add schema for aliases,
      * common table expressions or other places where the schema
      * doesn't belong to:
      *

package/lib/query-creator.js

@@ -163,7 +163,7 @@ class QueryCreator {
      * ```
      *
      * @example
-     * `withSchema` is smart enough to not add schema for aliases
+     * `withSchema` is smart enough to not add schema for aliases,
      * common table expressions or other places where the schema
      * doesn't belong to:
      *

package/lib/{util → query-executor}/query-executor.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NeverExecutingQueryExecutor = exports.DefaultQueryExecutor = exports.QueryExecutor = void 0;
-const object_utils_1 = require("./object-utils");
+const object_utils_1 = require("../util/object-utils");
 class QueryExecutor {
     #transformers;
     constructor(transformers = []) {

package/lib/raw-builder/raw-builder.d.ts

@@ -3,10 +3,10 @@ import { AliasNode } from '../operation-node/alias-node';
 import { OperationNodeSource } from '../operation-node/operation-node-source';
 import { RawNode } from '../operation-node/raw-node';
 import { CompiledQuery } from '../query-compiler/compiled-query';
-import { QueryExecutor } from '../util/query-executor';
+import { QueryExecutor } from '../query-executor/query-executor';
 export declare class RawBuilder<O = unknown> implements OperationNodeSource {
     #private;
-    constructor({ sql, params, executor }: RawBuilderConstructorArgs);
+    constructor(args: RawBuilderConstructorArgs);
     toOperationNode(): RawNode;
     as<A extends string>(alias: A): AliasedRawBuilder<O, A>;
     compile(): CompiledQuery;

package/lib/raw-builder/raw-builder.js

@@ -11,10 +11,10 @@ class RawBuilder {
     #sql;
     #params;
     #executor;
-    constructor({ sql, params, executor }) {
-        this.#sql = sql;
-        this.#params = params;
-        this.#executor = executor;
+    constructor(args) {
+        this.#sql = args.sql;
+        this.#params = args.params;
+        this.#executor = args.executor;
     }
     toOperationNode() {
         const bindingRegex = /(\?\??)/g;

package/lib/schema/alter-table-builder.d.ts

@@ -0,0 +1,64 @@
+import { ColumnDefinitionBuilder, ColumnDefinitionBuilderInterface } from '..';
+import { AlterColumnNode } from '../operation-node/alter-column-node';
+import { AlterTableNode } from '../operation-node/alter-table-node';
+import { ColumnDataType } from '../operation-node/data-type-node';
+import { OperationNodeSource } from '../operation-node/operation-node-source';
+import { OnDelete } from '../operation-node/references-node';
+import { CompiledQuery } from '../query-compiler/compiled-query';
+import { RawBuilder } from '../raw-builder/raw-builder';
+import { Compilable } from '../util/compilable';
+import { PrimitiveValue } from '../util/object-utils';
+import { QueryExecutor } from '../query-executor/query-executor';
+export declare class AlterTableBuilder {
+    #private;
+    constructor(args: AlterTableBuilderConstructorArgs);
+    renameTo(newTableName: string): AlterTableExecutor;
+    setSchema(newSchema: string): AlterTableExecutor;
+    alterColumn(column: string): AlterColumnBuilder;
+    dropColumn(column: string): AlterTableExecutor;
+    renameColumn(column: string, newColumn: string): AlterTableExecutor;
+    addColumn(columnName: string, dataType: ColumnDataType | RawBuilder): AlterTableAddColumnBuilder;
+}
+export declare class AlterColumnBuilder {
+    #private;
+    constructor(args: AlterColumnBuilderConstructorArgs);
+    setDataType(dataType: ColumnDataType): AlterTableExecutor;
+    setDefault(value: PrimitiveValue | RawBuilder<any>): AlterTableExecutor;
+    dropDefault(): AlterTableExecutor;
+    setNotNull(): AlterTableExecutor;
+    dropNotNull(): AlterTableExecutor;
+}
+export declare class AlterTableExecutor implements OperationNodeSource, Compilable {
+    #private;
+    constructor(args: AlterTableExecutorConstructorArgs);
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableAddColumnBuilder> {
+    #private;
+    constructor(args: AlterTableAddColumnBuilderConstructorArgs);
+    increments(): AlterTableAddColumnBuilder;
+    primaryKey(): AlterTableAddColumnBuilder;
+    references(ref: string): AlterTableAddColumnBuilder;
+    onDelete(onDelete: OnDelete): AlterTableAddColumnBuilder;
+    unique(): AlterTableAddColumnBuilder;
+    notNull(): AlterTableAddColumnBuilder;
+    defaultTo(value: PrimitiveValue | RawBuilder<any>): AlterTableAddColumnBuilder;
+    check(sql: string): AlterTableAddColumnBuilder;
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface AlterTableBuilderConstructorArgs {
+    alterTableNode: AlterTableNode;
+    executor: QueryExecutor;
+}
+export interface AlterColumnBuilderConstructorArgs extends AlterTableBuilderConstructorArgs {
+    alterColumnNode: AlterColumnNode;
+}
+export interface AlterTableExecutorConstructorArgs extends AlterTableBuilderConstructorArgs {
+}
+export interface AlterTableAddColumnBuilderConstructorArgs extends AlterTableBuilderConstructorArgs {
+    columnBuilder: ColumnDefinitionBuilder;
+}