kysely 0.28.17 → 0.29.0

package/dist/readonly/readonly-kysely.d.ts

@@ -0,0 +1,230 @@
+import type { IsolationLevel } from '../driver/driver.js';
+import type { Command, ConnectionBuilder, ControlledTransaction, Kysely, Transaction } from '../kysely.js';
+import type { ReleaseSavepoint, RollbackToSavepoint } from '../parser/savepoint-parser.js';
+import type { KyselyPlugin } from '../plugin/kysely-plugin.js';
+import type { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import type { AbortableOperationOptions, AbortableQueryOptions } from '../util/abort.js';
+import type { KyselyTypeError } from '../util/type-error.js';
+import type { DrainOuterGeneric } from '../util/type-utils.js';
+import type { ReadonlyCompiledQuery } from './readonly-compiled-query.js';
+import type { ReadonlyQueryResult } from './readonly-database-connection.js';
+import type { ReadonlyAccessMode } from './readonly-driver.js';
+import type { ReadonlyQueryCreator } from './readonly-query-creator.js';
+/**
+ * A helper type that allows you to expose a type-level read-only {@link Kysely} version
+ * to your service's consumers.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * import * as Sqlite from 'better-sqlite3'
+ * import { type Generated, Kysely, SqliteDialect } from 'kysely'
+ * import type { ReadonlyKysely } from 'kysely/readonly'
+ *
+ * interface Database {
+ *   person: {
+ *     id: Generated<number>
+ *     first_name: string
+ *     last_name: string | null
+ *   }
+ * }
+ *
+ * function getDB(): ReadonlyKysely<Database> {
+ *   return new Kysely({
+ *     dialect: new SqliteDialect({
+ *       database: new Sqlite(':memory:'),
+ *     })
+ *   }) as never
+ * }
+ *
+ * const db = getDB()
+ *
+ * db.selectFrom('person') // works!
+ * db.deleteFrom('person') // typescript compiler error!
+ * ```
+ */
+export interface ReadonlyKysely<DB> extends ReadonlyQueryCreator<DB>, Pick<Kysely<DB>, 'case' | 'destroy' | 'dynamic' | 'fn' | 'introspection' | 'isTransaction'> {
+    /**
+     * Similar to {@link Kysely.connection} but read-only.
+     */
+    connection(): ReadonlyConnectionBuilder<DB>;
+    /**
+     * Similar to {@link Kysely.executeQuery} but read-only.
+     */
+    executeQuery<R>(query: ReadonlyCompiledQuery<R> | SelectQueryBuilder<DB, any, R>, options?: AbortableQueryOptions): Promise<ReadonlyQueryResult<R>>;
+    /**
+     * @deprecated not allowed with a read-only Kysely instance.
+     */
+    executeQuery(...args: any[]): KyselyTypeError<'not allowed with a read-only Kysely instance.'>;
+    /**
+     * @deprecated not allowed with a read-only Kysely instance.
+     */
+    getExecutor(...args: any[]): KyselyTypeError<'not allowed with a read-only Kysely instance.'>;
+    /**
+     * @deprecated not allowed with a read-only Kysely instance.
+     */
+    get schema(): KyselyTypeError<'not allowed with a read-only Kysely instance.'>;
+    /**
+     * Similar to {@link Kysely.transaction} but read-only.
+     */
+    transaction(): ReadonlyTransactionBuilder<DB>;
+    /**
+     * Similar to {@link Kysely.startTransaction} but read-only.
+     */
+    startTransaction(): ReadonlyControlledTransactionBuilder<DB>;
+    /**
+     * Similar to {@link Kysely.withoutPlugins} but read-only.
+     */
+    withoutPlugins(): ReadonlyKysely<DB>;
+    /**
+     * Similar to {@link Kysely.withPlugin} but read-only.
+     */
+    withPlugin(plugin: KyselyPlugin): ReadonlyKysely<DB>;
+    /**
+     * Similar to {@link Kysely.withSchema} but read-only.
+     */
+    withSchema(schema: string): ReadonlyKysely<DB>;
+    /**
+     * Similar to {@link Kysely.withTables} but read-only.
+     *
+     * @deprecated use {@link $extendTables} instead.
+     */
+    withTables<T extends Record<string, Record<string, any>>>(): ReadonlyKysely<DrainOuterGeneric<DB & T>>;
+    /**
+     * Similar to {@link Kysely.$extendTables} but read-only.
+     */
+    $extendTables<T extends Record<string, Record<string, any>>>(): ReadonlyKysely<DrainOuterGeneric<DB & T>>;
+    /**
+     * Similar to {@link Kysely.$omitTables} but read-only.
+     */
+    $omitTables<T extends keyof DB>(): ReadonlyKysely<DB extends object ? Omit<DB, T> : DB>;
+    /**
+     * Similar to {@link Kysely.$pickTables} but read-only.
+     */
+    $pickTables<T extends keyof DB>(): ReadonlyKysely<DB extends object ? Pick<DB, T> : DB>;
+}
+/**
+ * Similar to {@link ConnectionBuilder} but read-only.
+ */
+export interface ReadonlyConnectionBuilder<DB> extends Omit<ConnectionBuilder<DB>, 'execute'> {
+    /**
+     * Similar to {@link ConnectionBuilder.execute} but read-only.
+     */
+    execute<T>(callback: (db: ReadonlyKysely<DB>) => Promise<T>, options?: AbortableOperationOptions): Promise<T>;
+}
+/**
+ * Similar to {@link TransactionBuilder} but read-only.
+ */
+export interface ReadonlyTransactionBuilder<DB> {
+    /**
+     * Similar to {@link TransactionBuilder.execute} but read-only.
+     */
+    execute<T>(callback: (trx: ReadonlyTransaction<DB>) => Promise<T>): Promise<T>;
+    /**
+     * Similar to {@link TransactionBuilder.setAccessMode} but read-only.
+     */
+    setAccessMode(accessMode: ReadonlyAccessMode): ReadonlyTransactionBuilder<DB>;
+    /**
+     * Similar to {@link TransactionBuilder.setIsolationLevel} but read-only.
+     */
+    setIsolationLevel(isolationLevel: IsolationLevel): ReadonlyTransactionBuilder<DB>;
+}
+/**
+ * Similar to {@link Transaction} but read-only.
+ */
+export interface ReadonlyTransaction<DB> extends Pick<ReadonlyKysely<DB>, 'case' | 'deleteFrom' | 'dynamic' | 'executeQuery' | 'fn' | 'getExecutor' | 'insertInto' | 'introspection' | 'mergeInto' | 'replaceInto' | 'schema' | 'selectFrom' | 'selectNoFrom' | 'updateTable' | 'with' | 'withRecursive'>, Pick<Transaction<DB>, 'connection' | 'destroy' | 'isTransaction' | 'startTransaction' | 'transaction'> {
+    /**
+     * Similar to {@link Transaction.withoutPlugins} but read-only.
+     */
+    withoutPlugins(): ReadonlyTransaction<DB>;
+    /**
+     * Similar to {@link Transaction.withPlugin} but read-only.
+     */
+    withPlugin(plugin: KyselyPlugin): ReadonlyTransaction<DB>;
+    /**
+     * Similar to {@link Transaction.withSchema} but read-only.
+     */
+    withSchema(schema: string): ReadonlyTransaction<DB>;
+    /**
+     * Similar to {@link Transaction.withTables} but read-only.
+     *
+     * @deprecated use {@link $extendTables} instead.
+     */
+    withTables<T extends Record<string, Record<string, any>>>(): ReadonlyTransaction<DrainOuterGeneric<DB & T>>;
+    /**
+     * Similar to {@link Transaction.$extendTables} but read-only.
+     */
+    $extendTables<T extends Record<string, Record<string, any>>>(): ReadonlyTransaction<DrainOuterGeneric<DB & T>>;
+    /**
+     * Similar to {@link Transaction.$omitTables} but read-only.
+     */
+    $omitTables<T extends keyof DB>(): ReadonlyTransaction<DB extends object ? Omit<DB, T> : DB>;
+    /**
+     * Similar to {@link Transaction.$pickTables} but read-only.
+     */
+    $pickTables<T extends keyof DB>(): ReadonlyTransaction<DB extends object ? Pick<DB, T> : DB>;
+}
+/**
+ * Similar to {@link ControlledTransactionBuilder} but read-only.
+ */
+export interface ReadonlyControlledTransactionBuilder<DB> {
+    /**
+     * Similar to {@link ControlledTransactionBuilder.execute} but read-only.
+     */
+    execute(): Promise<ReadonlyControlledTransaction<DB>>;
+    /**
+     * Similar to {@link ControlledTransactionBuilder.setAccessMode} but read-only.
+     */
+    setAccessMode(accessMode: ReadonlyAccessMode): ReadonlyControlledTransactionBuilder<DB>;
+    /**
+     * Similar to {@link ControlledTransactionBuilder.setIsolationLevel} but read-only.
+     */
+    setIsolationLevel(isolationLevel: IsolationLevel): ReadonlyControlledTransactionBuilder<DB>;
+}
+/**
+ * Similar to {@link ControlledTransaction} but read-only.
+ */
+export interface ReadonlyControlledTransaction<DB, S extends string[] = []> extends ReadonlyTransaction<DB>, Pick<ControlledTransaction<DB, S>, 'commit' | 'isCommitted' | 'isRolledBack' | 'rollback'> {
+    /**
+     * Similar to {@link ControlledTransaction.releaseSavepoint} but read-only.
+     */
+    releaseSavepoint<SN extends S[number]>(savepointName: SN): ReleaseSavepoint<S, SN> extends string[] ? Command<ReadonlyControlledTransaction<DB, ReleaseSavepoint<S, SN>>> : never;
+    /**
+     * Similar to {@link ControlledTransaction.rollbackToSavepoint} but read-only.
+     */
+    rollbackToSavepoint<SN extends S[number]>(savepointName: SN): RollbackToSavepoint<S, SN> extends string[] ? Command<ReadonlyControlledTransaction<DB, RollbackToSavepoint<S, SN>>> : never;
+    /**
+     * Similar to {@link ControlledTransaction.savepoint} but read-only.
+     */
+    savepoint<SN extends string>(savepointName: SN extends S ? never : SN): Command<ReadonlyControlledTransaction<DB, [...S, SN]>>;
+    /**
+     * Similar to {@link ControlledTransaction.withoutPlugins} but read-only.
+     */
+    withoutPlugins(): ReadonlyControlledTransaction<DB, S>;
+    /**
+     * Similar to {@link ControlledTransaction.withPlugin} but read-only.
+     */
+    withPlugin(plugin: KyselyPlugin): ReadonlyControlledTransaction<DB, S>;
+    /**
+     * Similar to {@link ControlledTransaction.withSchema} but read-only.
+     */
+    withSchema(schema: string): ReadonlyControlledTransaction<DB, S>;
+    /**
+     * Similar to {@link ControlledTransaction.withTables} but read-only.
+     *
+     * @deprecated use {@link $extendTables} instead.
+     */
+    withTables<T extends Record<string, Record<string, any>>>(): ReadonlyControlledTransaction<DrainOuterGeneric<DB & T>, S>;
+    /**
+     * Similar to {@link ControlledTransaction.$extendTables} but read-only.
+     */
+    $extendTables<T extends Record<string, Record<string, any>>>(): ReadonlyControlledTransaction<DrainOuterGeneric<DB & T>, S>;
+    /**
+     * Similar to {@link ControlledTransaction.$omitTables} but read-only.
+     */
+    $omitTables<T extends keyof DB>(): ReadonlyControlledTransaction<DB extends object ? Omit<DB, T> : DB, S>;
+    /**
+     * Similar to {@link ControlledTransaction.$pickTables} but read-only.
+     */
+    $pickTables<T extends keyof DB>(): ReadonlyControlledTransaction<DB extends object ? Pick<DB, T> : DB, S>;
+}

package/dist/readonly/readonly-kysely.js

@@ -0,0 +1,2 @@
+/// <reference types="./readonly-kysely.d.ts" />
+export {};

package/dist/readonly/readonly-query-creator.d.ts

@@ -0,0 +1,37 @@
+import type { CTEBuilderCallback } from '../query-builder/cte-builder.js';
+import type { QueryCreator } from '../query-creator.js';
+import type { KyselyTypeError } from '../util/type-error.js';
+import type { ReadonlyCommonTableExpression, ReadonlyQueryCreatorWithCommonTableExpression, ReadonlyRecursiveCommonTableExpression } from './readonly-with-parser.js';
+/**
+ * Similar to {@link QueryCreator} but read-only.
+ */
+export interface ReadonlyQueryCreator<DB> extends Pick<QueryCreator<DB>, 'selectFrom' | 'selectNoFrom'> {
+    /**
+     * @deprecated not allowed with a read-only Kysely instance.
+     */
+    deleteFrom(...args: any[]): KyselyTypeError<'not allowed with a read-only Kysely instance.'>;
+    /**
+     * @deprecated not allowed with a read-only Kysely instance.
+     */
+    insertInto(...args: any[]): KyselyTypeError<'not allowed with a read-only Kysely instance.'>;
+    /**
+     * @deprecated not allowed with a read-only Kysely instance.
+     */
+    mergeInto(...args: any[]): KyselyTypeError<'not allowed with a read-only Kysely instance.'>;
+    /**
+     * @deprecated not allowed with a read-only Kysely instance.
+     */
+    replaceInto(...args: any[]): KyselyTypeError<'not allowed with a read-only Kysely instance.'>;
+    /**
+     * @deprecated not allowed with a read-only Kysely instance.
+     */
+    updateTable(...args: any[]): KyselyTypeError<'not allowed with a read-only Kysely instance.'>;
+    /**
+     * Similar to {@link QueryCreator.with} but read-only.
+     */
+    with<N extends string, E extends ReadonlyCommonTableExpression<DB, N>>(nameOrBuilder: N | CTEBuilderCallback<N>, expression: E): ReadonlyQueryCreatorWithCommonTableExpression<DB, N, E>;
+    /**
+     * Similar to {@link QueryCreator.withRecursive} but read-only.
+     */
+    withRecursive<N extends string, E extends ReadonlyRecursiveCommonTableExpression<DB, N>>(nameOrBuilder: N | CTEBuilderCallback<N>, expression: E): ReadonlyQueryCreatorWithCommonTableExpression<DB, N, E>;
+}

package/dist/readonly/readonly-query-creator.js

@@ -0,0 +1,2 @@
+/// <reference types="./readonly-query-creator.d.ts" />
+export {};

package/dist/readonly/readonly-with-parser.d.ts

@@ -0,0 +1,32 @@
+import type { Expression } from '../expression/expression.js';
+import type { ExtractRowFromCommonTableExpressionName, ExtractTableFromCommonTableExpressionName } from '../parser/with-parser.js';
+import type { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import type { ReadonlyQueryCreator } from './readonly-query-creator.js';
+/**
+ * Similar to {@link CommonTableExpression} but read-only.
+ */
+export type ReadonlyCommonTableExpression<DB, CN> = ReadonlyCommonTableExpressionOutput<DB, CN> | ReadonlyCommonTableExpressionFactory<DB, CN>;
+/**
+ * Similar to {@link CommonTableExpressionFactory} but read-only.
+ */
+export type ReadonlyCommonTableExpressionFactory<DB, CN> = (creator: ReadonlyQueryCreator<DB>) => ReadonlyCommonTableExpressionOutput<DB, CN>;
+/**
+ * Similar to {@link RecursiveCommonTableExpression} but read-only.
+ */
+export type ReadonlyRecursiveCommonTableExpression<DB, CN extends string> = (creator: ReadonlyQueryCreator<DB & {
+    [K in ExtractTableFromCommonTableExpressionName<CN>]: ExtractRowFromCommonTableExpressionName<CN>;
+}>) => ReadonlyCommonTableExpressionOutput<DB, CN>;
+/**
+ * Similar to {@link CommonTableExpressionOutput} but read-only.
+ */
+export type ReadonlyCommonTableExpressionOutput<DB, CN> = SelectQueryBuilder<DB, any, any> | Expression<ExtractRowFromCommonTableExpressionName<CN>>;
+/**
+ * Similar to {@link QueryCreatorWithCommonTableExpression} but read-only.
+ */
+export type ReadonlyQueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = ReadonlyQueryCreator<DB & {
+    [K in ExtractTableFromCommonTableExpressionName<CN>]: ReadonlyExtractRowFromCommonTableExpression<CTE>;
+}>;
+/**
+ * Similar to {@link ExtractRowFromCommonTableExpression} but read-only.
+ */
+export type ReadonlyExtractRowFromCommonTableExpression<CTE> = CTE extends Expression<infer O> ? O : CTE extends (creator: ReadonlyQueryCreator<any>) => infer Q ? Q extends Expression<infer O> ? O : never : never;

package/dist/readonly/readonly-with-parser.js

@@ -0,0 +1,2 @@
+/// <reference types="./readonly-with-parser.d.ts" />
+export {};

package/dist/schema/alter-table-add-foreign-key-constraint-builder.d.ts

@@ -0,0 +1,33 @@
+import { AlterTableNode } from '../operation-node/alter-table-node.js';
+import type { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import type { OnModifyForeignAction } from '../operation-node/references-node.js';
+import type { CompiledQuery } from '../query-compiler/compiled-query.js';
+import type { QueryExecutor } from '../query-executor/query-executor.js';
+import type { AbortableQueryOptions } from '../util/abort.js';
+import type { Compilable } from '../util/compilable.js';
+import type { QueryId } from '../util/query-id.js';
+import type { ForeignKeyConstraintBuilder, ForeignKeyConstraintBuilderInterface } from './foreign-key-constraint-builder.js';
+export declare class AlterTableAddForeignKeyConstraintBuilder implements ForeignKeyConstraintBuilderInterface<AlterTableAddForeignKeyConstraintBuilder>, OperationNodeSource, Compilable {
+    #private;
+    constructor(props: AlterTableAddForeignKeyConstraintBuilderProps);
+    onDelete(onDelete: OnModifyForeignAction): AlterTableAddForeignKeyConstraintBuilder;
+    onUpdate(onUpdate: OnModifyForeignAction): AlterTableAddForeignKeyConstraintBuilder;
+    deferrable(): AlterTableAddForeignKeyConstraintBuilder;
+    notDeferrable(): AlterTableAddForeignKeyConstraintBuilder;
+    initiallyDeferred(): AlterTableAddForeignKeyConstraintBuilder;
+    initiallyImmediate(): AlterTableAddForeignKeyConstraintBuilder;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(options?: AbortableQueryOptions): Promise<void>;
+}
+export interface AlterTableAddForeignKeyConstraintBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly node: AlterTableNode;
+    readonly constraintBuilder: ForeignKeyConstraintBuilder;
+}

package/dist/schema/alter-table-add-foreign-key-constraint-builder.js

@@ -0,0 +1,64 @@
+/// <reference types="./alter-table-add-foreign-key-constraint-builder.d.ts" />
+import { AddConstraintNode } from '../operation-node/add-constraint-node.js';
+import { AlterTableNode } from '../operation-node/alter-table-node.js';
+import { freeze } from '../util/object-utils.js';
+export class AlterTableAddForeignKeyConstraintBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    onDelete(onDelete) {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.onDelete(onDelete),
+        });
+    }
+    onUpdate(onUpdate) {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.onUpdate(onUpdate),
+        });
+    }
+    deferrable() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.deferrable(),
+        });
+    }
+    notDeferrable() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.notDeferrable(),
+        });
+    }
+    initiallyDeferred() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.initiallyDeferred(),
+        });
+    }
+    initiallyImmediate() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.initiallyImmediate(),
+        });
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(AlterTableNode.cloneWithTableProps(this.#props.node, {
+            addConstraint: AddConstraintNode.create(this.#props.constraintBuilder.toOperationNode()),
+        }), this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute(options) {
+        await this.#props.executor.executeQuery(this.compile(), options);
+    }
+}

