kysely 0.28.17 → 0.29.0

package/dist/operation-node/alter-type-node.d.ts

@@ -0,0 +1,24 @@
+import type { OperationNode } from './operation-node.js';
+import type { SchemableIdentifierNode } from './schemable-identifier-node.js';
+import type { IdentifierNode } from './identifier-node.js';
+import type { AddValueNode } from './add-value-node.js';
+import type { RenameValueNode } from './rename-value-node.js';
+export type AlterTypeNodeProps = Omit<AlterTypeNode, 'kind' | 'name'>;
+export interface AlterTypeNode extends OperationNode {
+    readonly kind: 'AlterTypeNode';
+    readonly name: SchemableIdentifierNode;
+    readonly addValue?: AddValueNode;
+    readonly renameTo?: IdentifierNode;
+    readonly renameValue?: RenameValueNode;
+    readonly setSchema?: IdentifierNode;
+}
+type AlterTypeNodeFactory = Readonly<{
+    is(node: OperationNode): node is AlterTypeNode;
+    create(name: SchemableIdentifierNode): Readonly<AlterTypeNode>;
+    cloneWith(node: AlterTypeNode, props: AlterTypeNodeProps): Readonly<AlterTypeNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const AlterTypeNode: AlterTypeNodeFactory;
+export {};

package/dist/operation-node/alter-type-node.js

@@ -0,0 +1,22 @@
+/// <reference types="./alter-type-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const AlterTypeNode = freeze({
+    is(node) {
+        return node.kind === 'AlterTypeNode';
+    },
+    create(name) {
+        return freeze({
+            kind: 'AlterTypeNode',
+            name,
+        });
+    },
+    cloneWith(node, props) {
+        return freeze({
+            ...node,
+            ...props,
+        });
+    },
+});

package/dist/operation-node/create-table-node.d.ts

