kysely 0.27.1 → 0.27.3

package/dist/esm/migration/migrator.js

@@ -4,6 +4,7 @@ import { WithSchemaPlugin } from '../plugin/with-schema/with-schema-plugin.js';
 import { freeze, getLast } from '../util/object-utils.js';
 export const DEFAULT_MIGRATION_TABLE = 'kysely_migration';
 export const DEFAULT_MIGRATION_LOCK_TABLE = 'kysely_migration_lock';
+export const DEFAULT_ALLOW_UNORDERED_MIGRATIONS = false;
 export const MIGRATION_LOCK_ID = 'migration_lock';
 export const NO_MIGRATIONS = freeze({ __noMigrations__: true });
 /**
@@ -70,7 +71,7 @@ export class Migrator {
      * This method goes through all possible migrations provided by the provider and runs the
      * ones whose names come alphabetically after the last migration that has been run. If the
      * list of executed migrations doesn't match the beginning of the list of possible migrations
-     * an error is thrown.
+     * an error is returned.
      *
      * ### Examples
      *
@@ -107,7 +108,7 @@ export class Migrator {
      * ```
      */
     async migrateToLatest() {
-        return this.#migrate(({ migrations }) => migrations.length - 1);
+        return this.#migrate(() => ({ direction: 'Up', step: Infinity }));
     }
     /**
      * Migrate up/down to a specific migration.
@@ -133,15 +134,27 @@ export class Migrator {
      * ```
      */
     async migrateTo(targetMigrationName) {
-        return this.#migrate(({ migrations }) => {
+        return this.#migrate(({ migrations, executedMigrations, pendingMigrations, }) => {
             if (targetMigrationName === NO_MIGRATIONS) {
-                return -1;
+                return { direction: 'Down', step: Infinity };
             }
-            const index = migrations.findIndex((it) => it.name === targetMigrationName);
-            if (index === -1) {
+            if (!migrations.find((m) => m.name === targetMigrationName)) {
                 throw new Error(`migration "${targetMigrationName}" doesn't exist`);
             }
-            return index;
+            const executedIndex = executedMigrations.indexOf(targetMigrationName);
+            const pendingIndex = pendingMigrations.findIndex((m) => m.name === targetMigrationName);
+            if (executedIndex !== -1) {
+                return {
+                    direction: 'Down',
+                    step: executedMigrations.length - executedIndex - 1,
+                };
+            }
+            else if (pendingIndex !== -1) {
+                return { direction: 'Up', step: pendingIndex + 1 };
+            }
+            else {
+                throw new Error(`migration "${targetMigrationName}" isn't executed or pending`);
+            }
         });
     }
     /**
@@ -159,7 +172,7 @@ export class Migrator {
      * ```
      */
     async migrateUp() {
-        return this.#migrate(({ currentIndex, migrations }) => Math.min(currentIndex + 1, migrations.length - 1));
+        return this.#migrate(() => ({ direction: 'Up', step: 1 }));
     }
     /**
      * Migrate one step down.
@@ -176,12 +189,12 @@ export class Migrator {
      * ```
      */
     async migrateDown() {
-        return this.#migrate(({ currentIndex }) => Math.max(currentIndex - 1, -1));
+        return this.#migrate(() => ({ direction: 'Down', step: 1 }));
     }
