zen-code 1.0.0

package/dist/kysely-Bchvsze0.mjs

@@ -0,0 +1,4316 @@
+import { bb as r, ah as m, aV as G, a2 as x, b6 as ae, aw as Fe, bk as Ue, aW as ze, bl as H, bm as ce, aS as ke, bn as E, bo as w, ax as Ge, b5 as qe, aR as He, bp as Je, bq as Pe, br as Ye, c as d, V as pe, K as je, P as Xe, bs as Ze, bj as Ne, bi as V, Q as Ke, C as Be, $ as _e, bt as et, g as tt, l as rt, bu as nt } from "./sql-CJsUpKEQ.mjs";
+const s = r({
+  is(t) {
+    return t.kind === "AlterTableNode";
+  },
+  create(t) {
+    return r({
+      kind: "AlterTableNode",
+      table: t
+    });
+  },
+  cloneWithTableProps(t, e) {
+    return r({
+      ...t,
+      ...e
+    });
+  },
+  cloneWithColumnAlteration(t, e) {
+    return r({
+      ...t,
+      columnAlterations: t.columnAlterations ? [...t.columnAlterations, e] : [e]
+    });
+  }
+}), O = r({
+  is(t) {
+    return t.kind === "CreateIndexNode";
+  },
+  create(t) {
+    return r({
+      kind: "CreateIndexNode",
+      name: m.create(t)
+    });
+  },
+  cloneWith(t, e) {
+    return r({
+      ...t,
+      ...e
+    });
+  },
+  cloneWithColumns(t, e) {
+    return r({
+      ...t,
+      columns: [...t.columns || [], ...e]
+    });
+  }
+}), ve = r({
+  is(t) {
+    return t.kind === "CreateSchemaNode";
+  },
+  create(t, e) {
+    return r({
+      kind: "CreateSchemaNode",
+      schema: m.create(t),
+      ...e
+    });
+  },
+  cloneWith(t, e) {
+    return r({
+      ...t,
+      ...e
+    });
+  }
+}), it = ["preserve rows", "delete rows", "drop"], p = r({
+  is(t) {
+    return t.kind === "CreateTableNode";
+  },
+  create(t) {
+    return r({
+      kind: "CreateTableNode",
+      table: t,
+      columns: r([])
+    });
+  },
+  cloneWithColumn(t, e) {
+    return r({
+      ...t,
+      columns: r([...t.columns, e])
+    });
+  },
+  cloneWithConstraint(t, e) {
+    return r({
+      ...t,
+      constraints: t.constraints ? r([...t.constraints, e]) : r([e])
+    });
+  },
+  cloneWithFrontModifier(t, e) {
+    return r({
+      ...t,
+      frontModifiers: t.frontModifiers ? r([...t.frontModifiers, e]) : r([e])
+    });
+  },
+  cloneWithEndModifier(t, e) {
+    return r({
+      ...t,
+      endModifiers: t.endModifiers ? r([...t.endModifiers, e]) : r([e])
+    });
+  },
+  cloneWith(t, e) {
+    return r({
+      ...t,
+      ...e
+    });
+  }
+}), Z = r({
+  is(t) {
+    return t.kind === "DropIndexNode";
+  },
+  create(t, e) {
+    return r({
+      kind: "DropIndexNode",
+      name: G.create(t),
+      ...e
+    });
+  },
+  cloneWith(t, e) {
+    return r({
+      ...t,
+      ...e
+    });
+  }
+}), ye = r({
+  is(t) {
+    return t.kind === "DropSchemaNode";
+  },
+  create(t, e) {
+    return r({
+      kind: "DropSchemaNode",
+      schema: m.create(t),
+      ...e
+    });
+  },
+  cloneWith(t, e) {
+    return r({
+      ...t,
+      ...e
+    });
+  }
+}), fe = r({
+  is(t) {
+    return t.kind === "DropTableNode";
+  },
+  create(t, e) {
+    return r({
+      kind: "DropTableNode",
+      table: t,
+      ...e
+    });
+  },
+  cloneWith(t, e) {
+    return r({
+      ...t,
+      ...e
+    });
+  }
+}), Ee = r({
+  is(t) {
+    return t.kind === "AddColumnNode";
+  },
+  create(t) {
+    return r({
+      kind: "AddColumnNode",
+      column: t
+    });
+  }
+}), c = r({
+  is(t) {
+    return t.kind === "ColumnDefinitionNode";
+  },
+  create(t, e) {
+    return r({
+      kind: "ColumnDefinitionNode",
+      column: x.create(t),
+      dataType: e
+    });
+  },
+  cloneWithFrontModifier(t, e) {
+    return r({
+      ...t,
+      frontModifiers: t.frontModifiers ? r([...t.frontModifiers, e]) : [e]
+    });
+  },
+  cloneWithEndModifier(t, e) {
+    return r({
+      ...t,
+      endModifiers: t.endModifiers ? r([...t.endModifiers, e]) : [e]
+    });
+  },
+  cloneWith(t, e) {
+    return r({
+      ...t,
+      ...e
+    });
+  }
+}), Qe = r({
+  is(t) {
+    return t.kind === "DropColumnNode";
+  },
+  create(t) {
+    return r({
+      kind: "DropColumnNode",
+      column: x.create(t)
+    });
+  }
+}), De = r({
+  is(t) {
+    return t.kind === "RenameColumnNode";
+  },
+  create(t, e) {
+    return r({
+      kind: "RenameColumnNode",
+      column: x.create(t),
+      renameTo: x.create(e)
+    });
+  }
+}), xe = r({
+  is(t) {
+    return t.kind === "CheckConstraintNode";
+  },
+  create(t, e) {
+    return r({
+      kind: "CheckConstraintNode",
+      expression: t,
+      name: e ? m.create(e) : void 0
+    });
+  }
+}), ot = [
+  "no action",
+  "restrict",
+  "cascade",
+  "set null",
+  "set default"
+], re = r({
+  is(t) {
+    return t.kind === "ReferencesNode";
+  },
+  create(t, e) {
+    return r({
+      kind: "ReferencesNode",
+      table: t,
+      columns: r([...e])
+    });
+  },
+  cloneWithOnDelete(t, e) {
+    return r({
+      ...t,
+      onDelete: e
+    });
+  },
+  cloneWithOnUpdate(t, e) {
+    return r({
+      ...t,
+      onUpdate: e
+    });
+  }
+});
+function Se(t) {
+  return Fe(t) ? t.toOperationNode() : ae.createImmediate(t);
+}
+const te = r({
+  is(t) {
+    return t.kind === "GeneratedNode";
+  },
+  create(t) {
+    return r({
+      kind: "GeneratedNode",
+      ...t
+    });
+  },
+  createWithExpression(t) {
+    return r({
+      kind: "GeneratedNode",
+      always: !0,
+      expression: t
+    });
+  },
+  cloneWith(t, e) {
+    return r({
+      ...t,
+      ...e
+    });
+  }
+}), st = r({
+  is(t) {
+    return t.kind === "DefaultValueNode";
+  },
+  create(t) {
+    return r({
+      kind: "DefaultValueNode",
+      defaultValue: t
+    });
+  }
+});
+function ue(t) {
+  if (ot.includes(t))
+    return t;
+  throw new Error(`invalid OnModifyForeignAction ${t}`);
+}
+class a {
+  #e;
+  constructor(e) {
+    this.#e = e;
+  }
+  /**
+   * Adds `auto_increment` or `autoincrement` to the column definition
+   * depending on the dialect.
+   *
+   * Some dialects like PostgreSQL don't support this. On PostgreSQL
+   * you can use the `serial` or `bigserial` data type instead.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('id', 'integer', col => col.autoIncrement().primaryKey())
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * create table `person` (
+   *   `id` integer primary key auto_increment
+   * )
+   * ```
+   */
+  autoIncrement() {
+    return new a(c.cloneWith(this.#e, { autoIncrement: !0 }));
+  }
+  /**
+   * Makes the column an identity column.
+   *
+   * This only works on some dialects like MS SQL Server (MSSQL).
+   *
+   * For PostgreSQL's `generated always as identity` use {@link generatedAlwaysAsIdentity}.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('id', 'integer', col => col.identity().primaryKey())
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MSSQL):
+   *
+   * ```sql
+   * create table "person" (
+   *   "id" integer identity primary key
+   * )
+   * ```
+   */
+  identity() {
+    return new a(c.cloneWith(this.#e, { identity: !0 }));
+  }
+  /**
+   * Makes the column the primary key.
+   *
+   * If you want to specify a composite primary key use the
+   * {@link CreateTableBuilder.addPrimaryKeyConstraint} method.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('id', 'integer', col => col.primaryKey())
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * create table `person` (
+   *   `id` integer primary key
+   * )
+   */
+  primaryKey() {
+    return new a(c.cloneWith(this.#e, { primaryKey: !0 }));
+  }
+  /**
+   * Adds a foreign key constraint for the column.
+   *
+   * If your database engine doesn't support foreign key constraints in the
+   * column definition (like MySQL 5) you need to call the table level
+   * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('pet')
+   *   .addColumn('owner_id', 'integer', (col) => col.references('person.id'))
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * create table "pet" (
+   *   "owner_id" integer references "person" ("id")
+   * )
+   * ```
+   */
+  references(e) {
+    const n = Ue(e);
+    if (!n.table || ze.is(n.column))
+      throw new Error(`invalid call references('${e}'). The reference must have format table.column or schema.table.column`);
+    return new a(c.cloneWith(this.#e, {
+      references: re.create(n.table, [
+        n.column
+      ])
+    }));
+  }
+  /**
+   * Adds an `on delete` constraint for the foreign key column.
+   *
+   * If your database engine doesn't support foreign key constraints in the
+   * column definition (like MySQL 5) you need to call the table level
+   * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('pet')
+   *   .addColumn(
+   *     'owner_id',
+   *     'integer',
+   *     (col) => col.references('person.id').onDelete('cascade')
+   *   )
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * create table "pet" (
+   *   "owner_id" integer references "person" ("id") on delete cascade
+   * )
+   * ```
+   */
+  onDelete(e) {
+    if (!this.#e.references)
+      throw new Error("on delete constraint can only be added for foreign keys");
+    return new a(c.cloneWith(this.#e, {
+      references: re.cloneWithOnDelete(this.#e.references, ue(e))
+    }));
+  }
+  /**
+   * Adds an `on update` constraint for the foreign key column.
+   *
+   * If your database engine doesn't support foreign key constraints in the
+   * column definition (like MySQL 5) you need to call the table level
+   * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('pet')
+   *   .addColumn(
+   *     'owner_id',
+   *     'integer',
+   *     (col) => col.references('person.id').onUpdate('cascade')
+   *   )
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * create table "pet" (
+   *   "owner_id" integer references "person" ("id") on update cascade
+   * )
+   * ```
+   */
+  onUpdate(e) {
+    if (!this.#e.references)
+      throw new Error("on update constraint can only be added for foreign keys");
+    return new a(c.cloneWith(this.#e, {
+      references: re.cloneWithOnUpdate(this.#e.references, ue(e))
+    }));
+  }
+  /**
+   * Adds a unique constraint for the column.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('email', 'varchar(255)', col => col.unique())
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * create table `person` (
+   *   `email` varchar(255) unique
+   * )
+   * ```
+   */
+  unique() {
+    return new a(c.cloneWith(this.#e, { unique: !0 }));
+  }
+  /**
+   * Adds a `not null` constraint for the column.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('first_name', 'varchar(255)', col => col.notNull())
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * create table `person` (
+   *   `first_name` varchar(255) not null
+   * )
+   * ```
+   */
+  notNull() {
+    return new a(c.cloneWith(this.#e, { notNull: !0 }));
+  }
+  /**
+   * Adds a `unsigned` modifier for the column.
+   *
+   * This only works on some dialects like MySQL.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('age', 'integer', col => col.unsigned())
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * create table `person` (
+   *   `age` integer unsigned
+   * )
+   * ```
+   */
+  unsigned() {
+    return new a(c.cloneWith(this.#e, { unsigned: !0 }));
+  }
+  /**
+   * Adds a default value constraint for the column.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('pet')
+   *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * create table `pet` (
+   *   `number_of_legs` integer default 4
+   * )
+   * ```
+   *
+   * Values passed to `defaultTo` are interpreted as value literals by default. You can define
+   * an arbitrary SQL expression using the {@link sql} template tag:
+   *
+   * ```ts
+   * import { sql } from 'kysely'
+   *
+   * await db.schema
+   *   .createTable('pet')
+   *   .addColumn(
+   *     'created_at',
+   *     'timestamp',
+   *     (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)
+   *   )
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * create table `pet` (
+   *   `created_at` timestamp default CURRENT_TIMESTAMP
+   * )
+   * ```
+   */
+  defaultTo(e) {
+    return new a(c.cloneWith(this.#e, {
+      defaultTo: st.create(Se(e))
+    }));
+  }
+  /**
+   * Adds a check constraint for the column.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * import { sql } from 'kysely'
+   *
+   * await db.schema
+   *   .createTable('pet')
+   *   .addColumn('number_of_legs', 'integer', (col) =>
+   *     col.check(sql`number_of_legs < 5`)
+   *   )
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * create table `pet` (
+   *   `number_of_legs` integer check (number_of_legs < 5)
+   * )
+   * ```
+   */
+  check(e) {
+    return new a(c.cloneWith(this.#e, {
+      check: xe.create(e.toOperationNode())
+    }));
+  }
+  /**
+   * Makes the column a generated column using a `generated always as` statement.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * import { sql } from 'kysely'
+   *
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('full_name', 'varchar(255)',
+   *     (col) => col.generatedAlwaysAs(sql`concat(first_name, ' ', last_name)`)
+   *   )
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * create table `person` (
+   *   `full_name` varchar(255) generated always as (concat(first_name, ' ', last_name))
+   * )
+   * ```
+   */
+  generatedAlwaysAs(e) {
+    return new a(c.cloneWith(this.#e, {
+      generated: te.createWithExpression(e.toOperationNode())
+    }));
+  }
+  /**
+   * Adds the `generated always as identity` specifier.
+   *
+   * This only works on some dialects like PostgreSQL.
+   *
+   * For MS SQL Server (MSSQL)'s identity column use {@link identity}.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('id', 'integer', col => col.generatedAlwaysAsIdentity().primaryKey())
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * create table "person" (
+   *   "id" integer generated always as identity primary key
+   * )
+   * ```
+   */
+  generatedAlwaysAsIdentity() {
+    return new a(c.cloneWith(this.#e, {
+      generated: te.create({ identity: !0, always: !0 })
+    }));
+  }
+  /**
+   * Adds the `generated by default as identity` specifier on supported dialects.
+   *
+   * This only works on some dialects like PostgreSQL.
+   *
+   * For MS SQL Server (MSSQL)'s identity column use {@link identity}.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('id', 'integer', col => col.generatedByDefaultAsIdentity().primaryKey())
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * create table "person" (
+   *   "id" integer generated by default as identity primary key
+   * )
+   * ```
+   */
+  generatedByDefaultAsIdentity() {
+    return new a(c.cloneWith(this.#e, {
+      generated: te.create({ identity: !0, byDefault: !0 })
+    }));
+  }
+  /**
+   * Makes a generated column stored instead of virtual. This method can only
+   * be used with {@link generatedAlwaysAs}
+   *
+   * ### Examples
+   *
+   * ```ts
+   * import { sql } from 'kysely'
+   *
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('full_name', 'varchar(255)', (col) => col
+   *     .generatedAlwaysAs(sql`concat(first_name, ' ', last_name)`)
+   *     .stored()
+   *   )
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * create table `person` (
+   *   `full_name` varchar(255) generated always as (concat(first_name, ' ', last_name)) stored
+   * )
+   * ```
+   */
+  stored() {
+    if (!this.#e.generated)
+      throw new Error("stored() can only be called after generatedAlwaysAs");
+    return new a(c.cloneWith(this.#e, {
+      generated: te.cloneWith(this.#e.generated, {
+        stored: !0
+      })
+    }));
+  }
+  /**
+   * This can be used to add any additional SQL right after the column's data type.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * import { sql } from 'kysely'
+   *
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('id', 'integer', col => col.primaryKey())
+   *   .addColumn(
+   *     'first_name',
+   *     'varchar(36)',
+   *     (col) => col.modifyFront(sql`collate utf8mb4_general_ci`).notNull()
+   *   )
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * create table `person` (
+   *   `id` integer primary key,
+   *   `first_name` varchar(36) collate utf8mb4_general_ci not null
+   * )
+   * ```
+   */
+  modifyFront(e) {
+    return new a(c.cloneWithFrontModifier(this.#e, e.toOperationNode()));
+  }
+  /**
+   * Adds `nulls not distinct` specifier.
+   * Should be used with `unique` constraint.
+   *
+   * This only works on some dialects like PostgreSQL.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * db.schema
+   *   .createTable('person')
+   *   .addColumn('id', 'integer', col => col.primaryKey())
+   *   .addColumn('first_name', 'varchar(30)', col => col.unique().nullsNotDistinct())
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * create table "person" (
+   *   "id" integer primary key,
+   *   "first_name" varchar(30) unique nulls not distinct
+   * )
+   * ```
+   */
+  nullsNotDistinct() {
+    return new a(c.cloneWith(this.#e, { nullsNotDistinct: !0 }));
+  }
+  /**
+   * Adds `if not exists` specifier. This only works for PostgreSQL.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .alterTable('person')
+   *   .addColumn('email', 'varchar(255)', col => col.unique().ifNotExists())
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * alter table "person" add column if not exists "email" varchar(255) unique
+   * ```
+   */
+  ifNotExists() {
+    return new a(c.cloneWith(this.#e, { ifNotExists: !0 }));
+  }
+  /**
+   * This can be used to add any additional SQL to the end of the column definition.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * import { sql } from 'kysely'
+   *
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('id', 'integer', col => col.primaryKey())
+   *   .addColumn(
+   *     'age',
+   *     'integer',
+   *     col => col.unsigned()
+   *       .notNull()
+   *       .modifyEnd(sql`comment ${sql.lit('it is not polite to ask a woman her age')}`)
+   *   )
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * create table `person` (
+   *   `id` integer primary key,
+   *   `age` integer unsigned not null comment 'it is not polite to ask a woman her age'
+   * )
+   * ```
+   */
+  modifyEnd(e) {
+    return new a(c.cloneWithEndModifier(this.#e, e.toOperationNode()));
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e;
+  }
+}
+const Te = r({
+  is(t) {
+    return t.kind === "ModifyColumnNode";
+  },
+  create(t) {
+    return r({
+      kind: "ModifyColumnNode",
+      column: t
+    });
+  }
+}), I = r({
+  is(t) {
+    return t.kind === "ForeignKeyConstraintNode";
+  },
+  create(t, e, n, i) {
+    return r({
+      kind: "ForeignKeyConstraintNode",
+      columns: t,
+      references: re.create(e, n),
+      name: i ? m.create(i) : void 0
+    });
+  },
+  cloneWith(t, e) {
+    return r({
+      ...t,
+      ...e
+    });
+  }
+});
+class g {
+  #e;
+  constructor(e) {
+    this.#e = e;
+  }
+  onDelete(e) {
+    return new g(I.cloneWith(this.#e, {
+      onDelete: ue(e)
+    }));
+  }
+  onUpdate(e) {
+    return new g(I.cloneWith(this.#e, {
+      onUpdate: ue(e)
+    }));
+  }
+  deferrable() {
+    return new g(I.cloneWith(this.#e, { deferrable: !0 }));
+  }
+  notDeferrable() {
+    return new g(I.cloneWith(this.#e, { deferrable: !1 }));
+  }
+  initiallyDeferred() {
+    return new g(I.cloneWith(this.#e, {
+      initiallyDeferred: !0
+    }));
+  }
+  initiallyImmediate() {
+    return new g(I.cloneWith(this.#e, {
+      initiallyDeferred: !1
+    }));
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e;
+  }
+}
+const ne = r({
+  is(t) {
+    return t.kind === "AddConstraintNode";
+  },
+  create(t) {
+    return r({
+      kind: "AddConstraintNode",
+      constraint: t
+    });
+  }
+}), D = r({
+  is(t) {
+    return t.kind === "UniqueConstraintNode";
+  },
+  create(t, e, n) {
+    return r({
+      kind: "UniqueConstraintNode",
+      columns: r(t.map(x.create)),
+      name: e ? m.create(e) : void 0,
+      nullsNotDistinct: n
+    });
+  },
+  cloneWith(t, e) {
+    return r({
+      ...t,
+      ...e
+    });
+  }
+}), ie = r({
+  is(t) {
+    return t.kind === "DropConstraintNode";
+  },
+  create(t) {
+    return r({
+      kind: "DropConstraintNode",
+      constraintName: m.create(t)
+    });
+  },
+  cloneWith(t, e) {
+    return r({
+      ...t,
+      ...e
+    });
+  }
+}), Y = r({
+  is(t) {
+    return t.kind === "AlterColumnNode";
+  },
+  create(t, e, n) {
+    return r({
+      kind: "AlterColumnNode",
+      column: x.create(t),
+      [e]: n
+    });
+  }
+});
+class Me {
+  #e;
+  constructor(e) {
+    this.#e = e;
+  }
+  setDataType(e) {
+    return new j(Y.create(this.#e, "dataType", H(e)));
+  }
+  setDefault(e) {
+    return new j(Y.create(this.#e, "setDefault", Se(e)));
+  }
+  dropDefault() {
+    return new j(Y.create(this.#e, "dropDefault", !0));
+  }
+  setNotNull() {
+    return new j(Y.create(this.#e, "setNotNull", !0));
+  }
+  dropNotNull() {
+    return new j(Y.create(this.#e, "dropNotNull", !0));
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+}
+class j {
+  #e;
+  constructor(e) {
+    this.#e = e;
+  }
+  toOperationNode() {
+    return this.#e;
+  }
+}
+class L {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  toOperationNode() {
+    return this.#e.executor.transformQuery(this.#e.node, this.#e.queryId);
+  }
+  compile() {
+    return this.#e.executor.compileQuery(this.toOperationNode(), this.#e.queryId);
+  }
+  async execute() {
+    await this.#e.executor.executeQuery(this.compile());
+  }
+}
+class k {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  onDelete(e) {
+    return new k({
+      ...this.#e,
+      constraintBuilder: this.#e.constraintBuilder.onDelete(e)
+    });
+  }
+  onUpdate(e) {
+    return new k({
+      ...this.#e,
+      constraintBuilder: this.#e.constraintBuilder.onUpdate(e)
+    });
+  }
+  deferrable() {
+    return new k({
+      ...this.#e,
+      constraintBuilder: this.#e.constraintBuilder.deferrable()
+    });
+  }
+  notDeferrable() {
+    return new k({
+      ...this.#e,
+      constraintBuilder: this.#e.constraintBuilder.notDeferrable()
+    });
+  }
+  initiallyDeferred() {
+    return new k({
+      ...this.#e,
+      constraintBuilder: this.#e.constraintBuilder.initiallyDeferred()
+    });
+  }
+  initiallyImmediate() {
+    return new k({
+      ...this.#e,
+      constraintBuilder: this.#e.constraintBuilder.initiallyImmediate()
+    });
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e.executor.transformQuery(s.cloneWithTableProps(this.#e.node, {
+      addConstraint: ne.create(this.#e.constraintBuilder.toOperationNode())
+    }), this.#e.queryId);
+  }
+  compile() {
+    return this.#e.executor.compileQuery(this.toOperationNode(), this.#e.queryId);
+  }
+  async execute() {
+    await this.#e.executor.executeQuery(this.compile());
+  }
+}
+class z {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  ifExists() {
+    return new z({
+      ...this.#e,
+      node: s.cloneWithTableProps(this.#e.node, {
+        dropConstraint: ie.cloneWith(this.#e.node.dropConstraint, {
+          ifExists: !0
+        })
+      })
+    });
+  }
+  cascade() {
+    return new z({
+      ...this.#e,
+      node: s.cloneWithTableProps(this.#e.node, {
+        dropConstraint: ie.cloneWith(this.#e.node.dropConstraint, {
+          modifier: "cascade"
+        })
+      })
+    });
+  }
+  restrict() {
+    return new z({
+      ...this.#e,
+      node: s.cloneWithTableProps(this.#e.node, {
+        dropConstraint: ie.cloneWith(this.#e.node.dropConstraint, {
+          modifier: "restrict"
+        })
+      })
+    });
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e.executor.transformQuery(this.#e.node, this.#e.queryId);
+  }
+  compile() {
+    return this.#e.executor.compileQuery(this.toOperationNode(), this.#e.queryId);
+  }
+  async execute() {
+    await this.#e.executor.executeQuery(this.compile());
+  }
+}
+const U = r({
+  is(t) {
+    return t.kind === "PrimaryKeyConstraintNode";
+  },
+  create(t, e) {
+    return r({
+      kind: "PrimaryKeyConstraintNode",
+      columns: r(t.map(x.create)),
+      name: e ? m.create(e) : void 0
+    });
+  },
+  cloneWith(t, e) {
+    return r({ ...t, ...e });
+  }
+}), F = r({
+  is(t) {
+    return t.kind === "AddIndexNode";
+  },
+  create(t) {
+    return r({
+      kind: "AddIndexNode",
+      name: m.create(t)
+    });
+  },
+  cloneWith(t, e) {
+    return r({
+      ...t,
+      ...e
+    });
+  },
+  cloneWithColumns(t, e) {
+    return r({
+      ...t,
+      columns: [...t.columns || [], ...e]
+    });
+  }
+});
+class S {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  /**
+   * 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() {
+    return new S({
+      ...this.#e,
+      node: s.cloneWithTableProps(this.#e.node, {
+        addIndex: F.cloneWith(this.#e.node.addIndex, {
+          unique: !0
+        })
+      })
+    });
+  }
+  /**
+   * 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
+   * await db.schema
+   *   .alterTable('person')
+   *   .addIndex('person_first_name_and_age_index')
+   *   .column('first_name')
+   *   .column('age desc')
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * alter table `person` add index `person_first_name_and_age_index` (`first_name`, `age` desc)
+   * ```
+   */
+  column(e) {
+    return new S({
+      ...this.#e,
+      node: s.cloneWithTableProps(this.#e.node, {
+        addIndex: F.cloneWithColumns(this.#e.node.addIndex, [
+          ce(e)
+        ])
+      })
+    });
+  }
+  /**
+   * 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
+   * await db.schema
+   *   .alterTable('person')
+   *   .addIndex('person_first_name_and_age_index')
+   *   .columns(['first_name', 'age desc'])
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * alter table `person` add index `person_first_name_and_age_index` (`first_name`, `age` desc)
+   * ```
+   */
+  columns(e) {
+    return new S({
+      ...this.#e,
+      node: s.cloneWithTableProps(this.#e.node, {
+        addIndex: F.cloneWithColumns(this.#e.node.addIndex, e.map(ce))
+      })
+    });
+  }
+  /**
+   * 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'))
+   * ```
+   */
+  expression(e) {
+    return new S({
+      ...this.#e,
+      node: s.cloneWithTableProps(this.#e.node, {
+        addIndex: F.cloneWithColumns(this.#e.node.addIndex, [
+          e.toOperationNode()
+        ])
+      })
+    });
+  }
+  using(e) {
+    return new S({
+      ...this.#e,
+      node: s.cloneWithTableProps(this.#e.node, {
+        addIndex: F.cloneWith(this.#e.node.addIndex, {
+          using: ke.createWithSql(e)
+        })
+      })
+    });
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e.executor.transformQuery(this.#e.node, this.#e.queryId);
+  }
+  compile() {
+    return this.#e.executor.compileQuery(this.toOperationNode(), this.#e.queryId);
+  }
+  async execute() {
+    await this.#e.executor.executeQuery(this.compile());
+  }
+}
+class v {
+  #e;
+  constructor(e) {
+    this.#e = e;
+  }
+  /**
+   * Adds `nulls not distinct` to the unique constraint definition
+   *
+   * Supported by PostgreSQL dialect only
+   */
+  nullsNotDistinct() {
+    return new v(D.cloneWith(this.#e, { nullsNotDistinct: !0 }));
+  }
+  deferrable() {
+    return new v(D.cloneWith(this.#e, { deferrable: !0 }));
+  }
+  notDeferrable() {
+    return new v(D.cloneWith(this.#e, { deferrable: !1 }));
+  }
+  initiallyDeferred() {
+    return new v(D.cloneWith(this.#e, {
+      initiallyDeferred: !0
+    }));
+  }
+  initiallyImmediate() {
+    return new v(D.cloneWith(this.#e, {
+      initiallyDeferred: !1
+    }));
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e;
+  }
+}
+class A {
+  #e;
+  constructor(e) {
+    this.#e = e;
+  }
+  deferrable() {
+    return new A(U.cloneWith(this.#e, { deferrable: !0 }));
+  }
+  notDeferrable() {
+    return new A(U.cloneWith(this.#e, { deferrable: !1 }));
+  }
+  initiallyDeferred() {
+    return new A(U.cloneWith(this.#e, {
+      initiallyDeferred: !0
+    }));
+  }
+  initiallyImmediate() {
+    return new A(U.cloneWith(this.#e, {
+      initiallyDeferred: !1
+    }));
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e;
+  }
+}
+class Ae {
+  #e;
+  constructor(e) {
+    this.#e = e;
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e;
+  }
+}
+const at = r({
+  is(t) {
+    return t.kind === "RenameConstraintNode";
+  },
+  create(t, e) {
+    return r({
+      kind: "RenameConstraintNode",
+      oldName: m.create(t),
+      newName: m.create(e)
+    });
+  }
+});
+class ct {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  renameTo(e) {
+    return new L({
+      ...this.#e,
+      node: s.cloneWithTableProps(this.#e.node, {
+        renameTo: E(e)
+      })
+    });
+  }
+  setSchema(e) {
+    return new L({
+      ...this.#e,
+      node: s.cloneWithTableProps(this.#e.node, {
+        setSchema: m.create(e)
+      })
+    });
+  }
+  alterColumn(e, n) {
+    const i = n(new Me(e));
+    return new N({
+      ...this.#e,
+      node: s.cloneWithColumnAlteration(this.#e.node, i.toOperationNode())
+    });
+  }
+  dropColumn(e) {
+    return new N({
+      ...this.#e,
+      node: s.cloneWithColumnAlteration(this.#e.node, Qe.create(e))
+    });
+  }
+  renameColumn(e, n) {
+    return new N({
+      ...this.#e,
+      node: s.cloneWithColumnAlteration(this.#e.node, De.create(e, n))
+    });
+  }
+  addColumn(e, n, i = w) {
+    const o = i(new a(c.create(e, H(n))));
+    return new N({
+      ...this.#e,
+      node: s.cloneWithColumnAlteration(this.#e.node, Ee.create(o.toOperationNode()))
+    });
+  }
+  modifyColumn(e, n, i = w) {
+    const o = i(new a(c.create(e, H(n))));
+    return new N({
+      ...this.#e,
+      node: s.cloneWithColumnAlteration(this.#e.node, Te.create(o.toOperationNode()))
+    });
+  }
+  /**
+   * See {@link CreateTableBuilder.addUniqueConstraint}
+   */
+  addUniqueConstraint(e, n, i = w) {
+    const o = i(new v(D.create(n, e)));
+    return new L({
+      ...this.#e,
+      node: s.cloneWithTableProps(this.#e.node, {
+        addConstraint: ne.create(o.toOperationNode())
+      })
+    });
+  }
+  /**
+   * See {@link CreateTableBuilder.addCheckConstraint}
+   */
+  addCheckConstraint(e, n, i = w) {
+    const o = i(new Ae(xe.create(n.toOperationNode(), e)));
+    return new L({
+      ...this.#e,
+      node: s.cloneWithTableProps(this.#e.node, {
+        addConstraint: ne.create(o.toOperationNode())
+      })
+    });
+  }
+  /**
+   * See {@link CreateTableBuilder.addForeignKeyConstraint}
+   *
+   * Unlike {@link CreateTableBuilder.addForeignKeyConstraint} this method returns
+   * the constraint builder and doesn't take a callback as the last argument. This
+   * is because you can only add one column per `ALTER TABLE` query.
+   */
+  addForeignKeyConstraint(e, n, i, o, u = w) {
+    const h = u(new g(I.create(n.map(x.create), E(i), o.map(x.create), e)));
+    return new k({
+      ...this.#e,
+      constraintBuilder: h
+    });
+  }
+  /**
+   * See {@link CreateTableBuilder.addPrimaryKeyConstraint}
+   */
+  addPrimaryKeyConstraint(e, n, i = w) {
+    const o = i(new A(U.create(n, e)));
+    return new L({
+      ...this.#e,
+      node: s.cloneWithTableProps(this.#e.node, {
+        addConstraint: ne.create(o.toOperationNode())
+      })
+    });
+  }
+  dropConstraint(e) {
+    return new z({
+      ...this.#e,
+      node: s.cloneWithTableProps(this.#e.node, {
+        dropConstraint: ie.create(e)
+      })
+    });
+  }
+  renameConstraint(e, n) {
+    return new z({
+      ...this.#e,
+      node: s.cloneWithTableProps(this.#e.node, {
+        renameConstraint: at.create(e, n)
+      })
+    });
+  }
+  /**
+   * This can be used to add index to table.
+   *
+   *  ### Examples
+   *
+   * ```ts
+   * db.schema.alterTable('person')
+   *   .addIndex('person_email_index')
+   *   .column('email')
+   *   .unique()
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * alter table `person` add unique index `person_email_index` (`email`)
+   * ```
+   */
+  addIndex(e) {
+    return new S({
+      ...this.#e,
+      node: s.cloneWithTableProps(this.#e.node, {
+        addIndex: F.create(e)
+      })
+    });
+  }
+  /**
+   * This can be used to drop index from table.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * db.schema.alterTable('person')
+   *   .dropIndex('person_email_index')
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * alter table `person` drop index `test_first_name_index`
+   * ```
+   */
+  dropIndex(e) {
+    return new L({
+      ...this.#e,
+      node: s.cloneWithTableProps(this.#e.node, {
+        dropIndex: Z.create(e)
+      })
+    });
+  }
+  /**
+   * Calls the given function passing `this` as the only argument.
+   *
+   * See {@link CreateTableBuilder.$call}
+   */
+  $call(e) {
+    return e(this);
+  }
+}
+class N {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  alterColumn(e, n) {
+    const i = n(new Me(e));
+    return new N({
+      ...this.#e,
+      node: s.cloneWithColumnAlteration(this.#e.node, i.toOperationNode())
+    });
+  }
+  dropColumn(e) {
+    return new N({
+      ...this.#e,
+      node: s.cloneWithColumnAlteration(this.#e.node, Qe.create(e))
+    });
+  }
+  renameColumn(e, n) {
+    return new N({
+      ...this.#e,
+      node: s.cloneWithColumnAlteration(this.#e.node, De.create(e, n))
+    });
+  }
+  addColumn(e, n, i = w) {
+    const o = i(new a(c.create(e, H(n))));
+    return new N({
+      ...this.#e,
+      node: s.cloneWithColumnAlteration(this.#e.node, Ee.create(o.toOperationNode()))
+    });
+  }
+  modifyColumn(e, n, i = w) {
+    const o = i(new a(c.create(e, H(n))));
+    return new N({
+      ...this.#e,
+      node: s.cloneWithColumnAlteration(this.#e.node, Te.create(o.toOperationNode()))
+    });
+  }
+  toOperationNode() {
+    return this.#e.executor.transformQuery(this.#e.node, this.#e.queryId);
+  }
+  compile() {
+    return this.#e.executor.compileQuery(this.toOperationNode(), this.#e.queryId);
+  }
+  async execute() {
+    await this.#e.executor.executeQuery(this.compile());
+  }
+}
+class $e extends Ge {
+  transformPrimitiveValueList(e) {
+    return qe.create(e.values.map(ae.createImmediate));
+  }
+  transformValue(e) {
+    return ae.createImmediate(e.value);
+  }
+}
+class f {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  /**
+   * Adds the "if not exists" modifier.
+   *
+   * If the index already exists, no error is thrown if this method has been called.
+   */
+  ifNotExists() {
+    return new f({
+      ...this.#e,
+      node: O.cloneWith(this.#e.node, {
+        ifNotExists: !0
+      })
+    });
+  }
+  /**
+   * Makes the index unique.
+   */
+  unique() {
+    return new f({
+      ...this.#e,
+      node: O.cloneWith(this.#e.node, {
+        unique: !0
+      })
+    });
+  }
+  /**
+   * Adds `nulls not distinct` specifier to index.
+   * This only works on some dialects like PostgreSQL.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * db.schema.createIndex('person_first_name_index')
+   *  .on('person')
+   *  .column('first_name')
+   *  .nullsNotDistinct()
+   *  .execute()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * create index "person_first_name_index"
+   * on "test" ("first_name")
+   * nulls not distinct;
+   * ```
+   */
+  nullsNotDistinct() {
+    return new f({
+      ...this.#e,
+      node: O.cloneWith(this.#e.node, {
+        nullsNotDistinct: !0
+      })
+    });
+  }
+  /**
+   * Specifies the table for the index.
+   */
+  on(e) {
+    return new f({
+      ...this.#e,
+      node: O.cloneWith(this.#e.node, {
+        table: E(e)
+      })
+    });
+  }
+  /**
+   * 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
+   * await db.schema
+   *         .createIndex('person_first_name_and_age_index')
+   *         .on('person')
+   *         .column('first_name')
+   *         .column('age desc')
+   *         .execute()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * create index "person_first_name_and_age_index" on "person" ("first_name", "age" desc)
+   * ```
+   */
+  column(e) {
+    return new f({
+      ...this.#e,
+      node: O.cloneWithColumns(this.#e.node, [
+        ce(e)
+      ])
+    });
+  }
+  /**
+   * 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
+   * await db.schema
+   *         .createIndex('person_first_name_and_age_index')
+   *         .on('person')
+   *         .columns(['first_name', 'age desc'])
+   *         .execute()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * create index "person_first_name_and_age_index" on "person" ("first_name", "age" desc)
+   * ```
+   */
+  columns(e) {
+    return new f({
+      ...this.#e,
+      node: O.cloneWithColumns(this.#e.node, e.map(ce))
+    });
+  }
+  /**
+   * Specifies an arbitrary expression for the index.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * import { sql } from 'kysely'
+   *
+   * await db.schema
+   *   .createIndex('person_first_name_index')
+   *   .on('person')
+   *   .expression(sql`first_name COLLATE "fi_FI"`)
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * create index "person_first_name_index" on "person" (first_name COLLATE "fi_FI")
+   * ```
+   */
+  expression(e) {
+    return new f({
+      ...this.#e,
+      node: O.cloneWithColumns(this.#e.node, [
+        e.toOperationNode()
+      ])
+    });
+  }
+  using(e) {
+    return new f({
+      ...this.#e,
+      node: O.cloneWith(this.#e.node, {
+        using: ke.createWithSql(e)
+      })
+    });
+  }
+  where(...e) {
+    const n = new $e();
+    return new f({
+      ...this.#e,
+      node: He.cloneWithWhere(this.#e.node, n.transformNode(Je(e), this.#e.queryId))
+    });
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e.executor.transformQuery(this.#e.node, this.#e.queryId);
+  }
+  compile() {
+    return this.#e.executor.compileQuery(this.toOperationNode(), this.#e.queryId);
+  }
+  async execute() {
+    await this.#e.executor.executeQuery(this.compile());
+  }
+}
+class We {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  ifNotExists() {
+    return new We({
+      ...this.#e,
+      node: ve.cloneWith(this.#e.node, { ifNotExists: !0 })
+    });
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e.executor.transformQuery(this.#e.node, this.#e.queryId);
+  }
+  compile() {
+    return this.#e.executor.compileQuery(this.toOperationNode(), this.#e.queryId);
+  }
+  async execute() {
+    await this.#e.executor.executeQuery(this.compile());
+  }
+}
+function ut(t) {
+  if (it.includes(t))
+    return t;
+  throw new Error(`invalid OnCommitAction ${t}`);
+}
+class l {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  /**
+   * Adds the "temporary" modifier.
+   *
+   * Use this to create a temporary table.
+   */
+  temporary() {
+    return new l({
+      ...this.#e,
+      node: p.cloneWith(this.#e.node, {
+        temporary: !0
+      })
+    });
+  }
+  /**
+   * Adds an "on commit" statement.
+   *
+   * This can be used in conjunction with temporary tables on supported databases
+   * like PostgreSQL.
+   */
+  onCommit(e) {
+    return new l({
+      ...this.#e,
+      node: p.cloneWith(this.#e.node, {
+        onCommit: ut(e)
+      })
+    });
+  }
+  /**
+   * Adds the "if not exists" modifier.
+   *
+   * If the table already exists, no error is thrown if this method has been called.
+   */
+  ifNotExists() {
+    return new l({
+      ...this.#e,
+      node: p.cloneWith(this.#e.node, {
+        ifNotExists: !0
+      })
+    });
+  }
+  /**
+   * Adds a column to the table.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * import { sql } from 'kysely'
+   *
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey())
+   *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
+   *   .addColumn('last_name', 'varchar(255)')
+   *   .addColumn('bank_balance', 'numeric(8, 2)')
+   *   // You can specify any data type using the `sql` tag if the types
+   *   // don't include it.
+   *   .addColumn('data', sql`any_type_here`)
+   *   .addColumn('parent_id', 'integer', (col) =>
+   *     col.references('person.id').onDelete('cascade')
+   *   )
+   * ```
+   *
+   * With this method, it's once again good to remember that Kysely just builds the
+   * query and doesn't provide the same API for all databases. For example, some
+   * databases like older MySQL don't support the `references` statement in the
+   * column definition. Instead foreign key constraints need to be defined in the
+   * `create table` query. See the next example:
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('id', 'integer', (col) => col.primaryKey())
+   *   .addColumn('parent_id', 'integer')
+   *   .addForeignKeyConstraint(
+   *     'person_parent_id_fk',
+   *     ['parent_id'],
+   *     'person',
+   *     ['id'],
+   *     (cb) => cb.onDelete('cascade')
+   *   )
+   *   .execute()
+   * ```
+   *
+   * Another good example is that PostgreSQL doesn't support the `auto_increment`
+   * keyword and you need to define an autoincrementing column for example using
+   * `serial`:
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('id', 'serial', (col) => col.primaryKey())
+   *   .execute()
+   * ```
+   */
+  addColumn(e, n, i = w) {
+    const o = i(new a(c.create(e, H(n))));
+    return new l({
+      ...this.#e,
+      node: p.cloneWithColumn(this.#e.node, o.toOperationNode())
+    });
+  }
+  /**
+   * Adds a primary key constraint for one or more columns.
+   *
+   * The constraint name can be anything you want, but it must be unique
+   * across the whole database.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('first_name', 'varchar(64)')
+   *   .addColumn('last_name', 'varchar(64)')
+   *   .addPrimaryKeyConstraint('primary_key', ['first_name', 'last_name'])
+   *   .execute()
+   * ```
+   */
+  addPrimaryKeyConstraint(e, n, i = w) {
+    const o = i(new A(U.create(n, e)));
+    return new l({
+      ...this.#e,
+      node: p.cloneWithConstraint(this.#e.node, o.toOperationNode())
+    });
+  }
+  /**
+   * Adds a unique constraint for one or more columns.
+   *
+   * The constraint name can be anything you want, but it must be unique
+   * across the whole database.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('first_name', 'varchar(64)')
+   *   .addColumn('last_name', 'varchar(64)')
+   *   .addUniqueConstraint(
+   *     'first_name_last_name_unique',
+   *     ['first_name', 'last_name']
+   *   )
+   *   .execute()
+   * ```
+   *
+   * In dialects such as PostgreSQL you can specify `nulls not distinct` as follows:
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('first_name', 'varchar(64)')
+   *   .addColumn('last_name', 'varchar(64)')
+   *   .addUniqueConstraint(
+   *     'first_name_last_name_unique',
+   *     ['first_name', 'last_name'],
+   *     (cb) => cb.nullsNotDistinct()
+   *   )
+   *   .execute()
+   * ```
+   */
+  addUniqueConstraint(e, n, i = w) {
+    const o = i(new v(D.create(n, e)));
+    return new l({
+      ...this.#e,
+      node: p.cloneWithConstraint(this.#e.node, o.toOperationNode())
+    });
+  }
+  /**
+   * Adds a check constraint.
+   *
+   * The constraint name can be anything you want, but it must be unique
+   * across the whole database.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * import { sql } from 'kysely'
+   *
+   * await db.schema
+   *   .createTable('animal')
+   *   .addColumn('number_of_legs', 'integer')
+   *   .addCheckConstraint('check_legs', sql`number_of_legs < 5`)
+   *   .execute()
+   * ```
+   */
+  addCheckConstraint(e, n, i = w) {
+    const o = i(new Ae(xe.create(n.toOperationNode(), e)));
+    return new l({
+      ...this.#e,
+      node: p.cloneWithConstraint(this.#e.node, o.toOperationNode())
+    });
+  }
+  /**
+   * Adds a foreign key constraint.
+   *
+   * The constraint name can be anything you want, but it must be unique
+   * across the whole database.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('pet')
+   *   .addColumn('owner_id', 'integer')
+   *   .addForeignKeyConstraint(
+   *     'owner_id_foreign',
+   *     ['owner_id'],
+   *     'person',
+   *     ['id'],
+   *   )
+   *   .execute()
+   * ```
+   *
+   * Add constraint for multiple columns:
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('pet')
+   *   .addColumn('owner_id1', 'integer')
+   *   .addColumn('owner_id2', 'integer')
+   *   .addForeignKeyConstraint(
+   *     'owner_id_foreign',
+   *     ['owner_id1', 'owner_id2'],
+   *     'person',
+   *     ['id1', 'id2'],
+   *     (cb) => cb.onDelete('cascade')
+   *   )
+   *   .execute()
+   * ```
+   */
+  addForeignKeyConstraint(e, n, i, o, u = w) {
+    const h = u(new g(I.create(n.map(x.create), E(i), o.map(x.create), e)));
+    return new l({
+      ...this.#e,
+      node: p.cloneWithConstraint(this.#e.node, h.toOperationNode())
+    });
+  }
+  /**
+   * This can be used to add any additional SQL to the front of the query __after__ the `create` keyword.
+   *
+   * Also see {@link temporary}.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * import { sql } from 'kysely'
+   *
+   * await db.schema
+   *   .createTable('person')
+   *   .modifyFront(sql`global temporary`)
+   *   .addColumn('id', 'integer', col => col.primaryKey())
+   *   .addColumn('first_name', 'varchar(64)', col => col.notNull())
+   *   .addColumn('last_name', 'varchar(64)', col => col.notNull())
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (Postgres):
+   *
+   * ```sql
+   * create global temporary table "person" (
+   *   "id" integer primary key,
+   *   "first_name" varchar(64) not null,
+   *   "last_name" varchar(64) not null
+   * )
+   * ```
+   */
+  modifyFront(e) {
+    return new l({
+      ...this.#e,
+      node: p.cloneWithFrontModifier(this.#e.node, e.toOperationNode())
+    });
+  }
+  /**
+   * This can be used to add any additional SQL to the end of the query.
+   *
+   * Also see {@link onCommit}.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * import { sql } from 'kysely'
+   *
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('id', 'integer', col => col.primaryKey())
+   *   .addColumn('first_name', 'varchar(64)', col => col.notNull())
+   *   .addColumn('last_name', 'varchar(64)', col => col.notNull())
+   *   .modifyEnd(sql`collate utf8_unicode_ci`)
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (MySQL):
+   *
+   * ```sql
+   * create table `person` (
+   *   `id` integer primary key,
+   *   `first_name` varchar(64) not null,
+   *   `last_name` varchar(64) not null
+   * ) collate utf8_unicode_ci
+   * ```
+   */
+  modifyEnd(e) {
+    return new l({
+      ...this.#e,
+      node: p.cloneWithEndModifier(this.#e.node, e.toOperationNode())
+    });
+  }
+  /**
+   * Allows to create table from `select` query.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('copy')
+   *   .temporary()
+   *   .as(db.selectFrom('person').select(['first_name', 'last_name']))
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * create temporary table "copy" as
+   * select "first_name", "last_name" from "person"
+   * ```
+   */
+  as(e) {
+    return new l({
+      ...this.#e,
+      node: p.cloneWith(this.#e.node, {
+        selectQuery: Pe(e)
+      })
+    });
+  }
+  /**
+   * Calls the given function passing `this` as the only argument.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('test')
+   *   .$call((builder) => builder.addColumn('id', 'integer'))
+   *   .execute()
+   * ```
+   *
+   * This is useful for creating reusable functions that can be called with a builder.
+   *
+   * ```ts
+   * import { type CreateTableBuilder, sql } from 'kysely'
+   *
+   * const addDefaultColumns = (ctb: CreateTableBuilder<any, any>) => {
+   *   return ctb
+   *     .addColumn('id', 'integer', (col) => col.notNull())
+   *     .addColumn('created_at', 'date', (col) =>
+   *       col.notNull().defaultTo(sql`now()`)
+   *     )
+   *     .addColumn('updated_at', 'date', (col) =>
+   *       col.notNull().defaultTo(sql`now()`)
+   *     )
+   * }
+   *
+   * await db.schema
+   *   .createTable('test')
+   *   .$call(addDefaultColumns)
+   *   .execute()
+   * ```
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e.executor.transformQuery(this.#e.node, this.#e.queryId);
+  }
+  compile() {
+    return this.#e.executor.compileQuery(this.toOperationNode(), this.#e.queryId);
+  }
+  async execute() {
+    await this.#e.executor.executeQuery(this.compile());
+  }
+}
+class K {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  /**
+   * Specifies the table the index was created for. This is not needed
+   * in all dialects.
+   */
+  on(e) {
+    return new K({
+      ...this.#e,
+      node: Z.cloneWith(this.#e.node, {
+        table: E(e)
+      })
+    });
+  }
+  ifExists() {
+    return new K({
+      ...this.#e,
+      node: Z.cloneWith(this.#e.node, {
+        ifExists: !0
+      })
+    });
+  }
+  cascade() {
+    return new K({
+      ...this.#e,
+      node: Z.cloneWith(this.#e.node, {
+        cascade: !0
+      })
+    });
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e.executor.transformQuery(this.#e.node, this.#e.queryId);
+  }
+  compile() {
+    return this.#e.executor.compileQuery(this.toOperationNode(), this.#e.queryId);
+  }
+  async execute() {
+    await this.#e.executor.executeQuery(this.compile());
+  }
+}
+class he {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  ifExists() {
+    return new he({
+      ...this.#e,
+      node: ye.cloneWith(this.#e.node, {
+        ifExists: !0
+      })
+    });
+  }
+  cascade() {
+    return new he({
+      ...this.#e,
+      node: ye.cloneWith(this.#e.node, {
+        cascade: !0
+      })
+    });
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e.executor.transformQuery(this.#e.node, this.#e.queryId);
+  }
+  compile() {
+    return this.#e.executor.compileQuery(this.toOperationNode(), this.#e.queryId);
+  }
+  async execute() {
+    await this.#e.executor.executeQuery(this.compile());
+  }
+}
+class de {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  ifExists() {
+    return new de({
+      ...this.#e,
+      node: fe.cloneWith(this.#e.node, {
+        ifExists: !0
+      })
+    });
+  }
+  cascade() {
+    return new de({
+      ...this.#e,
+      node: fe.cloneWith(this.#e.node, {
+        cascade: !0
+      })
+    });
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e.executor.transformQuery(this.#e.node, this.#e.queryId);
+  }
+  compile() {
+    return this.#e.executor.compileQuery(this.toOperationNode(), this.#e.queryId);
+  }
+  async execute() {
+    await this.#e.executor.executeQuery(this.compile());
+  }
+}
+const Q = r({
+  is(t) {
+    return t.kind === "CreateViewNode";
+  },
+  create(t) {
+    return r({
+      kind: "CreateViewNode",
+      name: G.create(t)
+    });
+  },
+  cloneWith(t, e) {
+    return r({
+      ...t,
+      ...e
+    });
+  }
+});
+class ht {
+  #e = new $e();
+  transformQuery(e) {
+    return this.#e.transformNode(e.node, e.queryId);
+  }
+  transformResult(e) {
+    return Promise.resolve(e.result);
+  }
+}
+class q {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  /**
+   * Adds the "temporary" modifier.
+   *
+   * Use this to create a temporary view.
+   */
+  temporary() {
+    return new q({
+      ...this.#e,
+      node: Q.cloneWith(this.#e.node, {
+        temporary: !0
+      })
+    });
+  }
+  materialized() {
+    return new q({
+      ...this.#e,
+      node: Q.cloneWith(this.#e.node, {
+        materialized: !0
+      })
+    });
+  }
+  /**
+   * Only implemented on some dialects like SQLite. On most dialects, use {@link orReplace}.
+   */
+  ifNotExists() {
+    return new q({
+      ...this.#e,
+      node: Q.cloneWith(this.#e.node, {
+        ifNotExists: !0
+      })
+    });
+  }
+  orReplace() {
+    return new q({
+      ...this.#e,
+      node: Q.cloneWith(this.#e.node, {
+        orReplace: !0
+      })
+    });
+  }
+  columns(e) {
+    return new q({
+      ...this.#e,
+      node: Q.cloneWith(this.#e.node, {
+        columns: e.map(Ye)
+      })
+    });
+  }
+  /**
+   * Sets the select query or a `values` statement that creates the view.
+   *
+   * WARNING!
+   * Some dialects don't support parameterized queries in DDL statements and therefore
+   * the query or raw {@link sql } expression passed here is interpolated into a single
+   * string opening an SQL injection vulnerability. DO NOT pass unchecked user input
+   * into the query or raw expression passed to this method!
+   */
+  as(e) {
+    const n = e.withPlugin(new ht()).toOperationNode();
+    return new q({
+      ...this.#e,
+      node: Q.cloneWith(this.#e.node, {
+        as: n
+      })
+    });
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e.executor.transformQuery(this.#e.node, this.#e.queryId);
+  }
+  compile() {
+    return this.#e.executor.compileQuery(this.toOperationNode(), this.#e.queryId);
+  }
+  async execute() {
+    await this.#e.executor.executeQuery(this.compile());
+  }
+}
+const oe = r({
+  is(t) {
+    return t.kind === "DropViewNode";
+  },
+  create(t) {
+    return r({
+      kind: "DropViewNode",
+      name: G.create(t)
+    });
+  },
+  cloneWith(t, e) {
+    return r({
+      ...t,
+      ...e
+    });
+  }
+});
+class B {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  materialized() {
+    return new B({
+      ...this.#e,
+      node: oe.cloneWith(this.#e.node, {
+        materialized: !0
+      })
+    });
+  }
+  ifExists() {
+    return new B({
+      ...this.#e,
+      node: oe.cloneWith(this.#e.node, {
+        ifExists: !0
+      })
+    });
+  }
+  cascade() {
+    return new B({
+      ...this.#e,
+      node: oe.cloneWith(this.#e.node, {
+        cascade: !0
+      })
+    });
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e.executor.transformQuery(this.#e.node, this.#e.queryId);
+  }
+  compile() {
+    return this.#e.executor.compileQuery(this.toOperationNode(), this.#e.queryId);
+  }
+  async execute() {
+    await this.#e.executor.executeQuery(this.compile());
+  }
+}
+const Re = r({
+  is(t) {
+    return t.kind === "CreateTypeNode";
+  },
+  create(t) {
+    return r({
+      kind: "CreateTypeNode",
+      name: t
+    });
+  },
+  cloneWithEnum(t, e) {
+    return r({
+      ...t,
+      enum: qe.create(e.map(ae.createImmediate))
+    });
+  }
+});
+class Ce {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  toOperationNode() {
+    return this.#e.executor.transformQuery(this.#e.node, this.#e.queryId);
+  }
+  /**
+   * Creates an anum type.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * db.schema.createType('species').asEnum(['cat', 'dog', 'frog'])
+   * ```
+   */
+  asEnum(e) {
+    return new Ce({
+      ...this.#e,
+      node: Re.cloneWithEnum(this.#e.node, e)
+    });
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  compile() {
+    return this.#e.executor.compileQuery(this.toOperationNode(), this.#e.queryId);
+  }
+  async execute() {
+    await this.#e.executor.executeQuery(this.compile());
+  }
+}
+const Le = r({
+  is(t) {
+    return t.kind === "DropTypeNode";
+  },
+  create(t) {
+    return r({
+      kind: "DropTypeNode",
+      name: t
+    });
+  },
+  cloneWith(t, e) {
+    return r({
+      ...t,
+      ...e
+    });
+  }
+});
+class Oe {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  ifExists() {
+    return new Oe({
+      ...this.#e,
+      node: Le.cloneWith(this.#e.node, {
+        ifExists: !0
+      })
+    });
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e.executor.transformQuery(this.#e.node, this.#e.queryId);
+  }
+  compile() {
+    return this.#e.executor.compileQuery(this.toOperationNode(), this.#e.queryId);
+  }
+  async execute() {
+    await this.#e.executor.executeQuery(this.compile());
+  }
+}
+function Ie(t) {
+  if (t.includes(".")) {
+    const n = t.split(".").map(dt);
+    if (n.length === 2)
+      return G.createWithSchema(n[0], n[1]);
+    throw new Error(`invalid schemable identifier ${t}`);
+  } else
+    return G.create(t);
+}
+function dt(t) {
+  return t.trim();
+}
+const se = r({
+  is(t) {
+    return t.kind === "RefreshMaterializedViewNode";
+  },
+  create(t) {
+    return r({
+      kind: "RefreshMaterializedViewNode",
+      name: G.create(t)
+    });
+  },
+  cloneWith(t, e) {
+    return r({
+      ...t,
+      ...e
+    });
+  }
+});
+class _ {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  /**
+   * Adds the "concurrently" modifier.
+   *
+   * Use this to refresh the view without locking out concurrent selects on the materialized view.
+   *
+   * WARNING!
+   * This cannot be used with the "with no data" modifier.
+   */
+  concurrently() {
+    return new _({
+      ...this.#e,
+      node: se.cloneWith(this.#e.node, {
+        concurrently: !0,
+        withNoData: !1
+      })
+    });
+  }
+  /**
+   * Adds the "with data" modifier.
+   *
+   * If specified (or defaults) the backing query is executed to provide the new data, and the materialized view is left in a scannable state
+   */
+  withData() {
+    return new _({
+      ...this.#e,
+      node: se.cloneWith(this.#e.node, {
+        withNoData: !1
+      })
+    });
+  }
+  /**
+   * Adds the "with no data" modifier.
+   *
+   * If specified, no new data is generated and the materialized view is left in an unscannable state.
+   *
+   * WARNING!
+   * This cannot be used with the "concurrently" modifier.
+   */
+  withNoData() {
+    return new _({
+      ...this.#e,
+      node: se.cloneWith(this.#e.node, {
+        withNoData: !0,
+        concurrently: !1
+      })
+    });
+  }
+  /**
+   * Simply calls the provided function passing `this` as the only argument. `$call` returns
+   * what the provided function returns.
+   */
+  $call(e) {
+    return e(this);
+  }
+  toOperationNode() {
+    return this.#e.executor.transformQuery(this.#e.node, this.#e.queryId);
+  }
+  compile() {
+    return this.#e.executor.compileQuery(this.toOperationNode(), this.#e.queryId);
+  }
+  async execute() {
+    await this.#e.executor.executeQuery(this.compile());
+  }
+}
+class ee {
+  #e;
+  constructor(e) {
+    this.#e = e;
+  }
+  /**
+   * Create a new table.
+   *
+   * ### Examples
+   *
+   * This example creates a new table with columns `id`, `first_name`,
+   * `last_name` and `gender`:
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('person')
+   *   .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
+   *   .addColumn('first_name', 'varchar', col => col.notNull())
+   *   .addColumn('last_name', 'varchar', col => col.notNull())
+   *   .addColumn('gender', 'varchar')
+   *   .execute()
+   * ```
+   *
+   * This example creates a table with a foreign key. Not all database
+   * engines support column-level foreign key constraint definitions.
+   * For example if you are using MySQL 5.X see the next example after
+   * this one.
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('pet')
+   *   .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
+   *   .addColumn('owner_id', 'integer', col => col
+   *     .references('person.id')
+   *     .onDelete('cascade')
+   *   )
+   *   .execute()
+   * ```
+   *
+   * This example adds a foreign key constraint for a columns just
+   * like the previous example, but using a table-level statement.
+   * On MySQL 5.X you need to define foreign key constraints like
+   * this:
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('pet')
+   *   .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
+   *   .addColumn('owner_id', 'integer')
+   *   .addForeignKeyConstraint(
+   *     'pet_owner_id_foreign', ['owner_id'], 'person', ['id'],
+   *     (constraint) => constraint.onDelete('cascade')
+   *   )
+   *   .execute()
+   * ```
+   */
+  createTable(e) {
+    return new l({
+      queryId: d(),
+      executor: this.#e,
+      node: p.create(E(e))
+    });
+  }
+  /**
+   * Drop a table.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .dropTable('person')
+   *   .execute()
+   * ```
+   */
+  dropTable(e) {
+    return new de({
+      queryId: d(),
+      executor: this.#e,
+      node: fe.create(E(e))
+    });
+  }
+  /**
+   * Create a new index.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createIndex('person_full_name_unique_index')
+   *   .on('person')
+   *   .columns(['first_name', 'last_name'])
+   *   .execute()
+   * ```
+   */
+  createIndex(e) {
+    return new f({
+      queryId: d(),
+      executor: this.#e,
+      node: O.create(e)
+    });
+  }
+  /**
+   * Drop an index.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .dropIndex('person_full_name_unique_index')
+   *   .execute()
+   * ```
+   */
+  dropIndex(e) {
+    return new K({
+      queryId: d(),
+      executor: this.#e,
+      node: Z.create(e)
+    });
+  }
+  /**
+   * Create a new schema.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createSchema('some_schema')
+   *   .execute()
+   * ```
+   */
+  createSchema(e) {
+    return new We({
+      queryId: d(),
+      executor: this.#e,
+      node: ve.create(e)
+    });
+  }
+  /**
+   * Drop a schema.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .dropSchema('some_schema')
+   *   .execute()
+   * ```
+   */
+  dropSchema(e) {
+    return new he({
+      queryId: d(),
+      executor: this.#e,
+      node: ye.create(e)
+    });
+  }
+  /**
+   * Alter a table.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .alterTable('person')
+   *   .alterColumn('first_name', (ac) => ac.setDataType('text'))
+   *   .execute()
+   * ```
+   */
+  alterTable(e) {
+    return new ct({
+      queryId: d(),
+      executor: this.#e,
+      node: s.create(E(e))
+    });
+  }
+  /**
+   * Create a new view.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createView('dogs')
+   *   .orReplace()
+   *   .as(db.selectFrom('pet').selectAll().where('species', '=', 'dog'))
+   *   .execute()
+   * ```
+   */
+  createView(e) {
+    return new q({
+      queryId: d(),
+      executor: this.#e,
+      node: Q.create(e)
+    });
+  }
+  /**
+   * Refresh a materialized view.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .refreshMaterializedView('my_view')
+   *   .concurrently()
+   *   .execute()
+   * ```
+   */
+  refreshMaterializedView(e) {
+    return new _({
+      queryId: d(),
+      executor: this.#e,
+      node: se.create(e)
+    });
+  }
+  /**
+   * Drop a view.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .dropView('dogs')
+   *   .ifExists()
+   *   .execute()
+   * ```
+   */
+  dropView(e) {
+    return new B({
+      queryId: d(),
+      executor: this.#e,
+      node: oe.create(e)
+    });
+  }
+  /**
+   * Create a new type.
+   *
+   * Only some dialects like PostgreSQL have user-defined types.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .createType('species')
+   *   .asEnum(['dog', 'cat', 'frog'])
+   *   .execute()
+   * ```
+   */
+  createType(e) {
+    return new Ce({
+      queryId: d(),
+      executor: this.#e,
+      node: Re.create(Ie(e))
+    });
+  }
+  /**
+   * Drop a type.
+   *
+   * Only some dialects like PostgreSQL have user-defined types.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db.schema
+   *   .dropType('species')
+   *   .ifExists()
+   *   .execute()
+   * ```
+   */
+  dropType(e) {
+    return new Oe({
+      queryId: d(),
+      executor: this.#e,
+      node: Le.create(Ie(e))
+    });
+  }
+  /**
+   * Returns a copy of this schema module with the given plugin installed.
+   */
+  withPlugin(e) {
+    return new ee(this.#e.withPlugin(e));
+  }
+  /**
+   * Returns a copy of this schema module  without any plugins.
+   */
+  withoutPlugins() {
+    return new ee(this.#e.withoutPlugins());
+  }
+  /**
+   * See {@link QueryCreator.withSchema}
+   */
+  withSchema(e) {
+    return new ee(this.#e.withPluginAtFront(new pe(e)));
+  }
+}
+class lt {
+  /**
+   * Creates a dynamic reference to a column that is not know at compile time.
+   *
+   * Kysely is built in a way that by default you can't refer to tables or columns
+   * that are not actually visible in the current query and context. This is all
+   * done by TypeScript at compile time, which means that you need to know the
+   * columns and tables at compile time. This is not always the case of course.
+   *
+   * This method is meant to be used in those cases where the column names
+   * come from the user input or are not otherwise known at compile time.
+   *
+   * WARNING! Unlike values, column names are not escaped by the database engine
+   * or Kysely and if you pass in unchecked column names using this method, you
+   * create an SQL injection vulnerability. Always __always__ validate the user
+   * input before passing it to this method.
+   *
+   * There are couple of examples below for some use cases, but you can pass
+   * `ref` to other methods as well. If the types allow you to pass a `ref`
+   * value to some place, it should work.
+   *
+   * ### Examples
+   *
+   * Filter by a column not know at compile time:
+   *
+   * ```ts
+   * async function someQuery(filterColumn: string, filterValue: string) {
+   *   const { ref } = db.dynamic
+   *
+   *   return await db
+   *     .selectFrom('person')
+   *     .selectAll()
+   *     .where(ref(filterColumn), '=', filterValue)
+   *     .execute()
+   * }
+   *
+   * someQuery('first_name', 'Arnold')
+   * someQuery('person.last_name', 'Aniston')
+   * ```
+   *
+   * Order by a column not know at compile time:
+   *
+   * ```ts
+   * async function someQuery(orderBy: string) {
+   *   const { ref } = db.dynamic
+   *
+   *   return await db
+   *     .selectFrom('person')
+   *     .select('person.first_name as fn')
+   *     .orderBy(ref(orderBy))
+   *     .execute()
+   * }
+   *
+   * someQuery('fn')
+   * ```
+   *
+   * In this example we add selections dynamically:
+   *
+   * ```ts
+   * const { ref } = db.dynamic
+   *
+   * // Some column name provided by the user. Value not known at compile time.
+   * const columnFromUserInput: PossibleColumns = 'birthdate';
+   *
+   * // A type that lists all possible values `columnFromUserInput` can have.
+   * // You can use `keyof Person` if any column of an interface is allowed.
+   * type PossibleColumns = 'last_name' | 'first_name' | 'birthdate'
+   *
+   * const [person] = await db.selectFrom('person')
+   *   .select([
+   *     ref<PossibleColumns>(columnFromUserInput),
+   *     'id'
+   *   ])
+   *   .execute()
+   *
+   * // The resulting type contains all `PossibleColumns` as optional fields
+   * // because we cannot know which field was actually selected before
+   * // running the code.
+   * const lastName: string | null | undefined = person?.last_name
+   * const firstName: string | undefined = person?.first_name
+   * const birthDate: Date | null | undefined = person?.birthdate
+   *
+   * // The result type also contains the compile time selection `id`.
+   * person?.id
+   * ```
+   */
+  ref(e) {
+    return new je(e);
+  }
+  /**
+   * Creates a table reference to a table that's not fully known at compile time.
+   *
+   * The type `T` is allowed to be a union of multiple tables.
+   *
+   * <!-- siteExample("select", "Generic find query", 130) -->
+   *
+   * A generic type-safe helper function for finding a row by a column value:
+   *
+   * ```ts
+   * import { SelectType } from 'kysely'
+   * import { Database } from 'type-editor'
+   *
+   * async function getRowByColumn<
+   *   T extends keyof Database,
+   *   C extends keyof Database[T] & string,
+   *   V extends SelectType<Database[T][C]>,
+   * >(t: T, c: C, v: V) {
+   *   // We need to use the dynamic module since the table name
+   *   // is not known at compile time.
+   *   const { table, ref } = db.dynamic
+   *
+   *   return await db
+   *     .selectFrom(table(t).as('t'))
+   *     .selectAll()
+   *     .where(ref(c), '=', v)
+   *     .orderBy('t.id')
+   *     .executeTakeFirstOrThrow()
+   * }
+   *
+   * const person = await getRowByColumn('person', 'first_name', 'Arnold')
+   * ```
+   */
+  table(e) {
+    return new Xe(e);
+  }
+}
+class wt {
+  #e;
+  constructor(e) {
+    this.#e = e;
+  }
+  async provideConnection(e) {
+    const n = await this.#e.acquireConnection();
+    try {
+      return await e(n);
+    } finally {
+      await this.#e.releaseConnection(n);
+    }
+  }
+}
+class T extends Ze {
+  #e;
+  #t;
+  #r;
+  constructor(e, n, i, o = []) {
+    super(o), this.#e = e, this.#t = n, this.#r = i;
+  }
+  get adapter() {
+    return this.#t;
+  }
+  compileQuery(e, n) {
+    return this.#e.compileQuery(e, n);
+  }
+  provideConnection(e) {
+    return this.#r.provideConnection(e);
+  }
+  withPlugins(e) {
+    return new T(this.#e, this.#t, this.#r, [...this.plugins, ...e]);
+  }
+  withPlugin(e) {
+    return new T(this.#e, this.#t, this.#r, [...this.plugins, e]);
+  }
+  withPluginAtFront(e) {
+    return new T(this.#e, this.#t, this.#r, [e, ...this.plugins]);
+  }
+  withConnectionProvider(e) {
+    return new T(this.#e, this.#t, e, [...this.plugins]);
+  }
+  withoutPlugins() {
+    return new T(this.#e, this.#t, this.#r, []);
+  }
+}
+function me() {
+  return typeof performance < "u" && Ne(performance.now) ? performance.now() : Date.now();
+}
+class pt {
+  #e;
+  #t;
+  #r;
+  #i;
+  #n;
+  #o = /* @__PURE__ */ new WeakSet();
+  constructor(e, n) {
+    this.#i = !1, this.#e = e, this.#t = n;
+  }
+  async init() {
+    if (this.#n)
+      throw new Error("driver has already been destroyed");
+    this.#r || (this.#r = this.#e.init().then(() => {
+      this.#i = !0;
+    }).catch((e) => (this.#r = void 0, Promise.reject(e)))), await this.#r;
+  }
+  async acquireConnection() {
+    if (this.#n)
+      throw new Error("driver has already been destroyed");
+    this.#i || await this.init();
+    const e = await this.#e.acquireConnection();
+    return this.#o.has(e) || (this.#u() && this.#h(e), this.#o.add(e)), e;
+  }
+  async releaseConnection(e) {
+    await this.#e.releaseConnection(e);
+  }
+  beginTransaction(e, n) {
+    return this.#e.beginTransaction(e, n);
+  }
+  commitTransaction(e) {
+    return this.#e.commitTransaction(e);
+  }
+  rollbackTransaction(e) {
+    return this.#e.rollbackTransaction(e);
+  }
+  savepoint(e, n, i) {
+    if (this.#e.savepoint)
+      return this.#e.savepoint(e, n, i);
+    throw new Error("The `savepoint` method is not supported by this driver");
+  }
+  rollbackToSavepoint(e, n, i) {
+    if (this.#e.rollbackToSavepoint)
+      return this.#e.rollbackToSavepoint(e, n, i);
+    throw new Error("The `rollbackToSavepoint` method is not supported by this driver");
+  }
+  releaseSavepoint(e, n, i) {
+    if (this.#e.releaseSavepoint)
+      return this.#e.releaseSavepoint(e, n, i);
+    throw new Error("The `releaseSavepoint` method is not supported by this driver");
+  }
+  async destroy() {
+    this.#r && (await this.#r, this.#n || (this.#n = this.#e.destroy().catch((e) => (this.#n = void 0, Promise.reject(e)))), await this.#n);
+  }
+  #u() {
+    return this.#t.isLevelEnabled("query") || this.#t.isLevelEnabled("error");
+  }
+  // This method monkey patches the database connection's executeQuery method
+  // by adding logging code around it. Monkey patching is not pretty, but it's
+  // the best option in this case.
+  #h(e) {
+    const n = e.executeQuery, i = e.streamQuery, o = this;
+    e.executeQuery = async (u) => {
+      let h;
+      const C = me();
+      try {
+        return await n.call(e, u);
+      } catch (W) {
+        throw h = W, await o.#s(W, u, C), W;
+      } finally {
+        h || await o.#a(u, C);
+      }
+    }, e.streamQuery = async function* (u, h) {
+      let C;
+      const W = me();
+      try {
+        for await (const y of i.call(e, u, h))
+          yield y;
+      } catch (y) {
+        throw C = y, await o.#s(y, u, W), y;
+      } finally {
+        C || await o.#a(u, W, !0);
+      }
+    };
+  }
+  async #s(e, n, i) {
+    await this.#t.error(() => ({
+      level: "error",
+      error: e,
+      query: n,
+      queryDurationMillis: this.#c(i)
+    }));
+  }
+  async #a(e, n, i = !1) {
+    await this.#t.query(() => ({
+      level: "query",
+      isStream: i,
+      query: e,
+      queryDurationMillis: this.#c(n)
+    }));
+  }
+  #c(e) {
+    return me() - e;
+  }
+}
+const mt = () => {
+};
+class be {
+  #e;
+  #t;
+  constructor(e) {
+    this.#e = e;
+  }
+  async provideConnection(e) {
+    for (; this.#t; )
+      await this.#t.catch(mt);
+    return this.#t = this.#r(e).finally(() => {
+      this.#t = void 0;
+    }), this.#t;
+  }
+  // Run the runner in an async function to make sure it doesn't
+  // throw synchronous errors.
+  async #r(e) {
+    return await e(this.#e);
+  }
+}
+const yt = ["read only", "read write"], ft = [
+  "read uncommitted",
+  "read committed",
+  "repeatable read",
+  "serializable",
+  "snapshot"
+];
+function Ve(t) {
+  if (t.accessMode && !yt.includes(t.accessMode))
+    throw new Error(`invalid transaction access mode ${t.accessMode}`);
+  if (t.isolationLevel && !ft.includes(t.isolationLevel))
+    throw new Error(`invalid transaction isolation level ${t.isolationLevel}`);
+}
+const Nt = ["query", "error"];
+r(Nt);
+class xt {
+  #e;
+  #t;
+  constructor(e) {
+    Ne(e) ? (this.#t = e, this.#e = r({
+      query: !0,
+      error: !0
+    })) : (this.#t = Wt, this.#e = r({
+      query: e.includes("query"),
+      error: e.includes("error")
+    }));
+  }
+  isLevelEnabled(e) {
+    return this.#e[e];
+  }
+  async query(e) {
+    this.#e.query && await this.#t(e());
+  }
+  async error(e) {
+    this.#e.error && await this.#t(e());
+  }
+}
+function Wt(t) {
+  if (t.level === "query") {
+    const e = `kysely:query:${t.isStream ? "stream:" : ""}`;
+    console.log(`${e} ${t.query.sql}`), console.log(`${e} duration: ${t.queryDurationMillis.toFixed(1)}ms`);
+  } else t.level === "error" && (t.error instanceof Error ? console.error(`kysely:error: ${t.error.stack ?? t.error.message}`) : console.error(`kysely:error: ${JSON.stringify({
+    error: t.error,
+    query: t.query.sql,
+    queryDurationMillis: t.queryDurationMillis
+  })}`));
+}
+function Ct(t) {
+  return V(t) && Ne(t.compile);
+}
+Symbol.asyncDispose ??= /* @__PURE__ */ Symbol("Symbol.asyncDispose");
+class $ extends Ke {
+  #e;
+  constructor(e) {
+    let n, i;
+    if (Ot(e))
+      n = { executor: e.executor }, i = { ...e };
+    else {
+      const o = e.dialect, u = o.createDriver(), h = o.createQueryCompiler(), C = o.createAdapter(), W = new xt(e.log ?? []), y = new pt(u, W), J = new wt(y), ge = new T(h, C, J, e.plugins ?? []);
+      n = { executor: ge }, i = {
+        config: e,
+        executor: ge,
+        dialect: o,
+        driver: y
+      };
+    }
+    super(n), this.#e = r(i);
+  }
+  /**
+   * Returns the {@link SchemaModule} module for building database schema.
+   */
+  get schema() {
+    return new ee(this.#e.executor);
+  }
+  /**
+   * Returns a the {@link DynamicModule} module.
+   *
+   * The {@link DynamicModule} module can be used to bypass strict typing and
+   * passing in dynamic values for the queries.
+   */
+  get dynamic() {
+    return new lt();
+  }
+  /**
+   * Returns a {@link DatabaseIntrospector | database introspector}.
+   */
+  get introspection() {
+    return this.#e.dialect.createIntrospector(this.withoutPlugins());
+  }
+  case(e) {
+    return new Be({
+      node: _e.create(et(e) ? void 0 : Pe(e))
+    });
+  }
+  /**
+   * Returns a {@link FunctionModule} that can be used to write somewhat type-safe function
+   * calls.
+   *
+   * ```ts
+   * const { count } = db.fn
+   *
+   * await db.selectFrom('person')
+   *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+   *   .select([
+   *     'id',
+   *     count('pet.id').as('person_count'),
+   *   ])
+   *   .groupBy('person.id')
+   *   .having(count('pet.id'), '>', 10)
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * select "person"."id", count("pet"."id") as "person_count"
+   * from "person"
+   * inner join "pet" on "pet"."owner_id" = "person"."id"
+   * group by "person"."id"
+   * having count("pet"."id") > $1
+   * ```
+   *
+   * Why "somewhat" type-safe? Because the function calls are not bound to the
+   * current query context. They allow you to reference columns and tables that
+   * are not in the current query. E.g. remove the `innerJoin` from the previous
+   * query and TypeScript won't even complain.
+   *
+   * If you want to make the function calls fully type-safe, you can use the
+   * {@link ExpressionBuilder.fn} getter for a query context-aware, stricter {@link FunctionModule}.
+   *
+   * ```ts
+   * await db.selectFrom('person')
+   *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+   *   .select((eb) => [
+   *     'person.id',
+   *     eb.fn.count('pet.id').as('pet_count')
+   *   ])
+   *   .groupBy('person.id')
+   *   .having((eb) => eb.fn.count('pet.id'), '>', 10)
+   *   .execute()
+   * ```
+   */
+  get fn() {
+    return tt();
+  }
+  /**
+   * Creates a {@link TransactionBuilder} that can be used to run queries inside a transaction.
+   *
+   * The returned {@link TransactionBuilder} can be used to configure the transaction. The
+   * {@link TransactionBuilder.execute} method can then be called to run the transaction.
+   * {@link TransactionBuilder.execute} takes a function that is run inside the
+   * transaction. If the function throws an exception,
+   * 1. the exception is caught,
+   * 2. the transaction is rolled back, and
+   * 3. the exception is thrown again.
+   * Otherwise the transaction is committed.
+   *
+   * The callback function passed to the {@link TransactionBuilder.execute | execute}
+   * method gets the transaction object as its only argument. The transaction is
+   * of type {@link Transaction} which inherits {@link Kysely}. Any query
+   * started through the transaction object is executed inside the transaction.
+   *
+   * To run a controlled transaction, allowing you to commit and rollback manually,
+   * use {@link startTransaction} instead.
+   *
+   * ### Examples
+   *
+   * <!-- siteExample("transactions", "Simple transaction", 10) -->
+   *
+   * This example inserts two rows in a transaction. If an exception is thrown inside
+   * the callback passed to the `execute` method,
+   * 1. the exception is caught,
+   * 2. the transaction is rolled back, and
+   * 3. the exception is thrown again.
+   * Otherwise the transaction is committed.
+   *
+   * ```ts
+   * const catto = await db.transaction().execute(async (trx) => {
+   *   const jennifer = await trx.insertInto('person')
+   *     .values({
+   *       first_name: 'Jennifer',
+   *       last_name: 'Aniston',
+   *       age: 40,
+   *     })
+   *     .returning('id')
+   *     .executeTakeFirstOrThrow()
+   *
+   *   return await trx.insertInto('pet')
+   *     .values({
+   *       owner_id: jennifer.id,
+   *       name: 'Catto',
+   *       species: 'cat',
+   *       is_favorite: false,
+   *     })
+   *     .returningAll()
+   *     .executeTakeFirst()
+   * })
+   * ```
+   *
+   * Setting the isolation level:
+   *
+   * ```ts
+   * import type { Kysely } from 'kysely'
+   *
+   * await db
+   *   .transaction()
+   *   .setIsolationLevel('serializable')
+   *   .execute(async (trx) => {
+   *     await doStuff(trx)
+   *   })
+   *
+   * async function doStuff(kysely: typeof db) {
+   *   // ...
+   * }
+   * ```
+   */
+  transaction() {
+    return new le({ ...this.#e });
+  }
+  /**
+   * Creates a {@link ControlledTransactionBuilder} that can be used to run queries inside a controlled transaction.
+   *
+   * The returned {@link ControlledTransactionBuilder} can be used to configure the transaction.
+   * The {@link ControlledTransactionBuilder.execute} method can then be called
+   * to start the transaction and return a {@link ControlledTransaction}.
+   *
+   * A {@link ControlledTransaction} allows you to commit and rollback manually,
+   * execute savepoint commands. It extends {@link Transaction} which extends {@link Kysely},
+   * so you can run queries inside the transaction. Once the transaction is committed,
+   * or rolled back, it can't be used anymore - all queries will throw an error.
+   * This is to prevent accidentally running queries outside the transaction - where
+   * atomicity is not guaranteed anymore.
+   *
+   * ### Examples
+   *
+   * <!-- siteExample("transactions", "Controlled transaction", 11) -->
+   *
+   * A controlled transaction allows you to commit and rollback manually, execute
+   * savepoint commands, and queries in general.
+   *
+   * In this example we start a transaction, use it to insert two rows and then commit
+   * the transaction. If an error is thrown, we catch it and rollback the transaction.
+   *
+   * ```ts
+   * const trx = await db.startTransaction().execute()
+   *
+   * try {
+   *   const jennifer = await trx.insertInto('person')
+   *     .values({
+   *       first_name: 'Jennifer',
+   *       last_name: 'Aniston',
+   *       age: 40,
+   *     })
+   *     .returning('id')
+   *     .executeTakeFirstOrThrow()
+   *
+   *   const catto = await trx.insertInto('pet')
+   *     .values({
+   *       owner_id: jennifer.id,
+   *       name: 'Catto',
+   *       species: 'cat',
+   *       is_favorite: false,
+   *     })
+   *     .returningAll()
+   *     .executeTakeFirstOrThrow()
+   *
+   *   await trx.commit().execute()
+   *
+   *   // ...
+   * } catch (error) {
+   *   await trx.rollback().execute()
+   * }
+   * ```
+   *
+   * <!-- siteExample("transactions", "Controlled transaction /w savepoints", 12) -->
+   *
+   * A controlled transaction allows you to commit and rollback manually, execute
+   * savepoint commands, and queries in general.
+   *
+   * In this example we start a transaction, insert a person, create a savepoint,
+   * try inserting a toy and a pet, and if an error is thrown, we rollback to the
+   * savepoint. Eventually we release the savepoint, insert an audit record and
+   * commit the transaction. If an error is thrown, we catch it and rollback the
+   * transaction.
+   *
+   * ```ts
+   * const trx = await db.startTransaction().execute()
+   *
+   * try {
+   *   const jennifer = await trx
+   *     .insertInto('person')
+   *     .values({
+   *       first_name: 'Jennifer',
+   *       last_name: 'Aniston',
+   *       age: 40,
+   *     })
+   *     .returning('id')
+   *     .executeTakeFirstOrThrow()
+   *
+   *   const trxAfterJennifer = await trx.savepoint('after_jennifer').execute()
+   *
+   *   try {
+   *     const catto = await trxAfterJennifer
+   *       .insertInto('pet')
+   *       .values({
+   *         owner_id: jennifer.id,
+   *         name: 'Catto',
+   *         species: 'cat',
+   *       })
+   *       .returning('id')
+   *       .executeTakeFirstOrThrow()
+   *
+   *     await trxAfterJennifer
+   *       .insertInto('toy')
+   *       .values({ name: 'Bone', price: 1.99, pet_id: catto.id })
+   *       .execute()
+   *   } catch (error) {
+   *     await trxAfterJennifer.rollbackToSavepoint('after_jennifer').execute()
+   *   }
+   *
+   *   await trxAfterJennifer.releaseSavepoint('after_jennifer').execute()
+   *
+   *   await trx.insertInto('audit').values({ action: 'added Jennifer' }).execute()
+   *
+   *   await trx.commit().execute()
+   * } catch (error) {
+   *   await trx.rollback().execute()
+   * }
+   * ```
+   */
+  startTransaction() {
+    return new we({ ...this.#e });
+  }
+  /**
+   * Provides a kysely instance bound to a single database connection.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * await db
+   *   .connection()
+   *   .execute(async (db) => {
+   *     // `db` is an instance of `Kysely` that's bound to a single
+   *     // database connection. All queries executed through `db` use
+   *     // the same connection.
+   *     await doStuff(db)
+   *   })
+   *
+   * async function doStuff(kysely: typeof db) {
+   *   // ...
+   * }
+   * ```
+   */
+  connection() {
+    return new bt({ ...this.#e });
+  }
+  /**
+   * Returns a copy of this Kysely instance with the given plugin installed.
+   */
+  withPlugin(e) {
+    return new $({
+      ...this.#e,
+      executor: this.#e.executor.withPlugin(e)
+    });
+  }
+  /**
+   * Returns a copy of this Kysely instance without any plugins.
+   */
+  withoutPlugins() {
+    return new $({
+      ...this.#e,
+      executor: this.#e.executor.withoutPlugins()
+    });
+  }
+  /**
+   * @override
+   */
+  withSchema(e) {
+    return new $({
+      ...this.#e,
+      executor: this.#e.executor.withPluginAtFront(new pe(e))
+    });
+  }
+  /**
+   * Returns a copy of this Kysely instance with tables added to its
+   * database type.
+   *
+   * This method only modifies the types and doesn't affect any of the
+   * executed queries in any way.
+   *
+   * ### Examples
+   *
+   * The following example adds and uses a temporary table:
+   *
+   * ```ts
+   * await db.schema
+   *   .createTable('temp_table')
+   *   .temporary()
+   *   .addColumn('some_column', 'integer')
+   *   .execute()
+   *
+   * const tempDb = db.withTables<{
+   *   temp_table: {
+   *     some_column: number
+   *   }
+   * }>()
+   *
+   * await tempDb
+   *   .insertInto('temp_table')
+   *   .values({ some_column: 100 })
+   *   .execute()
+   * ```
+   */
+  withTables() {
+    return new $({ ...this.#e });
+  }
+  /**
+   * Releases all resources and disconnects from the database.
+   *
+   * You need to call this when you are done using the `Kysely` instance.
+   */
+  async destroy() {
+    await this.#e.driver.destroy();
+  }
+  /**
+   * Returns true if this `Kysely` instance is a transaction.
+   *
+   * You can also use `db instanceof Transaction`.
+   */
+  get isTransaction() {
+    return !1;
+  }
+  /**
+   * @internal
+   * @private
+   */
+  getExecutor() {
+    return this.#e.executor;
+  }
+  /**
+   * Executes a given compiled query or query builder.
+   *
+   * See {@link https://github.com/kysely-org/kysely/blob/master/site/docs/recipes/0004-splitting-query-building-and-execution.md#execute-compiled-queries splitting build, compile and execute code recipe} for more information.
+   */
+  executeQuery(e, n) {
+    n !== void 0 && rt("Passing `queryId` in `db.executeQuery` is deprecated and will result in a compile-time error in the future.");
+    const i = Ct(e) ? e.compile() : e;
+    return this.getExecutor().executeQuery(i);
+  }
+  async [Symbol.asyncDispose]() {
+    await this.destroy();
+  }
+}
+class R extends $ {
+  #e;
+  constructor(e) {
+    super(e), this.#e = e;
+  }
+  // The return type is `true` instead of `boolean` to make Kysely<DB>
+  // unassignable to Transaction<DB> while allowing assignment the
+  // other way around.
+  get isTransaction() {
+    return !0;
+  }
+  transaction() {
+    throw new Error("calling the transaction method for a Transaction is not supported");
+  }
+  connection() {
+    throw new Error("calling the connection method for a Transaction is not supported");
+  }
+  async destroy() {
+    throw new Error("calling the destroy method for a Transaction is not supported");
+  }
+  withPlugin(e) {
+    return new R({
+      ...this.#e,
+      executor: this.#e.executor.withPlugin(e)
+    });
+  }
+  withoutPlugins() {
+    return new R({
+      ...this.#e,
+      executor: this.#e.executor.withoutPlugins()
+    });
+  }
+  withSchema(e) {
+    return new R({
+      ...this.#e,
+      executor: this.#e.executor.withPluginAtFront(new pe(e))
+    });
+  }
+  withTables() {
+    return new R({ ...this.#e });
+  }
+}
+function Ot(t) {
+  return V(t) && V(t.config) && V(t.driver) && V(t.executor) && V(t.dialect);
+}
+class bt {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  async execute(e) {
+    return this.#e.executor.provideConnection(async (n) => {
+      const i = this.#e.executor.withConnectionProvider(new be(n)), o = new $({
+        ...this.#e,
+        executor: i
+      });
+      return await e(o);
+    });
+  }
+}
+class le {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  setAccessMode(e) {
+    return new le({
+      ...this.#e,
+      accessMode: e
+    });
+  }
+  setIsolationLevel(e) {
+    return new le({
+      ...this.#e,
+      isolationLevel: e
+    });
+  }
+  async execute(e) {
+    const { isolationLevel: n, accessMode: i, ...o } = this.#e, u = { isolationLevel: n, accessMode: i };
+    return Ve(u), this.#e.executor.provideConnection(async (h) => {
+      const C = this.#e.executor.withConnectionProvider(new be(h)), W = new R({
+        ...o,
+        executor: C
+      });
+      let y = !1;
+      try {
+        await this.#e.driver.beginTransaction(h, u), y = !0;
+        const J = await e(W);
+        return await this.#e.driver.commitTransaction(h), J;
+      } catch (J) {
+        throw y && await this.#e.driver.rollbackTransaction(h), J;
+      }
+    });
+  }
+}
+class we {
+  #e;
+  constructor(e) {
+    this.#e = r(e);
+  }
+  setAccessMode(e) {
+    return new we({
+      ...this.#e,
+      accessMode: e
+    });
+  }
+  setIsolationLevel(e) {
+    return new we({
+      ...this.#e,
+      isolationLevel: e
+    });
+  }
+  async execute() {
+    const { isolationLevel: e, accessMode: n, ...i } = this.#e, o = { isolationLevel: e, accessMode: n };
+    Ve(o);
+    const u = await nt(this.#e.executor);
+    return await this.#e.driver.beginTransaction(u.connection, o), new b({
+      ...i,
+      connection: u,
+      executor: this.#e.executor.withConnectionProvider(new be(u.connection))
+    });
+  }
+}
+class b extends R {
+  #e;
+  #t;
+  #r;
+  constructor(e) {
+    const n = { isCommitted: !1, isRolledBack: !1 };
+    e = {
+      ...e,
+      executor: new P(e.executor, n)
+    };
+    const { connection: i, ...o } = e;
+    super(o), this.#e = r(e), this.#r = n;
+    const u = d();
+    this.#t = (h) => e.executor.compileQuery(h, u);
+  }
+  get isCommitted() {
+    return this.#r.isCommitted;
+  }
+  get isRolledBack() {
+    return this.#r.isRolledBack;
+  }
+  /**
+   * Commits the transaction.
+   *
+   * See {@link rollback}.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * import type { Kysely } from 'kysely'
+   * import type { Database } from 'type-editor' // imaginary module
+   *
+   * const trx = await db.startTransaction().execute()
+   *
+   * try {
+   *   await doSomething(trx)
+   *
+   *   await trx.commit().execute()
+   * } catch (error) {
+   *   await trx.rollback().execute()
+   * }
+   *
+   * async function doSomething(kysely: Kysely<Database>) {}
+   * ```
+   */
+  commit() {
+    return M(this.#r), new X(async () => {
+      await this.#e.driver.commitTransaction(this.#e.connection.connection), this.#r.isCommitted = !0, this.#e.connection.release();
+    });
+  }
+  /**
+   * Rolls back the transaction.
+   *
+   * See {@link commit} and {@link rollbackToSavepoint}.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * import type { Kysely } from 'kysely'
+   * import type { Database } from 'type-editor' // imaginary module
+   *
+   * const trx = await db.startTransaction().execute()
+   *
+   * try {
+   *   await doSomething(trx)
+   *
+   *   await trx.commit().execute()
+   * } catch (error) {
+   *   await trx.rollback().execute()
+   * }
+   *
+   * async function doSomething(kysely: Kysely<Database>) {}
+   * ```
+   */
+  rollback() {
+    return M(this.#r), new X(async () => {
+      await this.#e.driver.rollbackTransaction(this.#e.connection.connection), this.#r.isRolledBack = !0, this.#e.connection.release();
+    });
+  }
+  /**
+   * Creates a savepoint with a given name.
+   *
+   * See {@link rollbackToSavepoint} and {@link releaseSavepoint}.
+   *
+   * For a type-safe experience, you should use the returned instance from now on.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * import type { Kysely } from 'kysely'
+   * import type { Database } from 'type-editor' // imaginary module
+   *
+   * const trx = await db.startTransaction().execute()
+   *
+   * await insertJennifer(trx)
+   *
+   * const trxAfterJennifer = await trx.savepoint('after_jennifer').execute()
+   *
+   * try {
+   *   await doSomething(trxAfterJennifer)
+   * } catch (error) {
+   *   await trxAfterJennifer.rollbackToSavepoint('after_jennifer').execute()
+   * }
+   *
+   * async function insertJennifer(kysely: Kysely<Database>) {}
+   * async function doSomething(kysely: Kysely<Database>) {}
+   * ```
+   */
+  savepoint(e) {
+    return M(this.#r), new X(async () => (await this.#e.driver.savepoint?.(this.#e.connection.connection, e, this.#t), new b({ ...this.#e })));
+  }
+  /**
+   * Rolls back to a savepoint with a given name.
+   *
+   * See {@link savepoint} and {@link releaseSavepoint}.
+   *
+   * You must use the same instance returned by {@link savepoint}, or
+   * escape the type-check by using `as any`.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * import type { Kysely } from 'kysely'
+   * import type { Database } from 'type-editor' // imaginary module
+   *
+   * const trx = await db.startTransaction().execute()
+   *
+   * await insertJennifer(trx)
+   *
+   * const trxAfterJennifer = await trx.savepoint('after_jennifer').execute()
+   *
+   * try {
+   *   await doSomething(trxAfterJennifer)
+   * } catch (error) {
+   *   await trxAfterJennifer.rollbackToSavepoint('after_jennifer').execute()
+   * }
+   *
+   * async function insertJennifer(kysely: Kysely<Database>) {}
+   * async function doSomething(kysely: Kysely<Database>) {}
+   * ```
+   */
+  rollbackToSavepoint(e) {
+    return M(this.#r), new X(async () => (await this.#e.driver.rollbackToSavepoint?.(this.#e.connection.connection, e, this.#t), new b({ ...this.#e })));
+  }
+  /**
+   * Releases a savepoint with a given name.
+   *
+   * See {@link savepoint} and {@link rollbackToSavepoint}.
+   *
+   * You must use the same instance returned by {@link savepoint}, or
+   * escape the type-check by using `as any`.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * import type { Kysely } from 'kysely'
+   * import type { Database } from 'type-editor' // imaginary module
+   *
+   * const trx = await db.startTransaction().execute()
+   *
+   * await insertJennifer(trx)
+   *
+   * const trxAfterJennifer = await trx.savepoint('after_jennifer').execute()
+   *
+   * try {
+   *   await doSomething(trxAfterJennifer)
+   * } catch (error) {
+   *   await trxAfterJennifer.rollbackToSavepoint('after_jennifer').execute()
+   * }
+   *
+   * await trxAfterJennifer.releaseSavepoint('after_jennifer').execute()
+   *
+   * await doSomethingElse(trx)
+   *
+   * async function insertJennifer(kysely: Kysely<Database>) {}
+   * async function doSomething(kysely: Kysely<Database>) {}
+   * async function doSomethingElse(kysely: Kysely<Database>) {}
+   * ```
+   */
+  releaseSavepoint(e) {
+    return M(this.#r), new X(async () => (await this.#e.driver.releaseSavepoint?.(this.#e.connection.connection, e, this.#t), new b({ ...this.#e })));
+  }
+  withPlugin(e) {
+    return new b({
+      ...this.#e,
+      executor: this.#e.executor.withPlugin(e)
+    });
+  }
+  withoutPlugins() {
+    return new b({
+      ...this.#e,
+      executor: this.#e.executor.withoutPlugins()
+    });
+  }
+  withSchema(e) {
+    return new b({
+      ...this.#e,
+      executor: this.#e.executor.withPluginAtFront(new pe(e))
+    });
+  }
+  withTables() {
+    return new b({ ...this.#e });
+  }
+}
+class X {
+  #e;
+  constructor(e) {
+    this.#e = e;
+  }
+  /**
+   * Executes the command.
+   */
+  async execute() {
+    return await this.#e();
+  }
+}
+function M(t) {
+  if (t.isCommitted)
+    throw new Error("Transaction is already committed");
+  if (t.isRolledBack)
+    throw new Error("Transaction is already rolled back");
+}
+class P {
+  #e;
+  #t;
+  constructor(e, n) {
+    e instanceof P ? this.#e = e.#e : this.#e = e, this.#t = n;
+  }
+  get adapter() {
+    return this.#e.adapter;
+  }
+  get plugins() {
+    return this.#e.plugins;
+  }
+  transformQuery(e, n) {
+    return this.#e.transformQuery(e, n);
+  }
+  compileQuery(e, n) {
+    return this.#e.compileQuery(e, n);
+  }
+  provideConnection(e) {
+    return this.#e.provideConnection(e);
+  }
+  executeQuery(e) {
+    return M(this.#t), this.#e.executeQuery(e);
+  }
+  stream(e, n) {
+    return M(this.#t), this.#e.stream(e, n);
+  }
+  withConnectionProvider(e) {
+    return new P(this.#e.withConnectionProvider(e), this.#t);
+  }
+  withPlugin(e) {
+    return new P(this.#e.withPlugin(e), this.#t);
+  }
+  withPlugins(e) {
+    return new P(this.#e.withPlugins(e), this.#t);
+  }
+  withPluginAtFront(e) {
+    return new P(this.#e.withPluginAtFront(e), this.#t);
+  }
+  withoutPlugins() {
+    return new P(this.#e.withoutPlugins(), this.#t);
+  }
+}
+export {
+  Le as $,
+  ct as A,
+  ne as B,
+  bt as C,
+  T as D,
+  F as E,
+  g as F,
+  Y as G,
+  s as H,
+  xe as I,
+  c as J,
+  $ as K,
+  O as L,
+  ve as M,
+  p as N,
+  it as O,
+  Re as P,
+  Q,
+  _ as R,
+  ee as S,
+  R as T,
+  se as U,
+  st as V,
+  Qe as W,
+  ie as X,
+  Z as Y,
+  ye as Z,
+  fe as _,
+  le as a,
+  oe as a0,
+  I as a1,
+  te as a2,
+  Te as a3,
+  U as a4,
+  ot as a5,
+  re as a6,
+  De as a7,
+  at as a8,
+  D as a9,
+  Ct as aa,
+  xt as ab,
+  we as b,
+  b as c,
+  X as d,
+  l as e,
+  Ce as f,
+  de as g,
+  Oe as h,
+  Ot as i,
+  f as j,
+  K as k,
+  We as l,
+  he as m,
+  a as n,
+  N as o,
+  q as p,
+  B as q,
+  Me as r,
+  j as s,
+  lt as t,
+  yt as u,
+  ft as v,
+  Ve as w,
+  wt as x,
+  be as y,
+  Ee as z
+};