package/dist/schema/alter-table-add-index-builder.d.ts

@@ -0,0 +1,157 @@
+import type { Expression } from '../expression/expression.js';
+import { AlterTableNode } from '../operation-node/alter-table-node.js';
+import type { IndexType } from '../operation-node/create-index-node.js';
+import type { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { type OrderedColumnName } from '../parser/reference-parser.js';
+import type { CompiledQuery } from '../query-compiler/compiled-query.js';
+import type { QueryExecutor } from '../query-executor/query-executor.js';
+import type { AbortableQueryOptions } from '../util/abort.js';
+import type { Compilable } from '../util/compilable.js';
+import type { QueryId } from '../util/query-id.js';
+export declare class AlterTableAddIndexBuilder implements OperationNodeSource, Compilable {
+    #private;
+    constructor(props: AlterTableAddIndexBuilderProps);
+    /**
+     * Makes the index unique.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .alterTable('person')
+     *   .addIndex('person_first_name_index')
+     *   .unique()
+     *   .column('email')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` add unique index `person_first_name_index` (`email`)
+     * ```
+     */
+    unique(): AlterTableAddIndexBuilder;
+    /**
+     * Adds a column to the index.
+     *
+     * Also see {@link columns} for adding multiple columns at once or {@link expression}
+     * for specifying an arbitrary expression.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * await db.schema
+     *   .alterTable('person')
+     *   .addIndex('person_first_name_and_age_index')
+     *   .column('first_name')
+     *   .column(sql`(left(lower(last_name), 1))`)
+     *   .column('age desc')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person`
+     * add index `person_first_name_and_age_index` (
+     *   `first_name`,
+     *   (left(lower(last_name), 1)),
+     *   `age` desc
+     * )
+     * ```
+     */
+    column<CL extends string>(column: OrderedColumnName<CL>): AlterTableAddIndexBuilder;
+    column(expression: Expression<any>): AlterTableAddIndexBuilder;
+    /**
+     * Specifies a list of columns for the index.
+     *
+     * Also see {@link column} for adding a single column or {@link expression} for
+     * specifying an arbitrary expression.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * await db.schema
+     *   .alterTable('person')
+     *   .addIndex('person_first_name_and_age_index')
+     *   .columns(['first_name', sql`(left(lower(last_name), 1))`, 'age desc'])
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person`
+     * add index `person_first_name_and_age_index` (
+     *   `first_name`,
+     *   (left(lower(last_name), 1)),
+     *   `age` desc
+     * )
+     * ```
+     */
+    columns<CL extends string>(columns: (OrderedColumnName<CL> | Expression<any>)[]): AlterTableAddIndexBuilder;
+    /**
+     * Specifies an arbitrary expression for the index.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * await db.schema
+     *   .alterTable('person')
+     *   .addIndex('person_first_name_index')
+     *   .expression(sql<boolean>`(first_name < 'Sami')`)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` add index `person_first_name_index` ((first_name < 'Sami'))
+     * ```
+     *
+     * @deprecated Use {@link column} or {@link columns} with an {@link Expression} instead.
+     */
+    expression(expression: Expression<any>): AlterTableAddIndexBuilder;
+    /**
+     * Specifies the index type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .alterTable('person')
+     *   .addIndex('person_first_name_index')
+     *   .column('first_name')
+     *   .using('hash')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` add index `person_first_name_index` (`first_name`) using hash
+     * ```
+     */
+    using(indexType: IndexType): AlterTableAddIndexBuilder;
+    using(indexType: string): AlterTableAddIndexBuilder;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(options?: AbortableQueryOptions): Promise<void>;
+}
+export interface AlterTableAddIndexBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly node: AlterTableNode;
+}