diff --git a/jOOQ/src/main/java/org/jooq/CreateTriggerActionStep.java b/jOOQ/src/main/java/org/jooq/CreateTriggerActionStep.java
index 3ff37bb100..8cf25d7367 100644
--- a/jOOQ/src/main/java/org/jooq/CreateTriggerActionStep.java
+++ b/jOOQ/src/main/java/org/jooq/CreateTriggerActionStep.java
@@ -37,54 +37,58 @@
  */
 package org.jooq;
 
-import static org.jooq.SQLDialect.*;
 
-import java.util.*;
 
-import org.jetbrains.annotations.*;
 
-/**
- * A step in the construction of the <code>CREATE TRIGGER</code> statement.
- * <p>
- * <h3>Referencing <code>XYZ*Step</code> types directly from client code</h3>
- * <p>
- * It is usually not recommended to reference any <code>XYZ*Step</code> types
- * directly from client code, or assign them to local variables. When writing
- * dynamic SQL, creating a statement's components dynamically, and passing them
- * to the DSL API statically is usually a better choice. See the manual's
- * section about dynamic SQL for details: <a href=
- * "https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql">https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql</a>.
- * <p>
- * Drawbacks of referencing the <code>XYZ*Step</code> types directly:
- * <ul>
- * <li>They're operating on mutable implementations (as of jOOQ 3.x)</li>
- * <li>They're less composable and not easy to get right when dynamic SQL gets
- * complex</li>
- * <li>They're less readable</li>
- * <li>They might have binary incompatible changes between minor releases</li>
- * </ul>
- */
-@SuppressWarnings({ "unused" })
-public interface CreateTriggerActionStep {
 
-    /**
-     * Add the <code>STATEMENT</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerFinalStep statement(Statement... statement);
 
-    /**
-     * Add the <code>STATEMENT</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerFinalStep statement(Collection<? extends Statement> statement);
 
-    /**
-     * Add the <code>STATEMENT</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerFinalStep statement(Statement statement);
-}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/jOOQ/src/main/java/org/jooq/CreateTriggerEventOfStep.java b/jOOQ/src/main/java/org/jooq/CreateTriggerEventOfStep.java
index 761eb0233c..921bb6b887 100644
--- a/jOOQ/src/main/java/org/jooq/CreateTriggerEventOfStep.java
+++ b/jOOQ/src/main/java/org/jooq/CreateTriggerEventOfStep.java
@@ -37,61 +37,65 @@
  */
 package org.jooq;
 
-import static org.jooq.SQLDialect.*;
 
-import java.util.*;
 
-import org.jetbrains.annotations.*;
 
-/**
- * A step in the construction of the <code>CREATE TRIGGER</code> statement.
- * <p>
- * <h3>Referencing <code>XYZ*Step</code> types directly from client code</h3>
- * <p>
- * It is usually not recommended to reference any <code>XYZ*Step</code> types
- * directly from client code, or assign them to local variables. When writing
- * dynamic SQL, creating a statement's components dynamically, and passing them
- * to the DSL API statically is usually a better choice. See the manual's
- * section about dynamic SQL for details: <a href=
- * "https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql">https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql</a>.
- * <p>
- * Drawbacks of referencing the <code>XYZ*Step</code> types directly:
- * <ul>
- * <li>They're operating on mutable implementations (as of jOOQ 3.x)</li>
- * <li>They're less composable and not easy to get right when dynamic SQL gets
- * complex</li>
- * <li>They're less readable</li>
- * <li>They might have binary incompatible changes between minor releases</li>
- * </ul>
- */
-@SuppressWarnings({ "unused" })
-public interface CreateTriggerEventOfStep extends CreateTriggerEventOrStep {
 
-    /**
-     * Add the <code>OF</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerEventOrStep of(String... of);
 
-    /**
-     * Add the <code>OF</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerEventOrStep of(Name... of);
 
-    /**
-     * Add the <code>OF</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerEventOrStep of(Field<?>... of);
 
-    /**
-     * Add the <code>OF</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerEventOrStep of(Collection<? extends Field<?>> of);
-}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/jOOQ/src/main/java/org/jooq/CreateTriggerEventOnStep.java b/jOOQ/src/main/java/org/jooq/CreateTriggerEventOnStep.java
index 0b519727e4..8cf25d7367 100644
--- a/jOOQ/src/main/java/org/jooq/CreateTriggerEventOnStep.java
+++ b/jOOQ/src/main/java/org/jooq/CreateTriggerEventOnStep.java
@@ -37,54 +37,58 @@
  */
 package org.jooq;
 
-import static org.jooq.SQLDialect.*;
 
-import java.util.*;
 
-import org.jetbrains.annotations.*;
 
-/**
- * A step in the construction of the <code>CREATE TRIGGER</code> statement.
- * <p>
- * <h3>Referencing <code>XYZ*Step</code> types directly from client code</h3>
- * <p>
- * It is usually not recommended to reference any <code>XYZ*Step</code> types
- * directly from client code, or assign them to local variables. When writing
- * dynamic SQL, creating a statement's components dynamically, and passing them
- * to the DSL API statically is usually a better choice. See the manual's
- * section about dynamic SQL for details: <a href=
- * "https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql">https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql</a>.
- * <p>
- * Drawbacks of referencing the <code>XYZ*Step</code> types directly:
- * <ul>
- * <li>They're operating on mutable implementations (as of jOOQ 3.x)</li>
- * <li>They're less composable and not easy to get right when dynamic SQL gets
- * complex</li>
- * <li>They're less readable</li>
- * <li>They might have binary incompatible changes between minor releases</li>
- * </ul>
- */
-@SuppressWarnings({ "unused" })
-public interface CreateTriggerEventOnStep {
 
-    /**
-     * Add the <code>ON</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerReferencingStep on(@Stringly.Name String on);
 
-    /**
-     * Add the <code>ON</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerReferencingStep on(Name on);
 
-    /**
-     * Add the <code>ON</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerReferencingStep on(Table<?> on);
-}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/jOOQ/src/main/java/org/jooq/CreateTriggerEventOrStep.java b/jOOQ/src/main/java/org/jooq/CreateTriggerEventOrStep.java
index f6301c02e9..8cf25d7367 100644
--- a/jOOQ/src/main/java/org/jooq/CreateTriggerEventOrStep.java
+++ b/jOOQ/src/main/java/org/jooq/CreateTriggerEventOrStep.java
@@ -37,54 +37,58 @@
  */
 package org.jooq;
 
-import static org.jooq.SQLDialect.*;
 
-import java.util.*;
 
-import org.jetbrains.annotations.*;
 
-/**
- * A step in the construction of the <code>CREATE TRIGGER</code> statement.
- * <p>
- * <h3>Referencing <code>XYZ*Step</code> types directly from client code</h3>
- * <p>
- * It is usually not recommended to reference any <code>XYZ*Step</code> types
- * directly from client code, or assign them to local variables. When writing
- * dynamic SQL, creating a statement's components dynamically, and passing them
- * to the DSL API statically is usually a better choice. See the manual's
- * section about dynamic SQL for details: <a href=
- * "https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql">https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql</a>.
- * <p>
- * Drawbacks of referencing the <code>XYZ*Step</code> types directly:
- * <ul>
- * <li>They're operating on mutable implementations (as of jOOQ 3.x)</li>
- * <li>They're less composable and not easy to get right when dynamic SQL gets
- * complex</li>
- * <li>They're less readable</li>
- * <li>They might have binary incompatible changes between minor releases</li>
- * </ul>
- */
-@SuppressWarnings({ "unused" })
-public interface CreateTriggerEventOrStep extends CreateTriggerEventOnStep {
 
-    /**
-     * Add the <code>OR INSERT</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerEventOrStep orInsert();
 
-    /**
-     * Add the <code>OR UPDATE</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerEventOfStep orUpdate();
 
-    /**
-     * Add the <code>OR DELETE</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerEventOrStep orDelete();
-}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/jOOQ/src/main/java/org/jooq/CreateTriggerEventStep.java b/jOOQ/src/main/java/org/jooq/CreateTriggerEventStep.java
index 84ac21778b..4e748fe93b 100644
--- a/jOOQ/src/main/java/org/jooq/CreateTriggerEventStep.java
+++ b/jOOQ/src/main/java/org/jooq/CreateTriggerEventStep.java
@@ -37,96 +37,100 @@
  */
 package org.jooq;
 
-import static org.jooq.SQLDialect.*;
 
-import java.util.*;
 
-import org.jetbrains.annotations.*;
 
-/**
- * A step in the construction of the <code>CREATE TRIGGER</code> statement.
- * <p>
- * <h3>Referencing <code>XYZ*Step</code> types directly from client code</h3>
- * <p>
- * It is usually not recommended to reference any <code>XYZ*Step</code> types
- * directly from client code, or assign them to local variables. When writing
- * dynamic SQL, creating a statement's components dynamically, and passing them
- * to the DSL API statically is usually a better choice. See the manual's
- * section about dynamic SQL for details: <a href=
- * "https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql">https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql</a>.
- * <p>
- * Drawbacks of referencing the <code>XYZ*Step</code> types directly:
- * <ul>
- * <li>They're operating on mutable implementations (as of jOOQ 3.x)</li>
- * <li>They're less composable and not easy to get right when dynamic SQL gets
- * complex</li>
- * <li>They're less readable</li>
- * <li>They might have binary incompatible changes between minor releases</li>
- * </ul>
- */
-@SuppressWarnings({ "unused" })
-public interface CreateTriggerEventStep {
 
-    /**
-     * Add the <code>BEFORE INSERT</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerEventOrStep beforeInsert();
 
-    /**
-     * Add the <code>AFTER INSERT</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerEventOrStep afterInsert();
 
-    /**
-     * Add the <code>INSTEAD OF INSERT</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerEventOrStep insteadOfInsert();
 
-    /**
-     * Add the <code>BEFORE UPDATE</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerEventOfStep beforeUpdate();
 
-    /**
-     * Add the <code>AFTER UPDATE</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerEventOfStep afterUpdate();
 
-    /**
-     * Add the <code>INSTEAD OF UPDATE</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerEventOfStep insteadOfUpdate();
 
-    /**
-     * Add the <code>BEFORE DELETE</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerEventOrStep beforeDelete();
 
-    /**
-     * Add the <code>AFTER DELETE</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerEventOrStep afterDelete();
 
-    /**
-     * Add the <code>INSTEAD OF DELETE</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerEventOrStep insteadOfDelete();
-}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/jOOQ/src/main/java/org/jooq/CreateTriggerFinalStep.java b/jOOQ/src/main/java/org/jooq/CreateTriggerFinalStep.java
index 092178d39f..8017dfe66e 100644
--- a/jOOQ/src/main/java/org/jooq/CreateTriggerFinalStep.java
+++ b/jOOQ/src/main/java/org/jooq/CreateTriggerFinalStep.java
@@ -37,33 +37,37 @@
  */
 package org.jooq;
 
-import static org.jooq.SQLDialect.*;
 
-import java.util.*;
 
-import org.jetbrains.annotations.*;
 
-/**
- * A step in the construction of the <code>CREATE TRIGGER</code> statement.
- * <p>
- * <h3>Referencing <code>XYZ*Step</code> types directly from client code</h3>
- * <p>
- * It is usually not recommended to reference any <code>XYZ*Step</code> types
- * directly from client code, or assign them to local variables. When writing
- * dynamic SQL, creating a statement's components dynamically, and passing them
- * to the DSL API statically is usually a better choice. See the manual's
- * section about dynamic SQL for details: <a href=
- * "https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql">https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql</a>.
- * <p>
- * Drawbacks of referencing the <code>XYZ*Step</code> types directly:
- * <ul>
- * <li>They're operating on mutable implementations (as of jOOQ 3.x)</li>
- * <li>They're less composable and not easy to get right when dynamic SQL gets
- * complex</li>
- * <li>They're less readable</li>
- * <li>They might have binary incompatible changes between minor releases</li>
- * </ul>
- */
-@SuppressWarnings({ "unused" })
-public interface CreateTriggerFinalStep extends DDLQuery {
-}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/jOOQ/src/main/java/org/jooq/CreateTriggerForStep.java b/jOOQ/src/main/java/org/jooq/CreateTriggerForStep.java
index f1b5b15707..6312365c62 100644
--- a/jOOQ/src/main/java/org/jooq/CreateTriggerForStep.java
+++ b/jOOQ/src/main/java/org/jooq/CreateTriggerForStep.java
@@ -37,40 +37,44 @@
  */
 package org.jooq;
 
-import static org.jooq.SQLDialect.*;
 
-import java.util.*;
 
-import org.jetbrains.annotations.*;
 
-/**
- * A step in the construction of the <code>CREATE TRIGGER</code> statement.
- * <p>
- * <h3>Referencing <code>XYZ*Step</code> types directly from client code</h3>
- * <p>
- * It is usually not recommended to reference any <code>XYZ*Step</code> types
- * directly from client code, or assign them to local variables. When writing
- * dynamic SQL, creating a statement's components dynamically, and passing them
- * to the DSL API statically is usually a better choice. See the manual's
- * section about dynamic SQL for details: <a href=
- * "https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql">https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql</a>.
- * <p>
- * Drawbacks of referencing the <code>XYZ*Step</code> types directly:
- * <ul>
- * <li>They're operating on mutable implementations (as of jOOQ 3.x)</li>
- * <li>They're less composable and not easy to get right when dynamic SQL gets
- * complex</li>
- * <li>They're less readable</li>
- * <li>They might have binary incompatible changes between minor releases</li>
- * </ul>
- */
-@SuppressWarnings({ "unused" })
-public interface CreateTriggerForStep extends CreateTriggerWhenStep {
 
-    /**
-     * Add the <code>FOR EACH ROW</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerWhenStep forEachRow();
-}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/jOOQ/src/main/java/org/jooq/CreateTriggerReferencingStep.java b/jOOQ/src/main/java/org/jooq/CreateTriggerReferencingStep.java
index 51a78b4e3c..921bb6b887 100644
--- a/jOOQ/src/main/java/org/jooq/CreateTriggerReferencingStep.java
+++ b/jOOQ/src/main/java/org/jooq/CreateTriggerReferencingStep.java
@@ -37,61 +37,65 @@
  */
 package org.jooq;
 
-import static org.jooq.SQLDialect.*;
 
-import java.util.*;
 
-import org.jetbrains.annotations.*;
 
-/**
- * A step in the construction of the <code>CREATE TRIGGER</code> statement.
- * <p>
- * <h3>Referencing <code>XYZ*Step</code> types directly from client code</h3>
- * <p>
- * It is usually not recommended to reference any <code>XYZ*Step</code> types
- * directly from client code, or assign them to local variables. When writing
- * dynamic SQL, creating a statement's components dynamically, and passing them
- * to the DSL API statically is usually a better choice. See the manual's
- * section about dynamic SQL for details: <a href=
- * "https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql">https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql</a>.
- * <p>
- * Drawbacks of referencing the <code>XYZ*Step</code> types directly:
- * <ul>
- * <li>They're operating on mutable implementations (as of jOOQ 3.x)</li>
- * <li>They're less composable and not easy to get right when dynamic SQL gets
- * complex</li>
- * <li>They're less readable</li>
- * <li>They might have binary incompatible changes between minor releases</li>
- * </ul>
- */
-@SuppressWarnings({ "unused" })
-public interface CreateTriggerReferencingStep extends CreateTriggerForStep {
 
-    /**
-     * Add the <code>REFERENCING OLD AS</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerReferencingStep referencingOldAs(@Stringly.Name String referencingOldAs);
 
-    /**
-     * Add the <code>REFERENCING OLD AS</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerReferencingStep referencingOldAs(Name referencingOldAs);
 
-    /**
-     * Add the <code>REFERENCING NEW AS</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerReferencingStep referencingNewAs(@Stringly.Name String referencingNewAs);
 
-    /**
-     * Add the <code>REFERENCING NEW AS</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerReferencingStep referencingNewAs(Name referencingNewAs);
-}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/jOOQ/src/main/java/org/jooq/CreateTriggerWhenStep.java b/jOOQ/src/main/java/org/jooq/CreateTriggerWhenStep.java
index fd9372fdce..9183e4630a 100644
--- a/jOOQ/src/main/java/org/jooq/CreateTriggerWhenStep.java
+++ b/jOOQ/src/main/java/org/jooq/CreateTriggerWhenStep.java
@@ -37,101 +37,105 @@
  */
 package org.jooq;
 
-import static org.jooq.SQLDialect.*;
 
-import java.util.*;
 
-import org.jetbrains.annotations.*;
 
-/**
- * A step in the construction of the <code>CREATE TRIGGER</code> statement.
- * <p>
- * <h3>Referencing <code>XYZ*Step</code> types directly from client code</h3>
- * <p>
- * It is usually not recommended to reference any <code>XYZ*Step</code> types
- * directly from client code, or assign them to local variables. When writing
- * dynamic SQL, creating a statement's components dynamically, and passing them
- * to the DSL API statically is usually a better choice. See the manual's
- * section about dynamic SQL for details: <a href=
- * "https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql">https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql</a>.
- * <p>
- * Drawbacks of referencing the <code>XYZ*Step</code> types directly:
- * <ul>
- * <li>They're operating on mutable implementations (as of jOOQ 3.x)</li>
- * <li>They're less composable and not easy to get right when dynamic SQL gets
- * complex</li>
- * <li>They're less readable</li>
- * <li>They might have binary incompatible changes between minor releases</li>
- * </ul>
- */
-@SuppressWarnings({ "unused" })
-public interface CreateTriggerWhenStep extends CreateTriggerActionStep {
 
-    /**
-     * Add the <code>WHEN</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerActionStep when(Field<Boolean> when);
 
-    /**
-     * Add the <code>WHEN</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerActionStep when(Condition... when);
 
-    /**
-     * Add the <code>WHEN</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerActionStep when(Collection<? extends Condition> when);
 
-    /**
-     * Add the <code>WHEN</code> clause to the <code>CREATE TRIGGER</code> statement.
-     */
-    @Support
-    @NotNull
-    CreateTriggerActionStep when(Condition when);
 
-    /**
-     * Add the <code>WHEN</code> clause to the <code>CREATE TRIGGER</code> statement.
-     *
-     * @see SQL
-     */
-    @Support
-    @PlainSQL
-    @NotNull
-    CreateTriggerActionStep when(@Stringly.SQL String when, QueryPart... parts);
 
-    /**
-     * Add the <code>WHEN</code> clause to the <code>CREATE TRIGGER</code> statement.
-     *
-     * @see SQL
-     */
-    @Support
-    @PlainSQL
-    @NotNull
-    CreateTriggerActionStep when(@Stringly.SQL String when, Object... bindings);
 
-    /**
-     * Add the <code>WHEN</code> clause to the <code>CREATE TRIGGER</code> statement.
-     *
-     * @see SQL
-     */
-    @Support
-    @PlainSQL
-    @NotNull
-    CreateTriggerActionStep when(@Stringly.SQL String when);
 
-    /**
-     * Add the <code>WHEN</code> clause to the <code>CREATE TRIGGER</code> statement.
-     *
-     * @see SQL
-     */
-    @Support
-    @PlainSQL
-    @NotNull
-    CreateTriggerActionStep when(SQL when);
-}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/jOOQ/src/main/java/org/jooq/DropTriggerFinalStep.java b/jOOQ/src/main/java/org/jooq/DropTriggerFinalStep.java
index 38750b9ecd..8017dfe66e 100644
--- a/jOOQ/src/main/java/org/jooq/DropTriggerFinalStep.java
+++ b/jOOQ/src/main/java/org/jooq/DropTriggerFinalStep.java
@@ -37,33 +37,37 @@
  */
 package org.jooq;
 
-import static org.jooq.SQLDialect.*;
 
-import java.util.*;
 
-import org.jetbrains.annotations.*;
 
-/**
- * A step in the construction of the <code>DROP TRIGGER</code> statement.
- * <p>
- * <h3>Referencing <code>XYZ*Step</code> types directly from client code</h3>
- * <p>
- * It is usually not recommended to reference any <code>XYZ*Step</code> types
- * directly from client code, or assign them to local variables. When writing
- * dynamic SQL, creating a statement's components dynamically, and passing them
- * to the DSL API statically is usually a better choice. See the manual's
- * section about dynamic SQL for details: <a href=
- * "https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql">https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql</a>.
- * <p>
- * Drawbacks of referencing the <code>XYZ*Step</code> types directly:
- * <ul>
- * <li>They're operating on mutable implementations (as of jOOQ 3.x)</li>
- * <li>They're less composable and not easy to get right when dynamic SQL gets
- * complex</li>
- * <li>They're less readable</li>
- * <li>They might have binary incompatible changes between minor releases</li>
- * </ul>
- */
-@SuppressWarnings({ "unused" })
-public interface DropTriggerFinalStep extends DDLQuery {
-}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+