@@ -0,0 +1,37 @@
+import type { OperationNode } from './operation-node.js';
+import type { TableNode } from './table-node.js';
+import type { ConstraintNode } from './constraint-node.js';
+import type { ColumnDefinitionNode } from './column-definition-node.js';
+import type { ArrayItemType } from '../util/type-utils.js';
+import type { AddIndexNode } from './add-index-node.js';
+export declare const ON_COMMIT_ACTIONS: string[];
+export type OnCommitAction = ArrayItemType<typeof ON_COMMIT_ACTIONS>;
+export type CreateTableNodeParams = Omit<CreateTableNode, 'kind' | 'table' | 'columns' | 'constraints' | 'indexes' | 'frontModifiers' | 'endModifiers'>;
+export interface CreateTableNode extends OperationNode {
+    readonly kind: 'CreateTableNode';
+    readonly table: TableNode;
+    readonly columns: ReadonlyArray<ColumnDefinitionNode>;
+    readonly constraints?: ReadonlyArray<ConstraintNode>;
+    readonly indexes?: ReadonlyArray<AddIndexNode>;
+    readonly temporary?: boolean;
+    readonly ifNotExists?: boolean;
+    readonly onCommit?: OnCommitAction;
+    readonly frontModifiers?: ReadonlyArray<OperationNode>;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
+    readonly selectQuery?: OperationNode;
+}
+type CreateTableNodeFactory = Readonly<{
+    is(node: OperationNode): node is CreateTableNode;
+    create(table: TableNode): Readonly<CreateTableNode>;
+    cloneWithColumn(node: CreateTableNode, column: ColumnDefinitionNode): Readonly<CreateTableNode>;
+    cloneWithConstraint(node: CreateTableNode, constraint: ConstraintNode): Readonly<CreateTableNode>;
+    cloneWithIndex(node: CreateTableNode, index: AddIndexNode): Readonly<CreateTableNode>;
+    cloneWithFrontModifier(node: CreateTableNode, modifier: OperationNode): Readonly<CreateTableNode>;
+    cloneWithEndModifier(node: CreateTableNode, modifier: OperationNode): Readonly<CreateTableNode>;
+    cloneWith(node: CreateTableNode, params: CreateTableNodeParams): Readonly<CreateTableNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const CreateTableNode: CreateTableNodeFactory;
+export {};

package/dist/operation-node/create-table-node.js

@@ -0,0 +1,62 @@
+/// <reference types="./create-table-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+export const ON_COMMIT_ACTIONS = ['preserve rows', 'delete rows', 'drop'];
+/**
+ * @internal
+ */
+export const CreateTableNode = freeze({
+    is(node) {
+        return node.kind === 'CreateTableNode';
+    },
+    create(table) {
+        return freeze({
+            kind: 'CreateTableNode',
+            table,
+            columns: freeze([]),
+        });
+    },
+    cloneWithColumn(node, column) {
+        return freeze({
+            ...node,
+            columns: freeze([...node.columns, column]),
+        });
+    },
+    cloneWithConstraint(node, constraint) {
+        return freeze({
+            ...node,
+            constraints: node.constraints
+                ? freeze([...node.constraints, constraint])
+                : freeze([constraint]),
+        });
+    },
+    cloneWithIndex(node, index) {
+        return freeze({
+            ...node,
+            indexes: node.indexes
+                ? freeze([...node.indexes, index])
+                : freeze([index]),
+        });
+    },
+    cloneWithFrontModifier(node, modifier) {
+        return freeze({
+            ...node,
+            frontModifiers: node.frontModifiers
+                ? freeze([...node.frontModifiers, modifier])
+                : freeze([modifier]),
+        });
+    },
+    cloneWithEndModifier(node, modifier) {
+        return freeze({
+            ...node,
+            endModifiers: node.endModifiers
+                ? freeze([...node.endModifiers, modifier])
+                : freeze([modifier]),
+        });
+    },
+    cloneWith(node, params) {
+        return freeze({
+            ...node,
+            ...params,
+        });
+    },
+});

package/dist/operation-node/data-type-node.d.ts

@@ -0,0 +1,18 @@
+import type { OperationNode } from './operation-node.js';
+export type SimpleColumnDataType = 'varchar' | 'char' | 'text' | 'integer' | 'int2' | 'int4' | 'int8' | 'smallint' | 'bigint' | 'boolean' | 'real' | 'double precision' | 'float4' | 'float8' | 'decimal' | 'numeric' | 'binary' | 'bytea' | 'date' | 'datetime' | 'time' | 'timetz' | 'timestamp' | 'timestamptz' | 'serial' | 'bigserial' | 'uuid' | 'json' | 'jsonb' | 'datetime2' | 'blob' | 'varbinary' | 'int4range' | 'int4multirange' | 'int8range' | 'int8multirange' | 'numrange' | 'nummultirange' | 'tsrange' | 'tsmultirange' | 'tstzrange' | 'tstzmultirange' | 'daterange' | 'datemultirange';
+export type ColumnDataType = SimpleColumnDataType | `varchar(${number})` | `char(${number})` | `decimal(${number}, ${number})` | `numeric(${number}, ${number})` | `binary(${number})` | `datetime(${number})` | `datetime2(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})` | `varbinary(${number})`;
+export type DataTypeParams = Omit<DataTypeNode, 'kind' | 'dataType'>;
+export interface DataTypeNode extends OperationNode {
+    readonly kind: 'DataTypeNode';
+    readonly dataType: ColumnDataType;
+}
+type DataTypeNodeFactory = Readonly<{
+    is(node: OperationNode): node is DataTypeNode;
+    create(dataType: ColumnDataType): Readonly<DataTypeNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const DataTypeNode: DataTypeNodeFactory;
+export declare function isColumnDataType(dataType: string): dataType is ColumnDataType;
+export {};

package/dist/operation-node/data-type-node.js

@@ -0,0 +1,80 @@
+/// <reference types="./data-type-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+const SIMPLE_COLUMN_DATA_TYPES = freeze({
+    bigint: true,
+    bigserial: true,
+    binary: true,
+    blob: true,
+    boolean: true,
+    bytea: true,
+    char: true,
+    date: true,
+    datemultirange: true,
+    daterange: true,
+    datetime: true,
+    datetime2: true,
+    decimal: true,
+    'double precision': true,
+    float4: true,
+    float8: true,
+    int2: true,
+    int4: true,
+    int4multirange: true,
+    int4range: true,
+    int8: true,
+    int8multirange: true,
+    int8range: true,
+    integer: true,
+    json: true,
+    jsonb: true,
+    numeric: true,
+    nummultirange: true,
+    numrange: true,
+    real: true,
+    serial: true,
+    smallint: true,
+    text: true,
+    time: true,
+    timestamp: true,
+    timestamptz: true,
+    timetz: true,
+    tsmultirange: true,
+    tsrange: true,
+    tstzmultirange: true,
+    tstzrange: true,
+    uuid: true,
+    varbinary: true,
+    varchar: true,
+});
+const COLUMN_DATA_TYPE_REGEX = freeze([
+    /^varchar\(\d+\)$/,
+    /^char\(\d+\)$/,
+    /^decimal\(\d+, \d+\)$/,
+    /^numeric\(\d+, \d+\)$/,
+    /^binary\(\d+\)$/,
+    /^datetime\(\d+\)$/,
+    /^time\(\d+\)$/,
+    /^timetz\(\d+\)$/,
+    /^timestamp\(\d+\)$/,
+    /^timestamptz\(\d+\)$/,
+    /^datetime2\(\d+\)$/,
+    /^varbinary\(\d+\)$/,
+]);
+/**
+ * @internal
+ */
+export const DataTypeNode = freeze({
+    is(node) {
+        return node.kind === 'DataTypeNode';
+    },
+    create(dataType) {
+        return freeze({
+            kind: 'DataTypeNode',
+            dataType,
+        });
+    },
+});
+export function isColumnDataType(dataType) {
+    return (SIMPLE_COLUMN_DATA_TYPES[dataType] ||
+        COLUMN_DATA_TYPE_REGEX.some((r) => r.test(dataType)));
+}

