kysely 0.27.6 → 0.28.1

package/dist/cjs/operation-node/delete-query-node.d.ts

@@ -32,8 +32,14 @@ export interface DeleteQueryNode extends OperationNode {
 export declare const DeleteQueryNode: Readonly<{
     is(node: OperationNode): node is DeleteQueryNode;
     create(fromItems: OperationNode[], withNode?: WithNode): DeleteQueryNode;
-    cloneWithOrderByItems(deleteNode: DeleteQueryNode, items: ReadonlyArray<OrderByItemNode>): DeleteQueryNode;
-    cloneWithoutOrderBy(deleteNode: DeleteQueryNode): DeleteQueryNode;
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithOrderByItems: (node: DeleteQueryNode, items: ReadonlyArray<OrderByItemNode>) => DeleteQueryNode;
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithoutOrderBy: (node: DeleteQueryNode) => DeleteQueryNode;
     cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
     cloneWithoutLimit(deleteNode: DeleteQueryNode): DeleteQueryNode;
     cloneWithUsing(deleteNode: DeleteQueryNode, tables: OperationNode[]): DeleteQueryNode;

package/dist/cjs/operation-node/delete-query-node.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeleteQueryNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
 const from_node_js_1 = require("./from-node.js");
-const order_by_node_js_1 = require("./order-by-node.js");
 const using_node_js_1 = require("./using-node.js");
+const query_node_js_1 = require("./query-node.js");
 /**
  * @internal
  */
@@ -19,20 +19,16 @@ exports.DeleteQueryNode = (0, object_utils_js_1.freeze)({
             ...(withNode && { with: withNode }),
         });
     },
-    cloneWithOrderByItems(deleteNode, items) {
-        return (0, object_utils_js_1.freeze)({
-            ...deleteNode,
-            orderBy: deleteNode.orderBy
-                ? order_by_node_js_1.OrderByNode.cloneWithItems(deleteNode.orderBy, items)
-                : order_by_node_js_1.OrderByNode.create(items),
-        });
-    },
-    cloneWithoutOrderBy(deleteNode) {
-        return (0, object_utils_js_1.freeze)({
-            ...deleteNode,
-            orderBy: undefined,
-        });
-    },
+    // TODO: remove in v0.29
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithOrderByItems: (node, items) => query_node_js_1.QueryNode.cloneWithOrderByItems(node, items),
+    // TODO: remove in v0.29
+    /**
+     * @deprecated Use `QueryNode.cloneWithoutOrderBy` instead.
+     */
+    cloneWithoutOrderBy: (node) => query_node_js_1.QueryNode.cloneWithoutOrderBy(node),
     cloneWithLimit(deleteNode, limit) {
         return (0, object_utils_js_1.freeze)({
             ...deleteNode,

package/dist/cjs/operation-node/foreign-key-constraint-node.d.ts

@@ -11,6 +11,8 @@ export interface ForeignKeyConstraintNode extends OperationNode {
     readonly onDelete?: OnModifyForeignAction;
     readonly onUpdate?: OnModifyForeignAction;
     readonly name?: IdentifierNode;
+    readonly deferrable?: boolean;
+    readonly initiallyDeferred?: boolean;
 }
 /**
  * @internal
@@ -22,6 +24,8 @@ export declare const ForeignKeyConstraintNode: Readonly<{
         name?: IdentifierNode;
         onDelete?: OnModifyForeignAction;
         onUpdate?: OnModifyForeignAction;
+        deferrable?: boolean;
+        initiallyDeferred?: boolean;
         kind: "ForeignKeyConstraintNode";
         columns: ReadonlyArray<ColumnNode>;
         references: ReferencesNode;

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

@@ -3,6 +3,7 @@ import { ExplainNode } from './explain-node.js';
 import { OnConflictNode } from './on-conflict-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { OperationNode } from './operation-node.js';
+import { OrActionNode } from './or-action-node.js';
 import { OutputNode } from './output-node.js';
 import { ReturningNode } from './returning-node.js';
 import { TableNode } from './table-node.js';
@@ -18,7 +19,9 @@ export interface InsertQueryNode extends OperationNode {
     readonly onConflict?: OnConflictNode;
     readonly onDuplicateKey?: OnDuplicateKeyNode;
     readonly with?: WithNode;
+    /** @deprecated use {@link orAction} instead. */
     readonly ignore?: boolean;
+    readonly orAction?: OrActionNode;
     readonly replace?: boolean;
     readonly explain?: ExplainNode;
     readonly defaultValues?: boolean;

package/dist/cjs/operation-node/join-node.d.ts

@@ -1,6 +1,6 @@
 import { OnNode } from './on-node.js';
 import { OperationNode } from './operation-node.js';
-export type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin' | 'LateralInnerJoin' | 'LateralLeftJoin' | 'Using';
+export type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin' | 'CrossJoin' | 'LateralInnerJoin' | 'LateralLeftJoin' | 'LateralCrossJoin' | 'Using' | 'OuterApply' | 'CrossApply';
 export interface JoinNode extends OperationNode {
     readonly kind: 'JoinNode';
     readonly joinType: JoinType;

package/dist/cjs/operation-node/merge-query-node.d.ts

@@ -2,6 +2,7 @@ import { AliasNode } from './alias-node.js';
 import { JoinNode } from './join-node.js';
 import { OperationNode } from './operation-node.js';
 import { OutputNode } from './output-node.js';
+import { ReturningNode } from './returning-node.js';
 import { TableNode } from './table-node.js';
 import { TopNode } from './top-node.js';
 import { WhenNode } from './when-node.js';
@@ -13,6 +14,7 @@ export interface MergeQueryNode extends OperationNode {
     readonly whens?: ReadonlyArray<WhenNode>;
     readonly with?: WithNode;
     readonly top?: TopNode;
+    readonly returning?: ReturningNode;
     readonly output?: OutputNode;
     readonly endModifiers?: ReadonlyArray<OperationNode>;
 }

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

@@ -37,7 +37,7 @@ import { OnConflictNode } from './on-conflict-node.js';
 import { CreateIndexNode } from './create-index-node.js';
 import { ListNode } from './list-node.js';
 import { DropIndexNode } from './drop-index-node.js';
-import { PrimaryKeyConstraintNode } from './primary-constraint-node.js';
+import { PrimaryKeyConstraintNode } from './primary-key-constraint-node.js';
 import { UniqueConstraintNode } from './unique-constraint-node.js';
 import { ReferencesNode } from './references-node.js';
 import { CheckConstraintNode } from './check-constraint-node.js';
@@ -92,6 +92,11 @@ import { CastNode } from './cast-node.js';
 import { FetchNode } from './fetch-node.js';
 import { TopNode } from './top-node.js';
 import { OutputNode } from './output-node.js';
+import { RefreshMaterializedViewNode } from './refresh-materialized-view-node.js';
+import { OrActionNode } from './or-action-node.js';
+import { CollateNode } from './collate-node.js';
+import { QueryId } from '../util/query-id.js';
+import { RenameConstraintNode } from './rename-constraint-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -130,100 +135,104 @@ import { OutputNode } from './output-node.js';
 export declare class OperationNodeTransformer {
     #private;
     protected readonly nodeStack: OperationNode[];
-    transformNode<T extends OperationNode | undefined>(node: T): T;
-    protected transformNodeImpl<T extends OperationNode>(node: T): T;
-    protected transformNodeList<T extends ReadonlyArray<OperationNode> | undefined>(list: T): T;
-    protected transformSelectQuery(node: SelectQueryNode): SelectQueryNode;
-    protected transformSelection(node: SelectionNode): SelectionNode;
-    protected transformColumn(node: ColumnNode): ColumnNode;
-    protected transformAlias(node: AliasNode): AliasNode;
-    protected transformTable(node: TableNode): TableNode;
-    protected transformFrom(node: FromNode): FromNode;
-    protected transformReference(node: ReferenceNode): ReferenceNode;
-    protected transformAnd(node: AndNode): AndNode;
-    protected transformOr(node: OrNode): OrNode;
-    protected transformValueList(node: ValueListNode): ValueListNode;
-    protected transformParens(node: ParensNode): ParensNode;
-    protected transformJoin(node: JoinNode): JoinNode;
-    protected transformRaw(node: RawNode): RawNode;
-    protected transformWhere(node: WhereNode): WhereNode;
-    protected transformInsertQuery(node: InsertQueryNode): InsertQueryNode;
-    protected transformValues(node: ValuesNode): ValuesNode;
-    protected transformDeleteQuery(node: DeleteQueryNode): DeleteQueryNode;
-    protected transformReturning(node: ReturningNode): ReturningNode;
-    protected transformCreateTable(node: CreateTableNode): CreateTableNode;
-    protected transformColumnDefinition(node: ColumnDefinitionNode): ColumnDefinitionNode;
-    protected transformAddColumn(node: AddColumnNode): AddColumnNode;
-    protected transformDropTable(node: DropTableNode): DropTableNode;
-    protected transformOrderBy(node: OrderByNode): OrderByNode;
-    protected transformOrderByItem(node: OrderByItemNode): OrderByItemNode;
-    protected transformGroupBy(node: GroupByNode): GroupByNode;
-    protected transformGroupByItem(node: GroupByItemNode): GroupByItemNode;
-    protected transformUpdateQuery(node: UpdateQueryNode): UpdateQueryNode;
-    protected transformColumnUpdate(node: ColumnUpdateNode): ColumnUpdateNode;
-    protected transformLimit(node: LimitNode): LimitNode;
-    protected transformOffset(node: OffsetNode): OffsetNode;
-    protected transformOnConflict(node: OnConflictNode): OnConflictNode;
-    protected transformOnDuplicateKey(node: OnDuplicateKeyNode): OnDuplicateKeyNode;
-    protected transformCreateIndex(node: CreateIndexNode): CreateIndexNode;
-    protected transformList(node: ListNode): ListNode;
-    protected transformDropIndex(node: DropIndexNode): DropIndexNode;
-    protected transformPrimaryKeyConstraint(node: PrimaryKeyConstraintNode): PrimaryKeyConstraintNode;
-    protected transformUniqueConstraint(node: UniqueConstraintNode): UniqueConstraintNode;
-    protected transformForeignKeyConstraint(node: ForeignKeyConstraintNode): ForeignKeyConstraintNode;
-    protected transformSetOperation(node: SetOperationNode): SetOperationNode;
-    protected transformReferences(node: ReferencesNode): ReferencesNode;
-    protected transformCheckConstraint(node: CheckConstraintNode): CheckConstraintNode;
-    protected transformWith(node: WithNode): WithNode;
-    protected transformCommonTableExpression(node: CommonTableExpressionNode): CommonTableExpressionNode;
-    protected transformCommonTableExpressionName(node: CommonTableExpressionNameNode): CommonTableExpressionNameNode;
-    protected transformHaving(node: HavingNode): HavingNode;
-    protected transformCreateSchema(node: CreateSchemaNode): CreateSchemaNode;
-    protected transformDropSchema(node: DropSchemaNode): DropSchemaNode;
-    protected transformAlterTable(node: AlterTableNode): AlterTableNode;
-    protected transformDropColumn(node: DropColumnNode): DropColumnNode;
-    protected transformRenameColumn(node: RenameColumnNode): RenameColumnNode;
-    protected transformAlterColumn(node: AlterColumnNode): AlterColumnNode;
-    protected transformModifyColumn(node: ModifyColumnNode): ModifyColumnNode;
-    protected transformAddConstraint(node: AddConstraintNode): AddConstraintNode;
-    protected transformDropConstraint(node: DropConstraintNode): DropConstraintNode;
-    protected transformCreateView(node: CreateViewNode): CreateViewNode;
-    protected transformDropView(node: DropViewNode): DropViewNode;
-    protected transformGenerated(node: GeneratedNode): GeneratedNode;
-    protected transformDefaultValue(node: DefaultValueNode): DefaultValueNode;
-    protected transformOn(node: OnNode): OnNode;
-    protected transformSelectModifier(node: SelectModifierNode): SelectModifierNode;
-    protected transformCreateType(node: CreateTypeNode): CreateTypeNode;
-    protected transformDropType(node: DropTypeNode): DropTypeNode;
-    protected transformExplain(node: ExplainNode): ExplainNode;
-    protected transformSchemableIdentifier(node: SchemableIdentifierNode): SchemableIdentifierNode;
-    protected transformAggregateFunction(node: AggregateFunctionNode): AggregateFunctionNode;
-    protected transformOver(node: OverNode): OverNode;
-    protected transformPartitionBy(node: PartitionByNode): PartitionByNode;
-    protected transformPartitionByItem(node: PartitionByItemNode): PartitionByItemNode;
-    protected transformBinaryOperation(node: BinaryOperationNode): BinaryOperationNode;
-    protected transformUnaryOperation(node: UnaryOperationNode): UnaryOperationNode;
-    protected transformUsing(node: UsingNode): UsingNode;
-    protected transformFunction(node: FunctionNode): FunctionNode;
-    protected transformCase(node: CaseNode): CaseNode;
-    protected transformWhen(node: WhenNode): WhenNode;
-    protected transformJSONReference(node: JSONReferenceNode): JSONReferenceNode;
-    protected transformJSONPath(node: JSONPathNode): JSONPathNode;
-    protected transformJSONPathLeg(node: JSONPathLegNode): JSONPathLegNode;
-    protected transformJSONOperatorChain(node: JSONOperatorChainNode): JSONOperatorChainNode;
-    protected transformTuple(node: TupleNode): TupleNode;
-    protected transformMergeQuery(node: MergeQueryNode): MergeQueryNode;
-    protected transformMatched(node: MatchedNode): MatchedNode;
-    protected transformAddIndex(node: AddIndexNode): AddIndexNode;
-    protected transformCast(node: CastNode): CastNode;
-    protected transformFetch(node: FetchNode): FetchNode;
-    protected transformTop(node: TopNode): TopNode;
-    protected transformOutput(node: OutputNode): OutputNode;
-    protected transformDataType(node: DataTypeNode): DataTypeNode;
-    protected transformSelectAll(node: SelectAllNode): SelectAllNode;
-    protected transformIdentifier(node: IdentifierNode): IdentifierNode;
-    protected transformValue(node: ValueNode): ValueNode;
-    protected transformPrimitiveValueList(node: PrimitiveValueListNode): PrimitiveValueListNode;
-    protected transformOperator(node: OperatorNode): OperatorNode;
-    protected transformDefaultInsertValue(node: DefaultInsertValueNode): DefaultInsertValueNode;
+    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 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;
 }