-    async #migrate(getTargetMigrationIndex) {
+    async #migrate(getMigrationDirectionAndStep) {
         try {
             await this.#ensureMigrationTablesExists();
-            return await this.#runMigrations(getTargetMigrationIndex);
+            return await this.#runMigrations(getMigrationDirectionAndStep);
         }
         catch (error) {
             if (error instanceof MigrationResultSetError) {
@@ -199,6 +212,9 @@ export class Migrator {
     get #migrationLockTable() {
         return this.#props.migrationLockTableName ?? DEFAULT_MIGRATION_LOCK_TABLE;
     }
+    get #allowUnorderedMigrations() {
+        return (this.#props.allowUnorderedMigrations ?? DEFAULT_ALLOW_UNORDERED_MIGRATIONS);
+    }
     get #schemaPlugin() {
         if (this.#migrationTableSchema) {
             return new WithSchemaPlugin(this.#migrationTableSchema);
@@ -309,7 +325,7 @@ export class Migrator {
             .executeTakeFirst();
         return !!lockRow;
     }
-    async #runMigrations(getTargetMigrationIndex) {
+    async #runMigrations(getMigrationDirectionAndStep) {
         const adapter = this.#props.db.getExecutor().adapter;
         const lockOptions = freeze({
             lockTable: this.#props.migrationLockTableName ?? DEFAULT_MIGRATION_LOCK_TABLE,
@@ -323,15 +339,15 @@ export class Migrator {
                 if (state.migrations.length === 0) {
                     return { results: [] };
                 }
-                const targetIndex = getTargetMigrationIndex(state);
-                if (targetIndex === undefined) {
+                const { direction, step } = getMigrationDirectionAndStep(state);
+                if (step <= 0) {
                     return { results: [] };
                 }
-                if (targetIndex < state.currentIndex) {
-                    return await this.#migrateDown(db, state, targetIndex);
+                if (direction === 'Down') {
+                    return await this.#migrateDown(db, state, step);
                 }
-                else if (targetIndex > state.currentIndex) {
-                    return await this.#migrateUp(db, state, targetIndex);
+                else if (direction === 'Up') {
+                    return await this.#migrateUp(db, state, step);
                 }
                 return { results: [] };
             }
@@ -349,10 +365,21 @@ export class Migrator {
     async #getState(db) {
         const migrations = await this.#resolveMigrations();
         const executedMigrations = await this.#getExecutedMigrations(db);
-        this.#ensureMigrationsNotCorrupted(migrations, executedMigrations);
+        this.#ensureNoMissingMigrations(migrations, executedMigrations);
+        if (!this.#allowUnorderedMigrations) {
+            this.#ensureMigrationsInOrder(migrations, executedMigrations);
+        }
+        const pendingMigrations = this.#getPendingMigrations(migrations, executedMigrations);
         return freeze({
             migrations,
-            currentIndex: migrations.findIndex((it) => it.name === getLast(executedMigrations)),
+            executedMigrations,
+            lastMigration: getLast(executedMigrations),
+            pendingMigrations,
+        });
+    }
+    #getPendingMigrations(migrations, executedMigrations) {
+        return migrations.filter((migration) => {
+            return !executedMigrations.includes(migration.name);
         });
     }
     async #resolveMigrations() {
@@ -369,36 +396,43 @@ export class Migrator {
             .withPlugin(this.#schemaPlugin)
             .selectFrom(this.#migrationTable)
             .select('name')
-            .orderBy('name')
+            .orderBy(['timestamp', 'name'])
             .execute();
         return executedMigrations.map((it) => it.name);
     }
-    #ensureMigrationsNotCorrupted(migrations, executedMigrations) {
+    #ensureNoMissingMigrations(migrations, executedMigrations) {
+        // Ensure all executed migrations exist in the `migrations` list.
         for (const executed of executedMigrations) {
             if (!migrations.some((it) => it.name === executed)) {
                 throw new Error(`corrupted migrations: previously executed migration ${executed} is missing`);
             }
         }
-        // Now we know all executed migrations exist in the `migrations` list.
-        // Next we need to make sure that the executed migratiosns are the first
-        // ones in the migration list.
+    }
+    #ensureMigrationsInOrder(migrations, executedMigrations) {
+        // Ensure the executed migrations are the first ones in the migration list.
         for (let i = 0; i < executedMigrations.length; ++i) {
             if (migrations[i].name !== executedMigrations[i]) {
                 throw new Error(`corrupted migrations: expected previously executed migration ${executedMigrations[i]} to be at index ${i} but ${migrations[i].name} was found in its place. New migrations must always have a name that comes alphabetically after the last executed migration.`);
             }
         }
     }
-    async #migrateDown(db, state, targetIndex) {
-        const results = [];
-        for (let i = state.currentIndex; i > targetIndex; --i) {
-            results.push({
-                migrationName: state.migrations[i].name,
+    async #migrateDown(db, state, step) {
+        const migrationsToRollback = state.executedMigrations
+            .slice()
+            .reverse()
+            .slice(0, step)
+            .map((name) => {
+            return state.migrations.find((it) => it.name === name);
+        });
+        const results = migrationsToRollback.map((migration) => {
+            return {
+                migrationName: migration.name,
                 direction: 'Down',
                 status: 'NotExecuted',
-            });
-        }
+            };
+        });
         for (let i = 0; i < results.length; ++i) {
-            const migration = state.migrations.find((it) => it.name === results[i].migrationName);
+            const migration = migrationsToRollback[i];
             try {
                 if (migration.down) {
                     await migration.down(db);
@@ -428,17 +462,17 @@ export class Migrator {
         }
         return { results };
     }
-    async #migrateUp(db, state, targetIndex) {
-        const results = [];
-        for (let i = state.currentIndex + 1; i <= targetIndex; ++i) {
-            results.push({
-                migrationName: state.migrations[i].name,
+    async #migrateUp(db, state, step) {
+        const migrationsToRun = state.pendingMigrations.slice(0, step);
+        const results = migrationsToRun.map((migration) => {
+            return {
+                migrationName: migration.name,
                 direction: 'Up',
                 status: 'NotExecuted',
-            });
-        }
-        for (let i = 0; i < results.length; ++i) {
-            const migration = state.migrations.find((it) => it.name === results[i].migrationName);
+            };
+        });
+        for (let i = 0; i < results.length; i++) {
+            const migration = state.pendingMigrations[i];
             try {
                 await migration.up(db);
                 await db

package/dist/esm/operation-node/add-index-node.js

@@ -11,7 +11,7 @@ export const AddIndexNode = freeze({
     create(name) {
         return freeze({
             kind: 'AddIndexNode',
-            name: IdentifierNode.create(name)
+            name: IdentifierNode.create(name),
         });
     },
     cloneWith(node, props) {

package/dist/esm/operation-node/cast-node.d.ts

@@ -0,0 +1,13 @@
+import { OperationNode } from './operation-node.js';
+export interface CastNode extends OperationNode {
+    readonly kind: 'CastNode';
+    readonly expression: OperationNode;
+    readonly dataType: OperationNode;
+}
+/**
+ * @internal
+ */
+export declare const CastNode: Readonly<{
+    is(node: OperationNode): node is CastNode;
+    create(expression: OperationNode, dataType: OperationNode): CastNode;
+}>;

package/dist/esm/operation-node/cast-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./cast-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const CastNode = freeze({
+    is(node) {
+        return node.kind === 'CastNode';
+    },
+    create(expression, dataType) {
+        return freeze({
+            kind: 'CastNode',
+            expression,
+            dataType,
+        });
+    },
+});

package/dist/esm/operation-node/column-definition-node.d.ts

@@ -21,6 +21,7 @@ export interface ColumnDefinitionNode extends OperationNode {
     readonly frontModifiers?: ReadonlyArray<OperationNode>;
     readonly endModifiers?: ReadonlyArray<OperationNode>;
     readonly nullsNotDistinct?: boolean;
+    readonly identity?: boolean;
 }
 /**
  * @internal

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

@@ -1,5 +1,7 @@
 import { OperationNode } from './operation-node.js';
-export type ColumnDataType = 'varchar' | `varchar(${number})` | 'char' | `char(${number})` | 'text' | 'integer' | 'int2' | 'int4' | 'int8' | 'bigint' | 'boolean' | 'real' | 'double precision' | 'float4' | 'float8' | 'decimal' | `decimal(${number}, ${number})` | 'numeric' | `numeric(${number}, ${number})` | 'binary' | `binary(${number})` | 'bytea' | 'date' | 'datetime' | `datetime(${number})` | 'time' | `time(${number})` | 'timetz' | `timetz(${number})` | 'timestamp' | `timestamp(${number})` | 'timestamptz' | `timestamptz(${number})` | 'serial' | 'bigserial' | 'uuid' | 'json' | 'jsonb' | 'blob';
+declare const SIMPLE_COLUMN_DATA_TYPES: readonly ["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", "blob"];
+type SimpleColumnDataType = (typeof SIMPLE_COLUMN_DATA_TYPES)[number];
+export type ColumnDataType = SimpleColumnDataType | `varchar(${number})` | `char(${number})` | `decimal(${number}, ${number})` | `numeric(${number}, ${number})` | `binary(${number})` | `datetime(${number})` | `time(${number})` | `timetz(${number})` | `timestamp(${number})` | `timestamptz(${number})`;
 export type DataTypeParams = Omit<DataTypeNode, 'kind' | 'dataType'>;
 export interface DataTypeNode extends OperationNode {
     readonly kind: 'DataTypeNode';
@@ -12,3 +14,5 @@ export declare const DataTypeNode: Readonly<{
     is(node: OperationNode): node is DataTypeNode;
     create(dataType: ColumnDataType): DataTypeNode;
 }>;
+export declare function isColumnDataType(dataType: string): dataType is ColumnDataType;
+export {};

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

@@ -1,5 +1,49 @@
 /// <reference types="./data-type-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
+const SIMPLE_COLUMN_DATA_TYPES = [
+    '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',
+    'blob',
+];
+const COLUMN_DATA_TYPE_REGEX = [
+    /^varchar\(\d+\)$/,
+    /^char\(\d+\)$/,
+    /^decimal\(\d+, \d+\)$/,
+    /^numeric\(\d+, \d+\)$/,
+    /^binary\(\d+\)$/,
+    /^datetime\(\d+\)$/,
+    /^time\(\d+\)$/,
+    /^timez\(\d+\)$/,
+    /^timestamp\(\d+\)$/,
+    /^timestamptz\(\d+\)$/,
+];
 /**
  * @internal
  */
@@ -14,3 +58,12 @@ export const DataTypeNode = freeze({
         });
     },
 });
+export function isColumnDataType(dataType) {
+    if (SIMPLE_COLUMN_DATA_TYPES.includes(dataType)) {
+        return true;
+    }
+    if (COLUMN_DATA_TYPE_REGEX.some((r) => r.test(dataType))) {
+        return true;
+    }
+    return false;
+}

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

@@ -9,6 +9,7 @@ import { OrderByNode } from './order-by-node.js';
 import { OrderByItemNode } from './order-by-item-node.js';
 import { ExplainNode } from './explain-node.js';
 import { UsingNode } from './using-node.js';
+import { TopNode } from './top-node.js';
 export interface DeleteQueryNode extends OperationNode {
     readonly kind: 'DeleteQueryNode';
     readonly from: FromNode;
@@ -20,6 +21,7 @@ export interface DeleteQueryNode extends OperationNode {
     readonly orderBy?: OrderByNode;
     readonly limit?: LimitNode;
     readonly explain?: ExplainNode;
+    readonly top?: TopNode;
 }
 /**
  * @internal
@@ -28,6 +30,8 @@ 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;
     cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
+    cloneWithoutLimit(deleteNode: DeleteQueryNode): DeleteQueryNode;
     cloneWithUsing(deleteNode: DeleteQueryNode, tables: OperationNode[]): DeleteQueryNode;
 }>;

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

@@ -25,12 +25,24 @@ export const DeleteQueryNode = freeze({
                 : OrderByNode.create(items),
         });
     },
+    cloneWithoutOrderBy(deleteNode) {
+        return freeze({
+            ...deleteNode,
+            orderBy: undefined,
+        });
+    },
     cloneWithLimit(deleteNode, limit) {
         return freeze({
             ...deleteNode,
             limit,
         });
     },
+    cloneWithoutLimit(deleteNode) {
+        return freeze({
+            ...deleteNode,
+            limit: undefined,
+        });
+    },
     cloneWithUsing(deleteNode, tables) {
         return freeze({
             ...deleteNode,

package/dist/esm/operation-node/fetch-node.d.ts

@@ -0,0 +1,15 @@
+import { OperationNode } from './operation-node.js';
+import { ValueNode } from './value-node.js';
+export type FetchModifier = 'only' | 'with ties';
+export interface FetchNode extends OperationNode {
+    readonly kind: 'FetchNode';
+    readonly rowCount: ValueNode;
+    readonly modifier: FetchModifier;
+}
+/**
+ * @internal
+ */
+export declare const FetchNode: {
+    is(node: OperationNode): node is FetchNode;
+    create(rowCount: number | bigint, modifier: FetchModifier): FetchNode;
+};

package/dist/esm/operation-node/fetch-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./fetch-node.d.ts" />
+import { ValueNode } from './value-node.js';
+/**
+ * @internal
+ */
+export const FetchNode = {
+    is(node) {
+        return node.kind === 'FetchNode';
+    },
+    create(rowCount, modifier) {
+        return {
+            kind: 'FetchNode',
+            rowCount: ValueNode.create(rowCount),
+            modifier,
+        };
+    },
+};

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

@@ -5,11 +5,12 @@ import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { OperationNode } from './operation-node.js';
 import { ReturningNode } from './returning-node.js';
 import { TableNode } from './table-node.js';
+import { TopNode } from './top-node.js';
 import { WithNode } from './with-node.js';
 export type InsertQueryNodeProps = Omit<InsertQueryNode, 'kind' | 'into'>;
 export interface InsertQueryNode extends OperationNode {
     readonly kind: 'InsertQueryNode';
-    readonly into: TableNode;
+    readonly into?: TableNode;
     readonly columns?: ReadonlyArray<ColumnNode>;
     readonly values?: OperationNode;
     readonly returning?: ReturningNode;
@@ -20,6 +21,7 @@ export interface InsertQueryNode extends OperationNode {
     readonly replace?: boolean;
     readonly explain?: ExplainNode;
     readonly defaultValues?: boolean;
+    readonly top?: TopNode;
 }
 /**
  * @internal
@@ -27,5 +29,6 @@ export interface InsertQueryNode extends OperationNode {
 export declare const InsertQueryNode: Readonly<{
     is(node: OperationNode): node is InsertQueryNode;
     create(into: TableNode, withNode?: WithNode, replace?: boolean): InsertQueryNode;
+    createWithoutInto(): InsertQueryNode;
     cloneWith(insertQuery: InsertQueryNode, props: InsertQueryNodeProps): InsertQueryNode;
 }>;

package/dist/esm/operation-node/insert-query-node.js

@@ -15,6 +15,11 @@ export const InsertQueryNode = freeze({
             replace,
         });
     },
+    createWithoutInto() {
+        return freeze({
+            kind: 'InsertQueryNode',
+        });
+    },
     cloneWith(insertQuery, props) {
         return freeze({
             ...insertQuery,

package/dist/esm/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';
+export type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin' | 'LateralInnerJoin' | 'LateralLeftJoin' | 'Using';
 export interface JoinNode extends OperationNode {
     readonly kind: 'JoinNode';
     readonly joinType: JoinType;

package/dist/esm/operation-node/matched-node.d.ts

@@ -0,0 +1,13 @@
+import { OperationNode } from './operation-node.js';
+export interface MatchedNode extends OperationNode {
+    readonly kind: 'MatchedNode';
+    readonly not: boolean;
+    readonly bySource: boolean;
+}
+/**
+ * @internal
+ */
+export declare const MatchedNode: Readonly<{
+    is(node: OperationNode): node is MatchedNode;
+    create(not: boolean, bySource?: boolean): MatchedNode;
+}>;

package/dist/esm/operation-node/matched-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./matched-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const MatchedNode = freeze({
+    is(node) {
+        return node.kind === 'MatchedNode';
+    },
+    create(not, bySource = false) {
+        return freeze({
+            kind: 'MatchedNode',
+            not,
+            bySource,
+        });
+    },
+});

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

@@ -0,0 +1,25 @@
+import { AliasNode } from './alias-node.js';
+import { JoinNode } from './join-node.js';
+import { OperationNode } from './operation-node.js';
+import { TableNode } from './table-node.js';
+import { TopNode } from './top-node.js';
+import { WhenNode } from './when-node.js';
+import { WithNode } from './with-node.js';
+export interface MergeQueryNode extends OperationNode {
+    readonly kind: 'MergeQueryNode';
+    readonly into: TableNode | AliasNode;
+    readonly using?: JoinNode;
+    readonly whens?: ReadonlyArray<WhenNode>;
+    readonly with?: WithNode;
+    readonly top?: TopNode;
+}
+/**
+ * @internal
+ */
+export declare const MergeQueryNode: Readonly<{
+    is(node: OperationNode): node is MergeQueryNode;
+    create(into: TableNode | AliasNode, withNode?: WithNode): MergeQueryNode;
+    cloneWithUsing(mergeNode: MergeQueryNode, using: JoinNode): MergeQueryNode;
+    cloneWithWhen(mergeNode: MergeQueryNode, when: WhenNode): MergeQueryNode;
+    cloneWithThen(mergeNode: MergeQueryNode, then: OperationNode): MergeQueryNode;
+}>;

package/dist/esm/operation-node/merge-query-node.js

@@ -0,0 +1,43 @@
+/// <reference types="./merge-query-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { WhenNode } from './when-node.js';
+/**
+ * @internal
+ */
+export const MergeQueryNode = freeze({
+    is(node) {
+        return node.kind === 'MergeQueryNode';
+    },
+    create(into, withNode) {
+        return freeze({
+            kind: 'MergeQueryNode',
+            into,
+            ...(withNode && { with: withNode }),
+        });
+    },
+    cloneWithUsing(mergeNode, using) {
+        return freeze({
+            ...mergeNode,
+            using,
+        });
+    },
+    cloneWithWhen(mergeNode, when) {
+        return freeze({
+            ...mergeNode,
+            whens: mergeNode.whens
+                ? freeze([...mergeNode.whens, when])
+                : freeze([when]),
+        });
+    },
+    cloneWithThen(mergeNode, then) {
+        return freeze({
+            ...mergeNode,
+            whens: mergeNode.whens
+                ? freeze([
+                    ...mergeNode.whens.slice(0, -1),
+                    WhenNode.cloneWithResult(mergeNode.whens[mergeNode.whens.length - 1], then),
+                ])
+                : undefined,
+        });
+    },
+});

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

@@ -85,7 +85,12 @@ import { JSONPathNode } from './json-path-node.js';
 import { JSONPathLegNode } from './json-path-leg-node.js';
 import { JSONOperatorChainNode } from './json-operator-chain-node.js';
 import { TupleNode } from './tuple-node.js';
+import { MergeQueryNode } from './merge-query-node.js';
+import { MatchedNode } from './matched-node.js';
 import { AddIndexNode } from './add-index-node.js';
+import { CastNode } from './cast-node.js';
+import { FetchNode } from './fetch-node.js';
+import { TopNode } from './top-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -200,7 +205,12 @@ export declare class OperationNodeTransformer {
     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 transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;