package/dist/operation-node/drop-column-node.d.ts

@@ -0,0 +1,18 @@
+import type { OperationNode } from './operation-node.js';
+import { ColumnNode } from './column-node.js';
+export type DropColumnNodeProps = Omit<DropColumnNode, 'kind' | 'column'>;
+export interface DropColumnNode extends OperationNode {
+    readonly kind: 'DropColumnNode';
+    readonly column: ColumnNode;
+    readonly ifExists?: boolean;
+}
+type DropColumnNodeFactory = Readonly<{
+    is(node: OperationNode): node is DropColumnNode;
+    create(column: string): Readonly<DropColumnNode>;
+    cloneWith(node: DropColumnNode, props: DropColumnNodeProps): Readonly<DropColumnNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const DropColumnNode: DropColumnNodeFactory;
+export {};

package/dist/operation-node/drop-column-node.js

@@ -0,0 +1,23 @@
+/// <reference types="./drop-column-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { ColumnNode } from './column-node.js';
+/**
+ * @internal
+ */
+export const DropColumnNode = freeze({
+    is(node) {
+        return node.kind === 'DropColumnNode';
+    },
+    create(column) {
+        return freeze({
+            kind: 'DropColumnNode',
+            column: ColumnNode.create(column),
+        });
+    },
+    cloneWith(node, props) {
+        return freeze({
+            ...node,
+            ...props,
+        });
+    },
+});

package/dist/operation-node/drop-table-node.d.ts

@@ -0,0 +1,24 @@
+import type { OperationNode } from './operation-node.js';
+import type { TableNode } from './table-node.js';
+export type DropTableNodeParams = Omit<Partial<DropTableNode>, 'kind' | 'table'>;
+/**
+ * @deprecated use {@link DropTableNodeParams} instead.
+ */
+export type DropTablexNodeParams = DropTableNodeParams;
+export interface DropTableNode extends OperationNode {
+    readonly kind: 'DropTableNode';
+    readonly table: TableNode;
+    readonly ifExists?: boolean;
+    readonly cascade?: boolean;
+    readonly temporary?: boolean;
+}
+type DropTableNodeFactory = Readonly<{
+    is(node: OperationNode): node is DropTableNode;
+    create(table: TableNode, params?: DropTableNodeParams): Readonly<DropTableNode>;
+    cloneWith(dropIndex: DropTableNode, params: DropTableNodeParams): Readonly<DropTableNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const DropTableNode: DropTableNodeFactory;
+export {};

package/dist/operation-node/drop-type-node.d.ts

@@ -0,0 +1,20 @@
+import type { OperationNode } from './operation-node.js';
+import type { SchemableIdentifierNode } from './schemable-identifier-node.js';
+export type DropTypeNodeParams = Omit<Partial<DropTypeNode>, 'kind' | 'name' | 'additionalNames'>;
+export interface DropTypeNode extends OperationNode {
+    readonly kind: 'DropTypeNode';
+    readonly name: SchemableIdentifierNode;
+    readonly additionalNames?: SchemableIdentifierNode[];
+    readonly ifExists?: boolean;
+    readonly cascade?: boolean;
+}
+type DropTypeNodeFactory = Readonly<{
+    is(node: OperationNode): node is DropTypeNode;
+    create(names: SchemableIdentifierNode | SchemableIdentifierNode[]): Readonly<DropTypeNode>;
+    cloneWith(dropType: DropTypeNode, params: DropTypeNodeParams): Readonly<DropTypeNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const DropTypeNode: DropTypeNodeFactory;
+export {};

package/dist/operation-node/drop-type-node.js

@@ -0,0 +1,26 @@
+/// <reference types="./drop-type-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const DropTypeNode = freeze({
+    is(node) {
+        return node.kind === 'DropTypeNode';
+    },
+    create(names) {
+        if (!Array.isArray(names)) {
+            names = [names];
+        }
+        return freeze({
+            kind: 'DropTypeNode',
+            name: names[0],
+            additionalNames: names.slice(1),
+        });
+    },
+    cloneWith(dropType, params) {
+        return freeze({
+            ...dropType,
+            ...params,
+        });
+    },
+});

package/dist/operation-node/insert-query-node.d.ts

@@ -0,0 +1,40 @@
+import type { ColumnNode } from './column-node.js';
+import type { ExplainNode } from './explain-node.js';
+import type { OnConflictNode } from './on-conflict-node.js';
+import type { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { OrActionNode } from './or-action-node.js';
+import type { OutputNode } from './output-node.js';
+import type { ReturningNode } from './returning-node.js';
+import type { TableNode } from './table-node.js';
+import type { TopNode } from './top-node.js';
+import type { WithNode } from './with-node.js';
+export type InsertQueryNodeProps = Omit<InsertQueryNode, 'kind' | 'into'>;
+export interface InsertQueryNode extends OperationNode {
+    readonly kind: 'InsertQueryNode';
+    readonly into?: TableNode;
+    readonly columns?: ReadonlyArray<ColumnNode>;
+    readonly values?: OperationNode;
+    readonly returning?: ReturningNode;
+    readonly onConflict?: OnConflictNode;
+    readonly onDuplicateKey?: OnDuplicateKeyNode;
+    readonly with?: WithNode;
+    readonly orAction?: OrActionNode;
+    readonly replace?: boolean;
+    readonly explain?: ExplainNode;
+    readonly defaultValues?: boolean;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
+    readonly top?: TopNode;
+    readonly output?: OutputNode;
+}
+type InsertQueryNodeFactory = Readonly<{
+    is(node: OperationNode): node is InsertQueryNode;
+    create(into: TableNode, withNode?: WithNode, replace?: boolean): Readonly<InsertQueryNode>;
+    createWithoutInto(): Readonly<InsertQueryNode>;
+    cloneWith(insertQuery: InsertQueryNode, props: InsertQueryNodeProps): Readonly<InsertQueryNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const InsertQueryNode: InsertQueryNodeFactory;
+export {};

package/dist/operation-node/operation-node-transformer.d.ts

@@ -0,0 +1,244 @@
+import type { AliasNode } from './alias-node.js';
+import type { ColumnNode } from './column-node.js';
+import type { IdentifierNode } from './identifier-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { ReferenceNode } from './reference-node.js';
+import type { SelectAllNode } from './select-all-node.js';
+import type { SelectionNode } from './selection-node.js';
+import type { TableNode } from './table-node.js';
+import type { AndNode } from './and-node.js';
+import type { JoinNode } from './join-node.js';
+import type { OrNode } from './or-node.js';
+import type { ParensNode } from './parens-node.js';
+import type { PrimitiveValueListNode } from './primitive-value-list-node.js';
+import type { RawNode } from './raw-node.js';
+import type { SelectQueryNode } from './select-query-node.js';
+import type { ValueListNode } from './value-list-node.js';
+import type { ValueNode } from './value-node.js';
+import type { OperatorNode } from './operator-node.js';
+import type { FromNode } from './from-node.js';
+import type { WhereNode } from './where-node.js';
+import type { InsertQueryNode } from './insert-query-node.js';
+import type { DeleteQueryNode } from './delete-query-node.js';
+import type { ReturningNode } from './returning-node.js';
+import type { CreateTableNode } from './create-table-node.js';
+import type { AddColumnNode } from './add-column-node.js';
+import type { DropTableNode } from './drop-table-node.js';
+import type { DataTypeNode } from './data-type-node.js';
+import type { OrderByNode } from './order-by-node.js';
+import type { OrderByItemNode } from './order-by-item-node.js';
+import type { GroupByNode } from './group-by-node.js';
+import type { GroupByItemNode } from './group-by-item-node.js';
+import type { UpdateQueryNode } from './update-query-node.js';
+import type { ColumnUpdateNode } from './column-update-node.js';
+import type { LimitNode } from './limit-node.js';
+import type { OffsetNode } from './offset-node.js';
+import type { OnConflictNode } from './on-conflict-node.js';
+import type { CreateIndexNode } from './create-index-node.js';
+import type { ListNode } from './list-node.js';
+import type { DropIndexNode } from './drop-index-node.js';
+import type { PrimaryKeyConstraintNode } from './primary-key-constraint-node.js';
+import type { UniqueConstraintNode } from './unique-constraint-node.js';
+import type { ReferencesNode } from './references-node.js';
+import type { CheckConstraintNode } from './check-constraint-node.js';
+import type { WithNode } from './with-node.js';
+import type { CommonTableExpressionNode } from './common-table-expression-node.js';
+import type { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
+import type { HavingNode } from './having-node.js';
+import type { CreateSchemaNode } from './create-schema-node.js';
+import type { DropSchemaNode } from './drop-schema-node.js';
+import type { AlterTableNode } from './alter-table-node.js';
+import type { DropColumnNode } from './drop-column-node.js';
+import type { RenameColumnNode } from './rename-column-node.js';
+import type { AlterColumnNode } from './alter-column-node.js';
+import type { AddConstraintNode } from './add-constraint-node.js';
+import type { DropConstraintNode } from './drop-constraint-node.js';
+import type { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
+import type { ColumnDefinitionNode } from './column-definition-node.js';
+import type { ModifyColumnNode } from './modify-column-node.js';
+import type { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
+import type { CreateViewNode } from './create-view-node.js';
+import type { DropViewNode } from './drop-view-node.js';
+import type { GeneratedNode } from './generated-node.js';
+import type { DefaultValueNode } from './default-value-node.js';
+import type { OnNode } from './on-node.js';
+import type { ValuesNode } from './values-node.js';
+import type { SelectModifierNode } from './select-modifier-node.js';
+import type { CreateTypeNode } from './create-type-node.js';
+import type { DropTypeNode } from './drop-type-node.js';
+import type { ExplainNode } from './explain-node.js';
+import type { SchemableIdentifierNode } from './schemable-identifier-node.js';
+import type { DefaultInsertValueNode } from './default-insert-value-node.js';
+import type { AggregateFunctionNode } from './aggregate-function-node.js';
+import type { OverNode } from './over-node.js';
+import type { PartitionByNode } from './partition-by-node.js';
+import type { PartitionByItemNode } from './partition-by-item-node.js';
+import type { SetOperationNode } from './set-operation-node.js';
+import type { BinaryOperationNode } from './binary-operation-node.js';
+import type { UnaryOperationNode } from './unary-operation-node.js';
+import type { UsingNode } from './using-node.js';
+import type { FunctionNode } from './function-node.js';
+import type { CaseNode } from './case-node.js';
+import type { WhenNode } from './when-node.js';
+import type { JSONReferenceNode } from './json-reference-node.js';
+import type { JSONPathNode } from './json-path-node.js';
+import type { JSONPathLegNode } from './json-path-leg-node.js';
+import type { JSONOperatorChainNode } from './json-operator-chain-node.js';
+import type { TupleNode } from './tuple-node.js';
+import type { MergeQueryNode } from './merge-query-node.js';
+import type { MatchedNode } from './matched-node.js';
+import type { AddIndexNode } from './add-index-node.js';
+import type { CastNode } from './cast-node.js';
+import type { FetchNode } from './fetch-node.js';
+import type { TopNode } from './top-node.js';
+import type { OutputNode } from './output-node.js';
+import type { RefreshMaterializedViewNode } from './refresh-materialized-view-node.js';
+import type { OrActionNode } from './or-action-node.js';
+import type { CollateNode } from './collate-node.js';
+import type { QueryId } from '../util/query-id.js';
+import type { RenameConstraintNode } from './rename-constraint-node.js';
+import type { AddValueNode } from './add-value-node.js';
+import type { AlterTypeNode } from './alter-type-node.js';
+import type { RenameValueNode } from './rename-value-node.js';
+/**
+ * Transforms an operation node tree into another one.
+ *
+ * Kysely queries are expressed internally as a tree of objects (operation nodes).
+ * `OperationNodeTransformer` takes such a tree as its input and returns a
+ * transformed deep copy of it. By default the `OperationNodeTransformer`
+ * does nothing. You need to override one or more methods to make it do
+ * something.
+ *
+ * There's a method for each node type. For example if you'd like to convert
+ * each identifier (table name, column name, alias etc.) from camelCase to
+ * snake_case, you'd do something like this:
+ *
+ * ```ts
+ * import { type IdentifierNode, OperationNodeTransformer } from 'kysely'
+ * import snakeCase from 'lodash/snakeCase'
+ *
+ * class CamelCaseTransformer extends OperationNodeTransformer {
+ *   override transformIdentifier(node: IdentifierNode): IdentifierNode {
+ *     node = super.transformIdentifier(node)
+ *
+ *     return {
+ *       ...node,
+ *       name: snakeCase(node.name),
+ *     }
+ *   }
+ * }
+ *
+ * const transformer = new CamelCaseTransformer()
+ *
+ * const query = db.selectFrom('person').select(['first_name', 'last_name'])
+ *
+ * const tree = transformer.transformNode(query.toOperationNode())
+ * ```
+ */
+export declare class OperationNodeTransformer {
+    #private;
+    protected readonly nodeStack: OperationNode[];
+    transformNode<T extends OperationNode | undefined>(node: T, queryId?: QueryId): T;
+    protected transformNodeImpl<T extends OperationNode>(node: T, queryId?: QueryId): T;
+    protected transformNodeList<T extends ReadonlyArray<OperationNode> | undefined>(list: T, queryId?: QueryId): T;
+    protected transformSelectQuery(node: SelectQueryNode, queryId?: QueryId): SelectQueryNode;
+    protected transformSelection(node: SelectionNode, queryId?: QueryId): SelectionNode;
+    protected transformColumn(node: ColumnNode, queryId?: QueryId): ColumnNode;
+    protected transformAlias(node: AliasNode, queryId?: QueryId): AliasNode;
+    protected transformTable(node: TableNode, queryId?: QueryId): TableNode;
+    protected transformFrom(node: FromNode, queryId?: QueryId): FromNode;
+    protected transformReference(node: ReferenceNode, queryId?: QueryId): ReferenceNode;
+    protected transformAnd(node: AndNode, queryId?: QueryId): AndNode;
+    protected transformOr(node: OrNode, queryId?: QueryId): OrNode;
+    protected transformValueList(node: ValueListNode, queryId?: QueryId): ValueListNode;
+    protected transformParens(node: ParensNode, queryId?: QueryId): ParensNode;
+    protected transformJoin(node: JoinNode, queryId?: QueryId): JoinNode;
+    protected transformRaw(node: RawNode, queryId?: QueryId): RawNode;
+    protected transformWhere(node: WhereNode, queryId?: QueryId): WhereNode;
+    protected transformInsertQuery(node: InsertQueryNode, queryId?: QueryId): InsertQueryNode;
+    protected transformValues(node: ValuesNode, queryId?: QueryId): ValuesNode;
+    protected transformDeleteQuery(node: DeleteQueryNode, queryId?: QueryId): DeleteQueryNode;
+    protected transformReturning(node: ReturningNode, queryId?: QueryId): ReturningNode;
+    protected transformCreateTable(node: CreateTableNode, queryId?: QueryId): CreateTableNode;
+    protected transformColumnDefinition(node: ColumnDefinitionNode, queryId?: QueryId): ColumnDefinitionNode;
+    protected transformAddColumn(node: AddColumnNode, queryId?: QueryId): AddColumnNode;
+    protected transformDropTable(node: DropTableNode, queryId?: QueryId): DropTableNode;
+    protected transformOrderBy(node: OrderByNode, queryId?: QueryId): OrderByNode;
+    protected transformOrderByItem(node: OrderByItemNode, queryId?: QueryId): OrderByItemNode;
+    protected transformGroupBy(node: GroupByNode, queryId?: QueryId): GroupByNode;
+    protected transformGroupByItem(node: GroupByItemNode, queryId?: QueryId): GroupByItemNode;
+    protected transformUpdateQuery(node: UpdateQueryNode, queryId?: QueryId): UpdateQueryNode;
+    protected transformColumnUpdate(node: ColumnUpdateNode, queryId?: QueryId): ColumnUpdateNode;
+    protected transformLimit(node: LimitNode, queryId?: QueryId): LimitNode;
+    protected transformOffset(node: OffsetNode, queryId?: QueryId): OffsetNode;
+    protected transformOnConflict(node: OnConflictNode, queryId?: QueryId): OnConflictNode;
+    protected transformOnDuplicateKey(node: OnDuplicateKeyNode, queryId?: QueryId): OnDuplicateKeyNode;
+    protected transformCreateIndex(node: CreateIndexNode, queryId?: QueryId): CreateIndexNode;
+    protected transformList(node: ListNode, queryId?: QueryId): ListNode;
+    protected transformDropIndex(node: DropIndexNode, queryId?: QueryId): DropIndexNode;
+    protected transformPrimaryKeyConstraint(node: PrimaryKeyConstraintNode, queryId?: QueryId): PrimaryKeyConstraintNode;
+    protected transformUniqueConstraint(node: UniqueConstraintNode, queryId?: QueryId): UniqueConstraintNode;
+    protected transformForeignKeyConstraint(node: ForeignKeyConstraintNode, queryId?: QueryId): ForeignKeyConstraintNode;
+    protected transformSetOperation(node: SetOperationNode, queryId?: QueryId): SetOperationNode;
+    protected transformReferences(node: ReferencesNode, queryId?: QueryId): ReferencesNode;
+    protected transformCheckConstraint(node: CheckConstraintNode, queryId?: QueryId): CheckConstraintNode;
+    protected transformWith(node: WithNode, queryId?: QueryId): WithNode;
+    protected transformCommonTableExpression(node: CommonTableExpressionNode, queryId?: QueryId): CommonTableExpressionNode;
+    protected transformCommonTableExpressionName(node: CommonTableExpressionNameNode, queryId?: QueryId): CommonTableExpressionNameNode;
+    protected transformHaving(node: HavingNode, queryId?: QueryId): HavingNode;
+    protected transformCreateSchema(node: CreateSchemaNode, queryId?: QueryId): CreateSchemaNode;
+    protected transformDropSchema(node: DropSchemaNode, queryId?: QueryId): DropSchemaNode;
+    protected transformAlterTable(node: AlterTableNode, queryId?: QueryId): AlterTableNode;
+    protected transformDropColumn(node: DropColumnNode, queryId?: QueryId): DropColumnNode;
+    protected transformRenameColumn(node: RenameColumnNode, queryId?: QueryId): RenameColumnNode;
+    protected transformAlterColumn(node: AlterColumnNode, queryId?: QueryId): AlterColumnNode;
+    protected transformModifyColumn(node: ModifyColumnNode, queryId?: QueryId): ModifyColumnNode;
+    protected transformAddConstraint(node: AddConstraintNode, queryId?: QueryId): AddConstraintNode;
+    protected transformDropConstraint(node: DropConstraintNode, queryId?: QueryId): DropConstraintNode;
+    protected transformRenameConstraint(node: RenameConstraintNode, queryId?: QueryId): RenameConstraintNode;
+    protected transformCreateView(node: CreateViewNode, queryId?: QueryId): CreateViewNode;
+    protected transformRefreshMaterializedView(node: RefreshMaterializedViewNode, queryId?: QueryId): RefreshMaterializedViewNode;
+    protected transformDropView(node: DropViewNode, queryId?: QueryId): DropViewNode;
+    protected transformGenerated(node: GeneratedNode, queryId?: QueryId): GeneratedNode;
+    protected transformDefaultValue(node: DefaultValueNode, queryId?: QueryId): DefaultValueNode;
+    protected transformOn(node: OnNode, queryId?: QueryId): OnNode;
+    protected transformSelectModifier(node: SelectModifierNode, queryId?: QueryId): SelectModifierNode;
+    protected transformCreateType(node: CreateTypeNode, queryId?: QueryId): CreateTypeNode;
+    protected transformDropType(node: DropTypeNode, queryId?: QueryId): DropTypeNode;
+    protected transformExplain(node: ExplainNode, queryId?: QueryId): ExplainNode;
+    protected transformSchemableIdentifier(node: SchemableIdentifierNode, queryId?: QueryId): SchemableIdentifierNode;
+    protected transformAggregateFunction(node: AggregateFunctionNode, queryId?: QueryId): AggregateFunctionNode;
+    protected transformOver(node: OverNode, queryId?: QueryId): OverNode;
+    protected transformPartitionBy(node: PartitionByNode, queryId?: QueryId): PartitionByNode;
+    protected transformPartitionByItem(node: PartitionByItemNode, queryId?: QueryId): PartitionByItemNode;
+    protected transformBinaryOperation(node: BinaryOperationNode, queryId?: QueryId): BinaryOperationNode;
+    protected transformUnaryOperation(node: UnaryOperationNode, queryId?: QueryId): UnaryOperationNode;
+    protected transformUsing(node: UsingNode, queryId?: QueryId): UsingNode;
+    protected transformFunction(node: FunctionNode, queryId?: QueryId): FunctionNode;
+    protected transformCase(node: CaseNode, queryId?: QueryId): CaseNode;
+    protected transformWhen(node: WhenNode, queryId?: QueryId): WhenNode;
+    protected transformJSONReference(node: JSONReferenceNode, queryId?: QueryId): JSONReferenceNode;
+    protected transformJSONPath(node: JSONPathNode, queryId?: QueryId): JSONPathNode;
+    protected transformJSONPathLeg(node: JSONPathLegNode, _queryId?: QueryId): JSONPathLegNode;
+    protected transformJSONOperatorChain(node: JSONOperatorChainNode, queryId?: QueryId): JSONOperatorChainNode;
+    protected transformTuple(node: TupleNode, queryId?: QueryId): TupleNode;
+    protected transformMergeQuery(node: MergeQueryNode, queryId?: QueryId): MergeQueryNode;
+    protected transformMatched(node: MatchedNode, _queryId?: QueryId): MatchedNode;
+    protected transformAddIndex(node: AddIndexNode, queryId?: QueryId): AddIndexNode;
+    protected transformCast(node: CastNode, queryId?: QueryId): CastNode;
+    protected transformFetch(node: FetchNode, queryId?: QueryId): FetchNode;
+    protected transformTop(node: TopNode, _queryId?: QueryId): TopNode;
+    protected transformOutput(node: OutputNode, queryId?: QueryId): OutputNode;
+    protected transformAlterType(node: AlterTypeNode, queryId?: QueryId): AlterTypeNode;
+    protected transformAddValue(node: AddValueNode, queryId?: QueryId): AddValueNode;
+    protected transformRenameValue(node: RenameValueNode, queryId?: QueryId): RenameValueNode;
+    protected transformDataType(node: DataTypeNode, _queryId?: QueryId): DataTypeNode;
+    protected transformSelectAll(node: SelectAllNode, _queryId?: QueryId): SelectAllNode;
+    protected transformIdentifier(node: IdentifierNode, _queryId?: QueryId): IdentifierNode;
+    protected transformValue(node: ValueNode, _queryId?: QueryId): ValueNode;
+    protected transformPrimitiveValueList(node: PrimitiveValueListNode, _queryId?: QueryId): PrimitiveValueListNode;
+    protected transformOperator(node: OperatorNode, _queryId?: QueryId): OperatorNode;
+    protected transformDefaultInsertValue(node: DefaultInsertValueNode, _queryId?: QueryId): DefaultInsertValueNode;
+    protected transformOrAction(node: OrActionNode, _queryId?: QueryId): OrActionNode;
+    protected transformCollate(node: CollateNode, _queryId?: QueryId): CollateNode;
+}