/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *  https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Other licenses:
 * -----------------------------------------------------------------------------
 * Commercial licenses for this work are available. These replace the above
 * ASL 2.0 and offer limited warranties, support, maintenance, and commercial
 * database integrations.
 *
 * For more information, please visit: https://www.jooq.org/legal/licensing
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */
package org.jooq.impl;

import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableCollection;
import static java.util.Collections.unmodifiableList;
import static java.util.Collections.unmodifiableMap;
import static org.jooq.impl.DSL.keyword;

import java.math.BigDecimal;
import java.sql.Date;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.function.BiPredicate;
import java.util.function.Predicate;
import java.util.stream.Collector;

// ...
import org.jooq.Catalog;
import org.jooq.CheckReturnValue;
import org.jooq.Collation;
import org.jooq.Comment;
import org.jooq.CommonTableExpression;
import org.jooq.Comparator;
import org.jooq.Condition;
import org.jooq.Constraint;
import org.jooq.DDLQuery;
import org.jooq.DMLQuery;
import org.jooq.DataType;
import org.jooq.DatePart;
import org.jooq.Domain;
import org.jooq.Field;
import org.jooq.FieldOrRow;
import org.jooq.FieldOrRowOrSelect;
import org.jooq.Function0;
import org.jooq.Function1;
import org.jooq.Function10;
import org.jooq.Function11;
import org.jooq.Function12;
import org.jooq.Function13;
import org.jooq.Function14;
import org.jooq.Function15;
import org.jooq.Function16;
import org.jooq.Function17;
import org.jooq.Function18;
import org.jooq.Function19;
import org.jooq.Function2;
import org.jooq.Function20;
import org.jooq.Function21;
import org.jooq.Function22;
import org.jooq.Function3;
import org.jooq.Function4;
import org.jooq.Function5;
import org.jooq.Function6;
import org.jooq.Function7;
import org.jooq.Function8;
import org.jooq.Function9;
import org.jooq.Geometry;
import org.jooq.GroupField;
import org.jooq.Index;
import org.jooq.JSON;
import org.jooq.JSONB;
import org.jooq.JSONEntry;
import org.jooq.Keyword;
// ...
import org.jooq.Name;
import org.jooq.Operator;
import org.jooq.OrderField;
import org.jooq.Param;
import org.jooq.Parameter;
import org.jooq.Privilege;
// ...
import org.jooq.Query;
import org.jooq.QueryPart;
import org.jooq.Record;
import org.jooq.Record1;
// ...
import org.jooq.Result;
import org.jooq.ResultQuery;
import org.jooq.Role;
import org.jooq.Row;
import org.jooq.RowCountQuery;
import org.jooq.RowId;
import org.jooq.SQL;
import org.jooq.SQLDialect;
import org.jooq.Schema;
import org.jooq.Select;
import org.jooq.SelectFieldOrAsterisk;
import org.jooq.Sequence;
import org.jooq.SortField;
import org.jooq.Spatial;
import org.jooq.Statement;
import org.jooq.Table;
import org.jooq.TableElement;
import org.jooq.TableLike;
// ...
import org.jooq.Type;
// ...
import org.jooq.WindowDefinition;
import org.jooq.WindowSpecification;
import org.jooq.XML;
import org.jooq.XMLAttributes;
import org.jooq.conf.Settings;
import org.jooq.types.DayToSecond;
// ...

import org.jetbrains.annotations.ApiStatus.Experimental;
import org.jetbrains.annotations.ApiStatus.Internal;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;


/**
 * A draft of the new query object model API.
 * <p>
 * <strong>This API is EXPERIMENTAL. Use at your own risk.</strong>
 * <p>
 * <h3>Purpose</h3>
 * <p>
 * This class provides a single namespace for jOOQ's query object model API.
 * Every {@link QueryPart} from the DSL API has a matching {@link QueryPart}
 * representation in this query object model API, and a shared internal
 * implementation in the <code>org.jooq.impl</code> package, that covers both
 * the DSL and model API functionality.
 * <p>
 * The goal of this model API is to allow for expression tree transformations
 * via {@link QueryPart#$replace(Replacer)} as well as via per-querypart
 * methods, such as for example {@link Substring#$startingPosition(Field)}, and
 * traversals via {@link QueryPart#$traverse(Traverser)} that are independent of
 * the DSL API that would otherwise be too noisy for this task.
 * <p>
 * <h3>Design</h3>
 * <p>
 * In order to avoid conflicts between the model API and the DSL API, all model
 * API in this class follows these naming conventions:
 * <ul>
 * <li>All public model API types are nested in the {@link QOM} class, whereas
 * DSL API types are top level types in the <code>org.jooq</code> package.</li>
 * <li>All accessor methods and their corresponding "immutable setters"
 * (returning a copy containing the modification) are named
 * <code>$property()</code>, e.g. {@link Substring#$startingPosition()} and
 * {@link Substring#$startingPosition(Field)}.</li>
 * <li>All private model API utility types are named <code>UXyz</code>, e.g.
 * {@link UEmpty}</li>
 * </ul>
 * <p>
 * <h3>Limitations</h3>
 * <p>
 * The API offers public access to jOOQ's internal representation, and as such,
 * is prone to incompatible changes between minor releases, in addition to the
 * incompatible changes that may arise due to this API being experimental. In
 * this experimental stage, the following limitations are accepted:
 * <ul>
 * <li>Not all {@link QueryPart} implementations have a corresponding public
 * {@link QueryPart} type yet, but may just implement the API via a
 * {@link UEmpty} or {@link UNotYetImplemented} subtype, and may not provide
 * access to contents via accessor methods.</li>
 * <li>Some child elements of a {@link QueryPart} may not yet be represented in
 * the model API, such as for example the <code>SELECT … FOR UPDATE</code>
 * clause, as substantial changes to the internal model are still required
 * before being able to offer public access to it.</li>
 * </ul>
 * <p>
 * <h3>Mutability</h3>
 * <p>
 * While some elements of this API are historically mutable (either mutable
 * objects are returned from {@link QueryPart} subtypes, or argument objects
 * when constructing an {@link QueryPart} remains mutable, rather than copied),
 * users must not rely on this mutable behaviour. Once this API stabilises, all
 * mutability will be gone, accidental remaining mutability will be considered a
 * bug.
 * <p>
 * <h3>Notes</h3>
 * <p>
 * A future Java 17 distribution of jOOQ might make use of sealed types to
 * improve the usability of the model API in pattern matching expressions etc.
 * Other Java language features that benefit pattern matching expression trees
 * might be adopted in the future in this area of the jOOQ API.
 *
 * @author Lukas Eder
 */
@Experimental
public final class QOM {

    // -------------------------------------------------------------------------
    // XXX: Model
    // -------------------------------------------------------------------------

    // This class uses a lot of fully qualified types, because of some javac bug
    // In Java 1.8.0_302, which hasn't been analysed and reproduced yet in a more
    // minimal example. Without the qualification, the types cannot be found
    // despite being imported

    /**
     * A generic tuple of degree 2 for use in {@link QOM} types.
     */
    public sealed interface Tuple2<Q1 extends org.jooq.QueryPart, Q2 extends org.jooq.QueryPart>
        extends
            org.jooq.QueryPart
        permits
            TupleImpl2
    {

        /**
         * The first value in the tuple.
         */
        @NotNull Q1 $1();

        /**
         * The second value in the tuple.
         */
        @NotNull Q2 $2();

        /**
         * Set the first value in the tuple.
         */
        @CheckReturnValue
        @NotNull Tuple2<Q1, Q2> $1(Q1 newPart1);

        /**
         * Set the second value in the tuple.
         */
        @CheckReturnValue
        @NotNull Tuple2<Q1, Q2> $2(Q2 newPart2);
    }

    /**
     * An unmodifiable {@link Map} of {@link QueryPart} keys and values.
     */
    public sealed interface UnmodifiableMap<K extends org.jooq.QueryPart, V extends org.jooq.QueryPart>
        extends
            org.jooq.QueryPart,
            java.util.Map<K, V>
        permits
            AbstractQueryPartMap
    {

        /**
         * Get the {@link #entrySet()} of this map as a list of tuples.
         */
        @NotNull UnmodifiableList<Tuple2<K, V>> $tuples();
    }

    /**
     * An unmodifiable {@link Collection} of {@link QueryPart} elements.
     */
    public sealed interface UnmodifiableCollection<Q extends org.jooq.QueryPart>
        extends
            org.jooq.QueryPart,
            java.util.Collection<Q>
        permits
            UnmodifiableList,
            QueryPartCollectionView
    {}

    /**
     * An unmodifiable {@link List} of {@link QueryPart} elements.
     */
    public sealed interface UnmodifiableList<Q extends org.jooq.QueryPart>
        extends
            UnmodifiableCollection<Q>,
            java.util.List<Q>
        permits
            QueryPartListView
    {

        // TODO: These methods could return unmodifiable views instead, to avoid
        //       copying things around...

        /**
         * Collect the contents of this list using a {@link Collector}.
         */
        default <R> R $collect(Collector<Q, ?, R> collector) {
            return stream().collect(collector);
        }

        /**
         * Concatenate a collection to this UnmodifiableList, returning a new
         * UnmodifiableList from the combined data.
         */
        @NotNull
        @CheckReturnValue
        default UnmodifiableList<Q> $concat(Collection<? extends Q> other) {
            QueryPartList<Q> r = new QueryPartList<>(this);
            r.addAll(other);
            return unmodifiable(r);
        }

        /**
         * Return a new UnmodifiableList without the element at the argument
         * position.
         */
        @NotNull
        @CheckReturnValue
        default UnmodifiableList<Q> $remove(int position) {
            QueryPartList<Q> r = new QueryPartList<>();

            for (int i = 0; i < size(); i++)
                if (i != position)
                    r.add(get(i));

            return unmodifiable(r);
        }

        /**
         * Access the first element if available.
         */
        @Nullable
        default Q $first() {
            return isEmpty() ? null : get(0);
        }

        /**
         * Access the last element if available.
         */
        @Nullable
        default Q $last() {
            return isEmpty() ? null : get(size() - 1);
        }

        /**
         * Return a new UnmodifiableList without the {@link #$first()} element.
         */
        @NotNull
        @CheckReturnValue
        default UnmodifiableList<Q> $removeFirst() {
            QueryPartList<Q> r = new QueryPartList<>();

            for (int i = 1; i < size(); i++)
                r.add(get(i));

            return unmodifiable(r);
        }

        /**
         * Return a new {@link UnmodifiableList} without the {@link #$last()}
         * element.
         */
        @NotNull
        @CheckReturnValue
        default UnmodifiableList<Q> $removeLast() {
            QueryPartList<Q> r = new QueryPartList<>();

            for (int i = 0; i < size() - 1; i++)
                r.add(get(i));

            return unmodifiable(r);
        }

        /**
         * Return a new {@link UnmodifiableList} with a new, replaced value at
         * the argument position.
         */
        @NotNull
        @CheckReturnValue
        default UnmodifiableList<Q> $set(int position, Q newValue) {
            QueryPartList<Q> r = new QueryPartList<>();

            for (int i = 0; i < size(); i++)
                if (i == position)
                    r.add(newValue);
                else
                    r.add(get(i));

            return unmodifiable(r);
        }

        /**
         * Return a new {@link UnmodifiableList} with a new, replaced set of
         * values at the argument position.
         */
        @NotNull
        @CheckReturnValue
        default UnmodifiableList<Q> $setAll(int position, Collection<? extends Q> newValues) {
            QueryPartList<Q> r = new QueryPartList<>();

            for (int i = 0; i < size(); i++)
                if (i == position)
                    r.addAll(newValues);
                else
                    r.add(get(i));

            return unmodifiable(r);
        }
    }

    /**
     * A <code>WITH</code> clause of a {@link Select}, {@link Insert},
     * {@link Update}, or {@link Delete} statement.
     */
    public sealed interface With
        extends
            org.jooq.QueryPart
        permits
            WithImpl
    {
        @NotNull UnmodifiableList<? extends CommonTableExpression<?>> $commonTableExpressions();
        @CheckReturnValue
        @NotNull
        With $commonTableExpressions(UnmodifiableList<? extends CommonTableExpression<?>> commonTableExpressions);
        boolean $recursive();
        @CheckReturnValue
        @NotNull
        With $recursive(boolean recursive);
    }

    /**
     * A {@link QueryPart} that may associate an {@link #$alias()} with the
     * {@link #$aliased()} part.
     */
    public interface Aliasable<Q extends org.jooq.QueryPart>
        extends
            org.jooq.QueryPart
    {

        /**
         * The aliased part (a {@link Field} or a {@link Table}).
         */
        @NotNull Q $aliased();

        /**
         * The alias if any.
         */
        @Nullable Name $alias();
    }

    // -------------------------------------------------------------------------
    // XXX: Queries
    // -------------------------------------------------------------------------

    /**
     * The <code>INSERT</code> statement.
     */
    public sealed interface Insert<R extends Record>
        extends
            DMLQuery<R>
        permits
            InsertImpl,
            InsertQueryImpl
    {
        @Nullable With $with();
        @NotNull  Table<R> $into();
        @CheckReturnValue
        @NotNull  Insert<?> $into(Table<?> into);
        @NotNull  UnmodifiableList<? extends Field<?>> $columns();
        @CheckReturnValue
        @NotNull  Insert<?> $columns(Collection<? extends Field<?>> columns);
        @Nullable Select<?> $select();
        @CheckReturnValue
        @NotNull  Insert<?> $select(Select<?> select);
                  boolean $defaultValues();
        @CheckReturnValue
        @NotNull  Insert<?> $defaultValues(boolean defaultValues);
        @NotNull  UnmodifiableList<? extends Row> $values();
        @CheckReturnValue
        @NotNull  Insert<?> $values(Collection<? extends Row> values);
                  boolean $onDuplicateKeyIgnore();
        @CheckReturnValue
        @NotNull  Insert<?> $onDuplicateKeyIgnore(boolean onDuplicateKeyIgnore);
                  boolean $onDuplicateKeyUpdate();
        @CheckReturnValue
        @NotNull  Insert<?> $onDuplicateKeyUpdate(boolean onDuplicateKeyUpdate);
        @NotNull  UnmodifiableList<? extends Field<?>> $onConflict();
        @CheckReturnValue
        @NotNull  Insert<?> $onConflict(Collection<? extends Field<?>> onConflictFields);
        // [#13640] TODO: What to do about the CONSTRAINT? Re-design this model?
        @Nullable Condition $onConflictWhere();
        @CheckReturnValue
        @NotNull  Insert<?> $onConflictWhere(Condition where);
        @NotNull  UnmodifiableMap<? extends FieldOrRow, ? extends FieldOrRowOrSelect> $updateSet();
        @CheckReturnValue
        @NotNull  Insert<?> $updateSet(Map<? extends FieldOrRow, ? extends FieldOrRowOrSelect> updateSet);
        @Nullable Condition $updateWhere();
        @CheckReturnValue
        @NotNull  Insert<?> $updateWhere(Condition where);
    }

    /**
     * An <code>INSERT</code> statement with a <code>RETURNING</code> clause.
     */
    public sealed interface InsertReturning<R extends Record>
        extends
            ResultQuery<R>
        permits
            InsertAsResultQuery
    {
        @NotNull Insert<?> $insert();
        @CheckReturnValue
        @NotNull InsertReturning<R> $insert(Insert<?> insert);
        @NotNull UnmodifiableList<? extends SelectFieldOrAsterisk> $returning();
        @CheckReturnValue
        @NotNull InsertReturning<?> $returning(Collection<? extends SelectFieldOrAsterisk> returning);
    }

    /**
     * The <code>UPDATE</code> statement.
     */
    public sealed interface Update<R extends Record>
        extends
            DMLQuery<R>
        permits
            UpdateImpl,
            UpdateQueryImpl
    {
        @Nullable With $with();
        @NotNull  Table<R> $table();
        @CheckReturnValue
        @NotNull  Update<?> $table(Table<?> table);
        @NotNull  UnmodifiableList<? extends Table<?>> $from();
        @CheckReturnValue
        @NotNull  Update<R> $from(Collection<? extends Table<?>> from);
        @NotNull  UnmodifiableMap<? extends FieldOrRow, ? extends FieldOrRowOrSelect> $set();
        @CheckReturnValue
        @NotNull  Update<R> $set(Map<? extends FieldOrRow, ? extends FieldOrRowOrSelect> set);
        @Nullable Condition $where();
        @CheckReturnValue
        @NotNull  Update<R> $where(Condition condition);
        @NotNull  UnmodifiableList<? extends SortField<?>> $orderBy();
        @CheckReturnValue
        @NotNull  Update<R> $orderBy(Collection<? extends SortField<?>> orderBy);
        @Nullable Field<? extends Number> $limit();
        @CheckReturnValue
        @NotNull  Update<R> $limit(Field<? extends Number> limit);
    }

    /**
     * An <code>UPDATE</code> statement with a <code>RETURNING</code> clause.
     */
    public sealed interface UpdateReturning<R extends Record>
        extends
            ResultQuery<R>
        permits
            UpdateAsResultQuery
    {
        @NotNull Update<?> $update();
        @CheckReturnValue
        @NotNull UpdateReturning<R> $update(Update<?> update);
        @NotNull UnmodifiableList<? extends SelectFieldOrAsterisk> $returning();
        @CheckReturnValue
        @NotNull UpdateReturning<?> $returning(Collection<? extends SelectFieldOrAsterisk> returning);
    }

    /**
     * The <code>DELETE</code> statement.
     */
    public sealed interface Delete<R extends Record>
        extends
            DMLQuery<R>
        permits
            DeleteImpl,
            DeleteQueryImpl
    {
        @Nullable With $with();
        @NotNull  Table<R> $from();
        @CheckReturnValue
        @NotNull  Delete<?> $from(Table<?> table);
        @NotNull  UnmodifiableList<? extends Table<?>> $using();
        @CheckReturnValue
        @NotNull  Delete<R> $using(Collection<? extends Table<?>> using);
        @Nullable Condition $where();
        @CheckReturnValue
        @NotNull  Delete<R> $where(Condition condition);
        @NotNull  UnmodifiableList<? extends SortField<?>> $orderBy();
        @CheckReturnValue
        @NotNull  Delete<R> $orderBy(Collection<? extends SortField<?>> orderBy);
        @Nullable Field<? extends Number> $limit();
        @CheckReturnValue
        @NotNull  Delete<R> $limit(Field<? extends Number> limit);
    }

    /**
     * An <code>DELETE</code> statement with a <code>RETURNING</code> clause.
     */
    public sealed interface DeleteReturning<R extends Record>
        extends
            ResultQuery<R>
        permits
            DeleteAsResultQuery
    {
        @NotNull Delete<?> $delete();
        @CheckReturnValue
        @NotNull DeleteReturning<R> $delete(Delete<?> delete);
        @NotNull UnmodifiableList<? extends SelectFieldOrAsterisk> $returning();
        @CheckReturnValue
        @NotNull DeleteReturning<?> $returning(Collection<? extends SelectFieldOrAsterisk> returning);
    }

    /**
     * The <code>CREATE VIEW</code> statement.
     */
    public /*sealed*/ interface CreateView<R extends Record>
        extends
            DDLQuery
        /*permits
            CreateViewImpl*/
    {
        boolean $ifNotExists();
        boolean $orReplace();
        @NotNull Table<?> $view();
        @NotNull UnmodifiableList<? extends Field<?>> $fields();
        @NotNull ResultQuery<R> $query();
    }

    // -------------------------------------------------------------------------
    // XXX: Schema
    // -------------------------------------------------------------------------






































    /**
     * A table with a MySQL style index access hint.
     */
    public sealed interface HintedTable<R extends Record>
        extends
            Table<R>
        permits
            org.jooq.impl.HintedTable
    {
        @NotNull Table<R> $table();
        @CheckReturnValue
        @NotNull <O extends Record> HintedTable<O> $table(Table<O> newTable);
    }

    /**
     * A collection derived table or table valued function with a
     * <code>WITH ORDINALITY</code> clause.
     */
    public sealed interface WithOrdinalityTable<R extends Record>
        extends
            Table<R>
        permits
            org.jooq.impl.WithOrdinalityTable
    {
        @NotNull Table<?> $table();
        @CheckReturnValue
        @NotNull WithOrdinalityTable<?> $table(Table<?> newTable);
    }

    public interface PrimaryKey extends Constraint {
        @NotNull UnmodifiableList<? extends Field<?>> $fields();
    }
    public interface UniqueKey extends Constraint {
        @NotNull UnmodifiableList<? extends Field<?>> $fields();
    }
    public interface ForeignKey extends Constraint {
        @NotNull UnmodifiableList<? extends Field<?>> $fields();
        @NotNull Constraint $references();
    }
    public interface Check extends Constraint {
        @NotNull Condition $condition();
    }

    // -------------------------------------------------------------------------
    // XXX: Statements
    // -------------------------------------------------------------------------

    public interface NullStatement extends Statement {}








































    // -------------------------------------------------------------------------
    // XXX: Tables
    // -------------------------------------------------------------------------

    public interface TableAlias<R extends Record>
        extends
            Table<R>,
            Aliasable<Table<R>>
    {
        @NotNull Table<R> $table();
        @Override
        @NotNull default Table<R> $aliased() {
            return $table();
        }
        @Override
        @NotNull Name $alias();
        // TODO [#12425] Reuse MDerivedColumnList
    }
    public interface Dual extends Table<Record>, UEmpty {}
    public interface Lateral<R extends Record> extends Table<R>, UOperator1<Table<R>, Lateral<R>> {}
    public interface DerivedTable<R extends org.jooq.Record> extends org.jooq.Table<R>, UOperator1<org.jooq.Select<R>, DerivedTable<R>> {}
    public interface Values<R extends Record> extends Table<R>, UOperator1<UnmodifiableList<? extends Row>, Values<R>> {}
    public interface DataChangeDeltaTable<R extends Record> extends Table<R> {
        @NotNull ResultOption $resultOption();
        @NotNull DMLQuery<R> $query();
    }
    public interface RowsFrom extends Table<Record> {
        @NotNull UnmodifiableList<? extends Table<?>> $tables();
    }
    public interface GenerateSeries<T> extends Table<Record1<T>>, UOperator3<Field<T>, Field<T>, Field<T>, GenerateSeries<T>> {
        @NotNull default Field<T> $from() { return $arg1(); }
        @NotNull default Field<T> $to() { return $arg2(); }
        @Nullable default Field<T> $step() { return $arg3(); }
    }

    // -------------------------------------------------------------------------
    // XXX: Conditions
    // -------------------------------------------------------------------------

    /**
     * A {@link Condition} that is always <code>TRUE</code>.
     */
    public sealed interface True
        extends
            Condition
        permits
            TrueCondition
    {}

    /**
     * A {@link Condition} that is always <code>FALSE</code>.
     */
    public sealed interface False
        extends
            Condition
        permits
            FalseCondition
    {}

    /**
     * A {@link Condition} that is always <code>NULL</code>.
     */
    public sealed interface Null
        extends
            Condition
        permits
            NullCondition
    {}

    /**
     * A {@link Condition} consisting of two {@link Condition} operands and a
     * binary logic {@link Operator}.
     */
    public /*sealed*/ interface CombinedCondition<R extends CombinedCondition<R>>
        extends
            Condition,
            UCommutativeOperator<Condition, R>
        /*permits
            MAnd,
            MOr*/
    {}

    /**
     * A {@link Condition} consisting of two {@link Field} operands and a
     * {@link Comparator} operator.
     */
    public /*sealed*/ interface CompareCondition<T, R extends CompareCondition<T, R>>
        extends
            Condition,
            UOperator2<Field<T>, Field<T>, R>
        /*permits
            MEq,
            MNe,
            MLt,
            MLe,
            MGt,
            MGe,
            MIsDistinctFrom,
            MIsNotDistinctFrom,
            MContains,
            MContainsIgnoreCase,
            MStartsWith,
            MStartsWithIgnoreCase,
            MEndsWith,
            MEndsWithIgnoreCase*/
    {}

    /**
     * The <code>BETWEEN</code> predicate.
     */
    public interface Between<T>
        extends
            Condition,
            UOperator3<Field<T>, Field<T>, Field<T>, Between<T>>
    {
        boolean $symmetric();
        @NotNull Between<T> $symmetric(boolean symmetric);
    }

    /**
     * The <code>IN</code> predicate accepting a list of values.
     */
    public /*sealed*/ interface InList<T>
        extends
            Condition,
            UOperator2<Field<T>, UnmodifiableList<? extends Field<T>>, InList<T>>
        /*permits
            InList*/
    {
        @NotNull default Field<T> $field() { return $arg1(); }
        @NotNull default UnmodifiableList<? extends Field<T>> $list() { return $arg2(); }
    }

    /**
     * The <code>NOT IN</code> predicate accepting a list of values.
     */
    public /*sealed*/ interface NotInList<T>
        extends
            Condition,
            UOperator2<Field<T>, UnmodifiableList<? extends Field<T>>, NotInList<T>>
        /*permits
            NotInList*/
    {
        @NotNull default Field<T> $field() { return $arg1(); }
        @NotNull default UnmodifiableList<? extends Field<T>> $list() { return $arg2(); }
    }

    public /*sealed*/ interface RegexpLike
        extends
            Condition
        /*permits
            RegexpLike*/
    {
        @NotNull Field<?> $search();
        @NotNull Field<String> $pattern();
    }

    public /*sealed*/ interface Extract
        extends
            Field<Integer>
        /*permits
            Extract*/
    {
        @NotNull Field<?> $field();
        @NotNull DatePart $datePart();
    }

    public /*sealed*/ interface RowIsNull
        extends
            Condition,
            UOperator1<Row, RowIsNull>
        /*permits
            RowIsNull*/
    {
        @NotNull default Row $field() { return $arg1(); }
    }

    public /*sealed*/ interface RowIsNotNull
        extends
            Condition,
            UOperator1<Row, RowIsNotNull>
        /*permits
            RowIsNotNull*/
    {
        @NotNull default Row $field() { return $arg1(); }
    }

    public /*sealed*/ interface RowOverlaps
        extends
            Condition,
            UOperator2<Row, Row, RowOverlaps>
        /*permits
            RowOverlaps*/
    {}

    public /*sealed*/ interface SelectIsNull
        extends
            Condition,
            UOperator1<Select<?>, SelectIsNull>
        /*permits
            SelectIsNull*/
    {
        @NotNull default Select<?> $field() { return $arg1(); }
    }

    public /*sealed*/ interface SelectIsNotNull
        extends
            Condition,
            UOperator1<Select<?>, SelectIsNotNull>
        /*permits
            SelectIsNotNull*/
    {
        @NotNull default Select<?> $field() { return $arg1(); }
    }

    public sealed interface Quantified
        extends
            org.jooq.QueryPart
        permits
            QuantifiedSelect,
            QuantifiedArray
    {}

    public sealed interface QuantifiedSelect<R extends Record>
        extends
            Quantified,
            UOperator2<Quantifier, Select<R>, QuantifiedSelect<R>>
        permits
            org.jooq.impl.QuantifiedSelectImpl
    {
        @NotNull default Quantifier $quantifier() { return $arg1(); }
        @NotNull default QuantifiedSelect<R> $quantifier(Quantifier newQuantifier) { return $arg1(newQuantifier); }
        @NotNull default Select<R> $query() { return $arg2(); }
        @NotNull default QuantifiedSelect<R> $query(Select<R> newSelect) { return $arg2(newSelect); }
    }

    public sealed interface QuantifiedArray<T>
        extends
            Quantified,
            UOperator2<Quantifier, Field<T[]>, QuantifiedArray<T>>
        permits
            org.jooq.impl.QuantifiedArray
    {
        @NotNull default Quantifier $quantifier() { return $arg1(); }
        @NotNull default QuantifiedArray<T> $quantifier(Quantifier newQuantifier) { return $arg1(newQuantifier); }
        @NotNull default Field<T[]> $array() { return $arg2(); }
        @NotNull default QuantifiedArray<T> $array(Field<T[]> newArray) { return $arg2(newArray); }
    }

    // -------------------------------------------------------------------------
    // XXX: Rows
    // -------------------------------------------------------------------------

    public /*sealed*/ interface RowAsField<R extends org.jooq.Record>
        extends
            org.jooq.Field<R>
        /*permits
            RowAsField*/
    {
        @NotNull Row $row();
    }

    public /*sealed*/ interface TableAsField<R extends org.jooq.Record>
        extends
            org.jooq.Field<R>
        /*permits
            TableAsField*/
    {
        @NotNull Table<R> $table();
    }

    public sealed interface JoinTable<R extends org.jooq.Record, J extends JoinTable<R, J>>
        extends
            org.jooq.Table<R>
        permits
            CrossJoin,
            CrossApply,
            OuterApply,
            NaturalJoin,
            NaturalLeftJoin,
            NaturalRightJoin,
            NaturalFullJoin,
            QualifiedJoin
    {
        @NotNull Table<?> $table1();
        @NotNull Table<?> $table2();
        @NotNull J $table1(Table<?> table1);
        @NotNull J $table2(Table<?> table2);
    }

    public sealed interface CrossJoin<R extends org.jooq.Record>
        extends
            JoinTable<R, CrossJoin<R>>
        permits
            org.jooq.impl.CrossJoin
    {}

    public sealed interface CrossApply<R extends org.jooq.Record>
        extends
            JoinTable<R, CrossApply<R>>
        permits
            org.jooq.impl.CrossApply
    {}

    public sealed interface OuterApply<R extends org.jooq.Record>
        extends
            JoinTable<R, OuterApply<R>>
        permits
            org.jooq.impl.OuterApply
    {}

    public sealed interface NaturalJoin<R extends org.jooq.Record>
        extends
            JoinTable<R, NaturalJoin<R>>
        permits
            org.jooq.impl.NaturalJoin
    {}

    public sealed interface NaturalLeftJoin<R extends org.jooq.Record>
        extends
            JoinTable<R, NaturalLeftJoin<R>>
        permits
            org.jooq.impl.NaturalLeftJoin
    {
        @NotNull UnmodifiableList<Field<?>> $partitionBy2();
        @NotNull NaturalLeftJoin<R> $partitionBy2(Collection<? extends Field<?>> partitionBy2);
    }

    public sealed interface NaturalRightJoin<R extends org.jooq.Record>
        extends
            JoinTable<R, NaturalRightJoin<R>>
        permits
            org.jooq.impl.NaturalRightJoin
    {
        @NotNull UnmodifiableList<Field<?>> $partitionBy1();
        @NotNull NaturalRightJoin<R> $partitionBy1(Collection<? extends Field<?>> partitionBy1);
    }

    public sealed interface NaturalFullJoin<R extends org.jooq.Record>
        extends
            JoinTable<R, NaturalFullJoin<R>>
        permits
            org.jooq.impl.NaturalFullJoin
    {
        @NotNull UnmodifiableList<Field<?>> $partitionBy1();
        @NotNull NaturalFullJoin<R> $partitionBy1(Collection<? extends Field<?>> partitionBy1);
        @NotNull UnmodifiableList<Field<?>> $partitionBy2();
        @NotNull NaturalFullJoin<R> $partitionBy2(Collection<? extends Field<?>> partitionBy2);
    }

    public sealed interface QualifiedJoin<R extends org.jooq.Record, J extends QualifiedJoin<R, J>>
        extends
            JoinTable<R, J>
        permits
            Join,
            StraightJoin,
            LeftJoin,
            RightJoin,
            FullJoin,
            LeftSemiJoin,
            LeftAntiJoin
    {
        @Nullable Condition $on();
        @NotNull J $on(Condition on);
        @NotNull UnmodifiableList<Field<?>> $using();
        @NotNull J $using(Collection<? extends Field<?>> using);
    }

    public sealed interface Join<R extends org.jooq.Record>
        extends
            QualifiedJoin<R, Join<R>>
        permits
            org.jooq.impl.Join
    {}

    public sealed interface StraightJoin<R extends org.jooq.Record>
        extends
            QualifiedJoin<R, StraightJoin<R>>
        permits
            org.jooq.impl.StraightJoin
    {}

    public sealed interface LeftJoin<R extends org.jooq.Record>
        extends
            QualifiedJoin<R, LeftJoin<R>>
        permits
            org.jooq.impl.LeftJoin
    {
        @NotNull UnmodifiableList<Field<?>> $partitionBy2();
        @NotNull LeftJoin<R> $partitionBy2(Collection<? extends Field<?>> partitionBy2);
    }

    public sealed interface RightJoin<R extends org.jooq.Record>
        extends
            QualifiedJoin<R, RightJoin<R>>
        permits
            org.jooq.impl.RightJoin
    {
        @NotNull UnmodifiableList<Field<?>> $partitionBy1();
        @NotNull RightJoin<R> $partitionBy1(Collection<? extends Field<?>> partitionBy1);
    }

    public sealed interface FullJoin<R extends org.jooq.Record>
        extends
            QualifiedJoin<R, FullJoin<R>>
        permits
            org.jooq.impl.FullJoin
    {
        @NotNull UnmodifiableList<Field<?>> $partitionBy1();
        @NotNull FullJoin<R> $partitionBy1(Collection<? extends Field<?>> partitionBy1);
        @NotNull UnmodifiableList<Field<?>> $partitionBy2();
        @NotNull FullJoin<R> $partitionBy2(Collection<? extends Field<?>> partitionBy2);
    }

    public sealed interface LeftSemiJoin<R extends org.jooq.Record>
        extends
            QualifiedJoin<R, LeftSemiJoin<R>>
        permits
            org.jooq.impl.LeftSemiJoin
    {}

    public sealed interface LeftAntiJoin<R extends org.jooq.Record>
        extends
            QualifiedJoin<R, LeftAntiJoin<R>>
        permits
            org.jooq.impl.LeftAntiJoin
    {}

    // -------------------------------------------------------------------------
    // XXX: SelectFields, GroupFields and SortFields
    // -------------------------------------------------------------------------

    // Can't seal these types yet because of https://bugs.eclipse.org/bugs/show_bug.cgi?id=577872

    public non-sealed interface EmptyGroupingSet
        extends
            GroupField,
            UEmpty
        /*permits
            org.jooq.impl.EmptyGroupingSet*/
    {}

    public non-sealed interface Rollup
        extends
            GroupField,
            UOperator1<UnmodifiableList<? extends FieldOrRow>, Rollup>
        /*permits
            Rollup*/
    {}

    public non-sealed interface Cube
        extends
            GroupField,
            UOperator1<UnmodifiableList<? extends FieldOrRow>, Cube>
        /*permits
            Cube*/
    {}

    public non-sealed interface GroupingSets
        extends
            GroupField,
            UOperator1<UnmodifiableList<? extends UnmodifiableList<? extends FieldOrRow>>, GroupingSets>
        /*permits
            GroupingSets*/
    {}

    // -------------------------------------------------------------------------
    // XXX: Aggregate functions and window functions
    // -------------------------------------------------------------------------

    public /*sealed*/ interface RatioToReport
        extends
            org.jooq.AggregateFunction<BigDecimal>
        /*permits
            RatioToReport*/
    {
        @NotNull Field<? extends Number> $field();
    }

    public /*sealed*/ interface Mode<T>
        extends
            org.jooq.AggregateFunction<T>,
            UOperator1<Field<T>, Mode<T>>
        /*permits
            Mode*/
    {
        @NotNull default Field<T> $field() { return $arg1(); }
    }

    public /*sealed*/ interface MultisetAgg<R extends Record>
        extends
            org.jooq.AggregateFunction<Result<R>>
        /*permits
            MultisetAgg*/
    {
        @NotNull Row $row();
    }

    public /*sealed*/ interface ArrayAgg<T>
        extends
            org.jooq.AggregateFunction<T[]>,
            UOperator1<Field<T>, ArrayAgg<T>>
        /*permits
            ArrayAgg*/
    {
        @NotNull default Field<T> $field() { return $arg1(); }
        boolean $distinct();
    }

    public /*sealed*/ interface XMLAgg
        extends
            org.jooq.AggregateFunction<XML>,
            UOperator1<Field<XML>, XMLAgg>
        /*permits
            XMLAgg*/
    {
        @NotNull default Field<XML> $field() { return $arg1(); }
    }

    public /*sealed*/ interface JSONArrayAgg<J>
        extends
            org.jooq.AggregateFunction<J>,
            UOperator1<org.jooq.Field<?>, JSONArrayAgg<J>>
        /*permits
            JSONArrayAgg*/
    {
        @NotNull default Field<?> $field() { return $arg1(); }
        boolean $distinct();
        @Nullable JSONOnNull $onNull();
        @Nullable DataType<?> $returning();
    }

    public /*sealed*/ interface JSONObjectAgg<J>
        extends
            org.jooq.AggregateFunction<J>,
            UOperator1<JSONEntry<?>, JSONObjectAgg<J>>
        /*permits JSONObjectAgg*/
    {
        @NotNull default JSONEntry<?> $entry() { return $arg1(); }
        @Nullable JSONOnNull $onNull();
        @Nullable DataType<?> $returning();
    }

    public /*sealed*/ interface CountTable
        extends
            org.jooq.AggregateFunction<Integer>
        /*permits
            CountTable*/
    {
        @NotNull Table<?> $table();
        boolean $distinct();
    }











    public interface WindowFunction<T> extends org.jooq.Field<T> {
        @Nullable WindowSpecification $windowSpecification();
        @Nullable WindowDefinition $windowDefinition();
    }

    public /*sealed*/ interface RowNumber
        extends
            WindowFunction<Integer>
        /*permits
            RowNumber*/
    {}

    public /*sealed*/ interface Rank
        extends
            WindowFunction<Integer>
        /*permits
            Rank*/
    {}

    public /*sealed*/ interface DenseRank
        extends
            WindowFunction<Integer>
        /*permits
            DenseRank*/
    {}

    public /*sealed*/ interface PercentRank
        extends
            WindowFunction<BigDecimal>
        /*permits
            PercentRank*/
    {}

    public /*sealed*/ interface CumeDist
        extends
            WindowFunction<BigDecimal>
        /*permits
            CumeDist*/
    {}

    public /*sealed*/ interface Ntile
        extends
            WindowFunction<Integer>
        /*permits Ntile*/
    {
        @NotNull Field<Integer> $tiles();
    }

    public /*sealed*/ interface Lead<T>
        extends
            WindowFunction<T>
        /*permits
            Lead*/
    {
        @NotNull Field<T> $field();
        @Nullable Field<Integer> $offset();
        @Nullable Field<T> $defaultValue();
        @Nullable NullTreatment $nullTreatment();
    }

    public /*sealed*/ interface Lag<T>
        extends
            WindowFunction<T>
        /*permits
            Lag*/
    {
        @NotNull Field<T> $field();
        @Nullable Field<Integer> $offset();
        @Nullable Field<T> $defaultValue();
        @Nullable NullTreatment $nullTreatment();
    }

    public /*sealed*/ interface FirstValue<T>
        extends
            WindowFunction<T>
        /*permits
            FirstValue*/
    {
        @NotNull Field<T> $field();
        @Nullable NullTreatment $nullTreatment();
    }

    public /*sealed*/ interface LastValue<T>
        extends
            WindowFunction<T>
        /*permits
            LastValue*/
    {
        @NotNull Field<T> $field();
        @Nullable NullTreatment $nullTreatment();
    }

    public /*sealed*/ interface NthValue<T>
        extends
            WindowFunction<T>
        /*permits
            NthValue*/
    {
        @NotNull Field<T> $field();
        @Nullable FromFirstOrLast $fromFirstOrLast();
        @Nullable NullTreatment $nullTreatment();
    }

    // -------------------------------------------------------------------------
    // XXX: Fields
    // -------------------------------------------------------------------------

    public /*sealed*/ interface FieldAlias<T>
        extends
            Field<T>,
            Aliasable<Field<?>>
        /*permits
            FieldAlias*/
    {
        @NotNull Field<T> $field();
        @Override
        @NotNull default Field<?> $aliased() {
            return $field();
        }
        @Override
        @NotNull Name $alias();
    }

    public /*sealed*/ interface Function<T>
        extends
            Field<T>
        /*permits
            org.jooq.impl.Function,
            org.jooq.impl.Function1*/
    {
        @NotNull UnmodifiableList<? extends Field<?>> $args();
    }

    public /*sealed*/ interface Cast<T>
        extends
            Field<T>
        /*permits
            Cast*/
    {
        @NotNull Field<?> $field();
    }

    public /*sealed*/ interface Coerce<T>
        extends
            Field<T>
        /*permits
            Coerce*/
    {
        @NotNull Field<?> $field();
    }

    public /*sealed*/ interface Default<T>
        extends
            Field<T>,
            UEmpty
        /*permits
            Default*/
    {}

    public /*sealed*/ interface Collated
        extends
            Field<String>
        /*permits
            Collated*/
    {
        @NotNull Field<?> $field();
        @NotNull Collation $collation();
    }

    public /*sealed*/ interface Array<T>
        extends
            Field<T[]>
        /*permits
            org.jooq.impl.Array*/
    {
        @NotNull UnmodifiableList<? extends Field<T>> $elements();
    }

    public /*sealed*/ interface ArrayQuery<T>
        extends
            Field<T[]>
        /*permits
            ArrayQuery*/
    {
        @NotNull Select<? extends Record1<T>> $query();
    }

    public /*sealed*/ interface Multiset<R extends org.jooq.Record>
        extends
            org.jooq.Field<org.jooq.Result<R>>
        /*permits
            Multiset*/
    {
        @NotNull TableLike<R> $table();
    }

    public /*sealed*/ interface ScalarSubquery<T>
        extends
            Field<T>,
            UOperator1<Select<? extends Record1<T>>, ScalarSubquery<T>>
        /*permits
            ScalarSubquery*/
    {}

    public /*sealed*/ interface RowSubquery
        extends
            Row,
            UOperator1<Select<?>, RowSubquery>
    {}

    public /*sealed*/ interface Neg<T>
        extends
            UReturnsNullOnNullInput,
            Field<T>,
            UOperator1<Field<T>, Neg<T>>
        /*permits
            Neg*/
    {}

    public /*sealed*/ interface Greatest<T>
        extends
            Field<T>,
            UOperator1<UnmodifiableList<? extends Field<T>>, Greatest<T>>
        /*permits
            Greatest*/
    {}

    public /*sealed*/ interface Least<T>
        extends
            Field<T>,
            UOperator1<UnmodifiableList<? extends Field<T>>, Least<T>>
        /*permits
            Least*/
    {}

    public /*sealed*/ interface Choose<T>
        extends
            Field<T>,
            UOperator2<Field<Integer>, UnmodifiableList<? extends Field<T>>, Choose<T>>
        /*permits
            Choose*/
    {}

    public /*sealed*/ interface FieldFunction<T>
        extends
            Field<Integer>,
            UOperator2<Field<T>, UnmodifiableList<? extends Field<T>>, FieldFunction<T>>
        /*permits
            FieldFunction*/
    {}

    public /*sealed*/ interface Nvl2<T>
        extends
            Field<T>,
            UOperator3<Field<?>, Field<T>, Field<T>, Nvl2<T>>
        /*permits
            Nvl2*/
    {
        @NotNull default Field<?> $value() { return $arg1(); }
        @NotNull default Field<T> $ifNotNull() { return $arg2(); }
        @NotNull default Field<T> $ifIfNull() { return $arg3(); }
    }

    public /*sealed*/ interface Iif<T>
        extends
            Field<T>,
            UOperator3<Condition, Field<T>, Field<T>, Iif<T>>
        /*permits
            Iif*/
    {
        @NotNull default Condition $condition() { return $arg1(); }
        @NotNull default Field<T> $ifTrue() { return $arg2(); }
        @NotNull default Field<T> $ifFalse() { return $arg3(); }
    }

    public /*sealed*/ interface Coalesce<T>
        extends
            Field<T>,
            UOperator1<UnmodifiableList<? extends Field<T>>, Coalesce<T>>
        /*permits
            Coalesce*/
    {}

    public /*sealed*/ interface CaseSimple<V, T>
        extends
            Field<T>,
            UOperator3<Field<V>, UnmodifiableList<? extends Tuple2<Field<V>, Field<T>>>, Field<T>, CaseSimple<V, T>>
    {
        @NotNull  default Field<V> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull  default CaseSimple<V, T> $value(Field<V> value) { return $arg1(value); }
        @NotNull  default UnmodifiableList<? extends Tuple2<Field<V>, Field<T>>> $when() { return $arg2(); }
        @CheckReturnValue
        @NotNull  default CaseSimple<V, T> $when(UnmodifiableList<? extends Tuple2<Field<V>, Field<T>>> when) { return $arg2(when); }
        @Nullable default Field<T> $else() { return $arg3(); }
        @CheckReturnValue
        @NotNull  default CaseSimple<V, T> $else(Field<T> else_) { return $arg3(else_); }
    }

    public /*sealed*/ interface CaseSearched<T>
        extends
            Field<T>,
            UOperator2<UnmodifiableList<? extends Tuple2<Condition, Field<T>>>, Field<T>, CaseSearched<T>>
    {
        @NotNull  default UnmodifiableList<? extends Tuple2<Condition, Field<T>>> $when() { return $arg1(); }
        @CheckReturnValue
        @NotNull  default CaseSearched<T> $when(UnmodifiableList<? extends Tuple2<Condition, Field<T>>> when) { return $arg1(when); }
        @Nullable default Field<T> $else() { return $arg2(); }
        @CheckReturnValue
        @NotNull  default CaseSearched<T> $else(Field<T> else_) { return $arg2(else_); }
    }

    public /*sealed*/ interface Decode<V, T>
        extends
            Field<T>,
            UOperator3<Field<V>, UnmodifiableList<? extends Tuple2<Field<V>, Field<T>>>, Field<T>, Decode<V, T>>
    {
        @NotNull  default Field<V> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull  default Decode<V, T> $value(Field<V> value) { return $arg1(value); }
        @NotNull  default UnmodifiableList<? extends Tuple2<Field<V>, Field<T>>> $when() { return $arg2(); }
        @CheckReturnValue
        @NotNull  default Decode<V, T> $when(UnmodifiableList<? extends Tuple2<Field<V>, Field<T>>> when) { return $arg2(when); }
        @Nullable default Field<T> $else() { return $arg3(); }
        @CheckReturnValue
        @NotNull  default Decode<V, T> $else(Field<T> else_) { return $arg3(else_); }
    }

    public /*sealed*/ interface Concat
        extends
            Field<String>,
            UOperator1<UnmodifiableList<? extends Field<?>>, Concat>
        /*permits
            Concat*/
    {}

    public /*sealed*/ interface TimestampDiff<T>
        extends
            Field<DayToSecond>,
            UOperator2<Field<T>, Field<T>, TimestampDiff<T>>
        /*permits
            TimestampDiff*/
    {
        @NotNull default Field<T> $minuend() { return $arg1(); }
        @NotNull default Field<T> $subtrahend() { return $arg2(); }
    }

    public /*sealed*/ interface Convert<T>
        extends
            Field<T>
        /*permits
            ConvertDateTime*/
    {
        @NotNull Field<?> $field();
        int $style();
    }

    public /*sealed*/ interface CurrentDate<T>
        extends
            Field<T>,
            UEmpty
        /*permits
            CurrentDate*/
    {}

    public /*sealed*/ interface CurrentTime<T>
        extends
            Field<T>,
            UEmpty
        /*permits
            CurrentTime*/
    {}

    public /*sealed*/ interface CurrentTimestamp<T>
        extends
            Field<T>,
            UEmpty
        /*permits
            CurrentTimestamp*/
    {}

    public /*sealed*/ interface XMLQuery
        extends
            Field<XML>
        /*permits
            XMLQuery*/
    {
        @NotNull Field<String> $xpath();
        @NotNull Field<XML> $passing();
        @Nullable XMLPassingMechanism $passingMechanism();
    }

    public /*sealed*/ interface XMLElement
        extends
            Field<XML>
        /*permits
            XMLElement*/
    {
        @NotNull Name $elementName();
        @NotNull XMLAttributes $attributes();
        @NotNull UnmodifiableList<? extends Field<?>> $content();
    }

    public /*sealed*/ interface XMLExists
        extends
            Condition
        /*permits
            XMLExists*/
    {
        @NotNull Field<String> $xpath();
        @NotNull Field<XML> $passing();
        @Nullable XMLPassingMechanism $passingMechanism();
    }

    public /*sealed*/ interface XMLParse
        extends
            Field<XML>
        /*permits
            XMLParse*/
    {
        @NotNull Field<String> $content();
        @NotNull DocumentOrContent $documentOrContent();
    }



    /**
     * The <code>ALTER DATABASE</code> statement.
     */
    public /*sealed*/ interface AlterDatabase
        extends
            DDLQuery
        //permits
        //    AlterDatabaseImpl
    {
        @NotNull Catalog $database();
        boolean $ifExists();
        @NotNull Catalog $renameTo();
        @CheckReturnValue
        @NotNull AlterDatabase $database(Catalog database);
        @CheckReturnValue
        @NotNull AlterDatabase $ifExists(boolean ifExists);
        @CheckReturnValue
        @NotNull AlterDatabase $renameTo(Catalog renameTo);
    }

    /**
     * The <code>ALTER DOMAIN</code> statement.
     */
    public /*sealed*/ interface AlterDomain<T>
        extends
            DDLQuery
        //permits
        //    AlterDomainImpl
    {
        @NotNull Domain<T> $domain();
        boolean $ifExists();
        @Nullable Constraint $addConstraint();
        @Nullable Constraint $dropConstraint();
        boolean $dropConstraintIfExists();
        @Nullable Domain<?> $renameTo();
        @Nullable Constraint $renameConstraint();
        boolean $renameConstraintIfExists();
        @Nullable Field<T> $setDefault();
        boolean $dropDefault();
        boolean $setNotNull();
        boolean $dropNotNull();
        @Nullable Cascade $cascade();
        @Nullable Constraint $renameConstraintTo();
        @CheckReturnValue
        @NotNull AlterDomain<T> $domain(Domain<T> domain);
        @CheckReturnValue
        @NotNull AlterDomain<T> $ifExists(boolean ifExists);
        @CheckReturnValue
        @NotNull AlterDomain<T> $addConstraint(Constraint addConstraint);
        @CheckReturnValue
        @NotNull AlterDomain<T> $dropConstraint(Constraint dropConstraint);
        @CheckReturnValue
        @NotNull AlterDomain<T> $dropConstraintIfExists(boolean dropConstraintIfExists);
        @CheckReturnValue
        @NotNull AlterDomain<T> $renameTo(Domain<?> renameTo);
        @CheckReturnValue
        @NotNull AlterDomain<T> $renameConstraint(Constraint renameConstraint);
        @CheckReturnValue
        @NotNull AlterDomain<T> $renameConstraintIfExists(boolean renameConstraintIfExists);
        @CheckReturnValue
        @NotNull AlterDomain<T> $setDefault(Field<T> setDefault);
        @CheckReturnValue
        @NotNull AlterDomain<T> $dropDefault(boolean dropDefault);
        @CheckReturnValue
        @NotNull AlterDomain<T> $setNotNull(boolean setNotNull);
        @CheckReturnValue
        @NotNull AlterDomain<T> $dropNotNull(boolean dropNotNull);
        @CheckReturnValue
        @NotNull AlterDomain<T> $cascade(Cascade cascade);
        @CheckReturnValue
        @NotNull AlterDomain<T> $renameConstraintTo(Constraint renameConstraintTo);
    }

    /**
     * The <code>ALTER INDEX</code> statement.
     */
    public /*sealed*/ interface AlterIndex
        extends
            DDLQuery
        //permits
        //    AlterIndexImpl
    {
        @NotNull Index $index();
        boolean $ifExists();
        @Nullable Table<?> $on();
        @NotNull Index $renameTo();
        @CheckReturnValue
        @NotNull AlterIndex $index(Index index);
        @CheckReturnValue
        @NotNull AlterIndex $ifExists(boolean ifExists);
        @CheckReturnValue
        @NotNull AlterIndex $on(Table<?> on);
        @CheckReturnValue
        @NotNull AlterIndex $renameTo(Index renameTo);
    }

    /**
     * The <code>ALTER SCHEMA</code> statement.
     */
    public /*sealed*/ interface AlterSchema
        extends
            DDLQuery
        //permits
        //    AlterSchemaImpl
    {
        @NotNull Schema $schema();
        boolean $ifExists();
        @NotNull Schema $renameTo();
        @CheckReturnValue
        @NotNull AlterSchema $schema(Schema schema);
        @CheckReturnValue
        @NotNull AlterSchema $ifExists(boolean ifExists);
        @CheckReturnValue
        @NotNull AlterSchema $renameTo(Schema renameTo);
    }

    /**
     * The <code>ALTER SEQUENCE</code> statement.
     */
    public /*sealed*/ interface AlterSequence<T extends Number>
        extends
            DDLQuery
        //permits
        //    AlterSequenceImpl
    {
        @NotNull Sequence<T> $sequence();
        boolean $ifExists();
        @Nullable Sequence<?> $renameTo();
        boolean $restart();
        @Nullable Field<T> $restartWith();
        @Nullable Field<T> $startWith();
        @Nullable Field<T> $incrementBy();
        @Nullable Field<T> $minvalue();
        boolean $noMinvalue();
        @Nullable Field<T> $maxvalue();
        boolean $noMaxvalue();
        @Nullable CycleOption $cycle();
        @Nullable Field<T> $cache();
        boolean $noCache();
        @CheckReturnValue
        @NotNull AlterSequence<T> $sequence(Sequence<T> sequence);
        @CheckReturnValue
        @NotNull AlterSequence<T> $ifExists(boolean ifExists);
        @CheckReturnValue
        @NotNull AlterSequence<T> $renameTo(Sequence<?> renameTo);
        @CheckReturnValue
        @NotNull AlterSequence<T> $restart(boolean restart);
        @CheckReturnValue
        @NotNull AlterSequence<T> $restartWith(Field<T> restartWith);
        @CheckReturnValue
        @NotNull AlterSequence<T> $startWith(Field<T> startWith);
        @CheckReturnValue
        @NotNull AlterSequence<T> $incrementBy(Field<T> incrementBy);
        @CheckReturnValue
        @NotNull AlterSequence<T> $minvalue(Field<T> minvalue);
        @CheckReturnValue
        @NotNull AlterSequence<T> $noMinvalue(boolean noMinvalue);
        @CheckReturnValue
        @NotNull AlterSequence<T> $maxvalue(Field<T> maxvalue);
        @CheckReturnValue
        @NotNull AlterSequence<T> $noMaxvalue(boolean noMaxvalue);
        @CheckReturnValue
        @NotNull AlterSequence<T> $cycle(CycleOption cycle);
        @CheckReturnValue
        @NotNull AlterSequence<T> $cache(Field<T> cache);
        @CheckReturnValue
        @NotNull AlterSequence<T> $noCache(boolean noCache);
    }

    /**
     * The <code>ALTER TYPE</code> statement.
     */
    public /*sealed*/ interface AlterType
        extends
            DDLQuery
        //permits
        //    AlterTypeImpl
    {
        @NotNull Name $type();
        @Nullable Name $renameTo();
        @Nullable Schema $setSchema();
        @Nullable Field<String> $addValue();
        @Nullable Field<String> $renameValue();
        @Nullable Field<String> $renameValueTo();
        @CheckReturnValue
        @NotNull AlterType $type(Name type);
        @CheckReturnValue
        @NotNull AlterType $renameTo(Name renameTo);
        @CheckReturnValue
        @NotNull AlterType $setSchema(Schema setSchema);
        @CheckReturnValue
        @NotNull AlterType $addValue(Field<String> addValue);
        @CheckReturnValue
        @NotNull AlterType $renameValue(Field<String> renameValue);
        @CheckReturnValue
        @NotNull AlterType $renameValueTo(Field<String> renameValueTo);
    }

    /**
     * The <code>ALTER VIEW</code> statement.
     */
    public /*sealed*/ interface AlterView
        extends
            DDLQuery
        //permits
        //    AlterViewImpl
    {
        @NotNull Table<?> $view();
        @NotNull UnmodifiableList<? extends Field<?>> $fields();
        boolean $ifExists();
        @Nullable Comment $comment();
        @Nullable Table<?> $renameTo();
        @Nullable Select<?> $as();
        @CheckReturnValue
        @NotNull AlterView $view(Table<?> view);
        @CheckReturnValue
        @NotNull AlterView $fields(Collection<? extends Field<?>> fields);
        @CheckReturnValue
        @NotNull AlterView $ifExists(boolean ifExists);
        @CheckReturnValue
        @NotNull AlterView $comment(Comment comment);
        @CheckReturnValue
        @NotNull AlterView $renameTo(Table<?> renameTo);
        @CheckReturnValue
        @NotNull AlterView $as(Select<?> as);
    }

    /**
     * The <code>COMMENT ON TABLE</code> statement.
     */
    public /*sealed*/ interface CommentOn
        extends
            DDLQuery
        //permits
        //    CommentOnImpl
    {
        @Nullable Table<?> $table();
        boolean $isView();
        @Nullable Field<?> $field();
        @NotNull Comment $comment();
        @CheckReturnValue
        @NotNull CommentOn $table(Table<?> table);
        @CheckReturnValue
        @NotNull CommentOn $isView(boolean isView);
        @CheckReturnValue
        @NotNull CommentOn $field(Field<?> field);
        @CheckReturnValue
        @NotNull CommentOn $comment(Comment comment);
    }

    /**
     * The <code>CREATE DATABASE</code> statement.
     */
    public /*sealed*/ interface CreateDatabase
        extends
            DDLQuery
        //permits
        //    CreateDatabaseImpl
    {
        @NotNull Catalog $database();
        boolean $ifNotExists();
        @CheckReturnValue
        @NotNull CreateDatabase $database(Catalog database);
        @CheckReturnValue
        @NotNull CreateDatabase $ifNotExists(boolean ifNotExists);
    }

    /**
     * The <code>CREATE DOMAIN</code> statement.
     */
    public /*sealed*/ interface CreateDomain<T>
        extends
            DDLQuery
        //permits
        //    CreateDomainImpl
    {
        @NotNull Domain<?> $domain();
        boolean $ifNotExists();
        @NotNull DataType<T> $dataType();
        @Nullable Field<T> $default_();
        @NotNull UnmodifiableList<? extends Constraint> $constraints();
        @CheckReturnValue
        @NotNull CreateDomain<T> $domain(Domain<?> domain);
        @CheckReturnValue
        @NotNull CreateDomain<T> $ifNotExists(boolean ifNotExists);
        @CheckReturnValue
        @NotNull CreateDomain<T> $dataType(DataType<T> dataType);
        @CheckReturnValue
        @NotNull CreateDomain<T> $default_(Field<T> default_);
        @CheckReturnValue
        @NotNull CreateDomain<T> $constraints(Collection<? extends Constraint> constraints);
    }










































    /**
     * The <code>CREATE INDEX</code> statement.
     */
    public /*sealed*/ interface CreateIndex
        extends
            DDLQuery
        //permits
        //    CreateIndexImpl
    {
        boolean $unique();
        @Nullable Index $index();
        boolean $ifNotExists();
        @Nullable Table<?> $table();
        @NotNull UnmodifiableList<? extends OrderField<?>> $on();
        @NotNull UnmodifiableList<? extends Field<?>> $include();
        @Nullable Condition $where();
        boolean $excludeNullKeys();
        @CheckReturnValue
        @NotNull CreateIndex $unique(boolean unique);
        @CheckReturnValue
        @NotNull CreateIndex $index(Index index);
        @CheckReturnValue
        @NotNull CreateIndex $ifNotExists(boolean ifNotExists);
        @CheckReturnValue
        @NotNull CreateIndex $table(Table<?> table);
        @CheckReturnValue
        @NotNull CreateIndex $on(Collection<? extends OrderField<?>> on);
        @CheckReturnValue
        @NotNull CreateIndex $include(Collection<? extends Field<?>> include);
        @CheckReturnValue
        @NotNull CreateIndex $where(Condition where);
        @CheckReturnValue
        @NotNull CreateIndex $excludeNullKeys(boolean excludeNullKeys);
    }






























    /**
     * The <code>CREATE TABLE</code> statement.
     */
    public /*sealed*/ interface CreateTable
        extends
            DDLQuery
        //permits
        //    CreateTableImpl
    {
        @NotNull Table<?> $table();
        boolean $temporary();
        boolean $ifNotExists();
        @NotNull UnmodifiableList<? extends TableElement> $tableElements();
        @Nullable Select<?> $select();
        @Nullable WithOrWithoutData $withData();
        @Nullable TableCommitAction $onCommit();
        @Nullable Comment $comment();
        @Nullable SQL $storage();
        @CheckReturnValue
        @NotNull CreateTable $table(Table<?> table);
        @CheckReturnValue
        @NotNull CreateTable $temporary(boolean temporary);
        @CheckReturnValue
        @NotNull CreateTable $ifNotExists(boolean ifNotExists);
        @CheckReturnValue
        @NotNull CreateTable $tableElements(Collection<? extends TableElement> tableElements);
        @CheckReturnValue
        @NotNull CreateTable $select(Select<?> select);
        @CheckReturnValue
        @NotNull CreateTable $withData(WithOrWithoutData withData);
        @CheckReturnValue
        @NotNull CreateTable $onCommit(TableCommitAction onCommit);
        @CheckReturnValue
        @NotNull CreateTable $comment(Comment comment);
        @CheckReturnValue
        @NotNull CreateTable $storage(SQL storage);
    }































































    /**
     * The <code>CREATE TYPE</code> statement.
     */
    public /*sealed*/ interface CreateType
        extends
            DDLQuery
        //permits
        //    CreateTypeImpl
    {
        @NotNull Type<?> $type();
        @NotNull UnmodifiableList<? extends Field<String>> $values();
        @NotNull UnmodifiableList<? extends Field<?>> $attributes();
        @CheckReturnValue
        @NotNull CreateType $type(Type<?> type);
        @CheckReturnValue
        @NotNull CreateType $values(Collection<? extends Field<String>> values);
        @CheckReturnValue
        @NotNull CreateType $attributes(Collection<? extends Field<?>> attributes);
    }

    /**
     * The <code>CREATE SCHEMA</code> statement.
     */
    public /*sealed*/ interface CreateSchema
        extends
            DDLQuery
        //permits
        //    CreateSchemaImpl
    {
        @NotNull Schema $schema();
        boolean $ifNotExists();
        @CheckReturnValue
        @NotNull CreateSchema $schema(Schema schema);
        @CheckReturnValue
        @NotNull CreateSchema $ifNotExists(boolean ifNotExists);
    }

    /**
     * The <code>CREATE SEQUENCE</code> statement.
     */
    public /*sealed*/ interface CreateSequence
        extends
            DDLQuery
        //permits
        //    CreateSequenceImpl
    {
        @NotNull Sequence<?> $sequence();
        boolean $ifNotExists();
        @Nullable Field<? extends Number> $startWith();
        @Nullable Field<? extends Number> $incrementBy();
        @Nullable Field<? extends Number> $minvalue();
        boolean $noMinvalue();
        @Nullable Field<? extends Number> $maxvalue();
        boolean $noMaxvalue();
        @Nullable CycleOption $cycle();
        @Nullable Field<? extends Number> $cache();
        boolean $noCache();
        @CheckReturnValue
        @NotNull CreateSequence $sequence(Sequence<?> sequence);
        @CheckReturnValue
        @NotNull CreateSequence $ifNotExists(boolean ifNotExists);
        @CheckReturnValue
        @NotNull CreateSequence $startWith(Field<? extends Number> startWith);
        @CheckReturnValue
        @NotNull CreateSequence $incrementBy(Field<? extends Number> incrementBy);
        @CheckReturnValue
        @NotNull CreateSequence $minvalue(Field<? extends Number> minvalue);
        @CheckReturnValue
        @NotNull CreateSequence $noMinvalue(boolean noMinvalue);
        @CheckReturnValue
        @NotNull CreateSequence $maxvalue(Field<? extends Number> maxvalue);
        @CheckReturnValue
        @NotNull CreateSequence $noMaxvalue(boolean noMaxvalue);
        @CheckReturnValue
        @NotNull CreateSequence $cycle(CycleOption cycle);
        @CheckReturnValue
        @NotNull CreateSequence $cache(Field<? extends Number> cache);
        @CheckReturnValue
        @NotNull CreateSequence $noCache(boolean noCache);
    }

    /**
     * The <code>DROP DATABASE</code> statement.
     */
    public /*sealed*/ interface DropDatabase
        extends
            DDLQuery
        //permits
        //    DropDatabaseImpl
    {
        @NotNull Catalog $database();
        boolean $ifExists();
        @CheckReturnValue
        @NotNull DropDatabase $database(Catalog database);
        @CheckReturnValue
        @NotNull DropDatabase $ifExists(boolean ifExists);
    }

    /**
     * The <code>DROP DOMAIN</code> statement.
     */
    public /*sealed*/ interface DropDomain
        extends
            DDLQuery
        //permits
        //    DropDomainImpl
    {
        @NotNull Domain<?> $domain();
        boolean $ifExists();
        @Nullable Cascade $cascade();
        @CheckReturnValue
        @NotNull DropDomain $domain(Domain<?> domain);
        @CheckReturnValue
        @NotNull DropDomain $ifExists(boolean ifExists);
        @CheckReturnValue
        @NotNull DropDomain $cascade(Cascade cascade);
    }





















    /**
     * The <code>DROP INDEX</code> statement.
     */
    public /*sealed*/ interface DropIndex
        extends
            DDLQuery
        //permits
        //    DropIndexImpl
    {
        @NotNull Index $index();
        boolean $ifExists();
        @Nullable Table<?> $on();
        @Nullable Cascade $cascade();
        @CheckReturnValue
        @NotNull DropIndex $index(Index index);
        @CheckReturnValue
        @NotNull DropIndex $ifExists(boolean ifExists);
        @CheckReturnValue
        @NotNull DropIndex $on(Table<?> on);
        @CheckReturnValue
        @NotNull DropIndex $cascade(Cascade cascade);
    }





















    /**
     * The <code>DROP SCHEMA</code> statement.
     */
    public /*sealed*/ interface DropSchema
        extends
            DDLQuery
        //permits
        //    DropSchemaImpl
    {
        @NotNull Schema $schema();
        boolean $ifExists();
        @Nullable Cascade $cascade();
        @CheckReturnValue
        @NotNull DropSchema $schema(Schema schema);
        @CheckReturnValue
        @NotNull DropSchema $ifExists(boolean ifExists);
        @CheckReturnValue
        @NotNull DropSchema $cascade(Cascade cascade);
    }

    /**
     * The <code>DROP SEQUENCE</code> statement.
     */
    public /*sealed*/ interface DropSequence
        extends
            DDLQuery
        //permits
        //    DropSequenceImpl
    {
        @NotNull Sequence<?> $sequence();
        boolean $ifExists();
        @CheckReturnValue
        @NotNull DropSequence $sequence(Sequence<?> sequence);
        @CheckReturnValue
        @NotNull DropSequence $ifExists(boolean ifExists);
    }

    /**
     * The <code>DROP TABLE</code> statement.
     */
    public /*sealed*/ interface DropTable
        extends
            DDLQuery
        //permits
        //    DropTableImpl
    {
        boolean $temporary();
        @NotNull Table<?> $table();
        boolean $ifExists();
        @Nullable Cascade $cascade();
        @CheckReturnValue
        @NotNull DropTable $temporary(boolean temporary);
        @CheckReturnValue
        @NotNull DropTable $table(Table<?> table);
        @CheckReturnValue
        @NotNull DropTable $ifExists(boolean ifExists);
        @CheckReturnValue
        @NotNull DropTable $cascade(Cascade cascade);
    }





















    /**
     * The <code>DROP TYPE</code> statement.
     */
    public /*sealed*/ interface DropType
        extends
            DDLQuery
        //permits
        //    DropTypeImpl
    {
        @NotNull UnmodifiableList<? extends Type<?>> $types();
        boolean $ifExists();
        @Nullable Cascade $cascade();
        @CheckReturnValue
        @NotNull DropType $types(Collection<? extends Type<?>> types);
        @CheckReturnValue
        @NotNull DropType $ifExists(boolean ifExists);
        @CheckReturnValue
        @NotNull DropType $cascade(Cascade cascade);
    }

    /**
     * The <code>DROP VIEW</code> statement.
     */
    public /*sealed*/ interface DropView
        extends
            DDLQuery
        //permits
        //    DropViewImpl
    {
        @NotNull Table<?> $view();
        boolean $ifExists();
        @CheckReturnValue
        @NotNull DropView $view(Table<?> view);
        @CheckReturnValue
        @NotNull DropView $ifExists(boolean ifExists);
    }

    /**
     * The <code>GRANT</code> statement.
     */
    public /*sealed*/ interface Grant
        extends
            DDLQuery
        //permits
        //    GrantImpl
    {
        @NotNull UnmodifiableList<? extends Privilege> $privileges();
        @NotNull Table<?> $on();
        @Nullable Role $to();
        boolean $toPublic();
        boolean $withGrantOption();
        @CheckReturnValue
        @NotNull Grant $privileges(Collection<? extends Privilege> privileges);
        @CheckReturnValue
        @NotNull Grant $on(Table<?> on);
        @CheckReturnValue
        @NotNull Grant $to(Role to);
        @CheckReturnValue
        @NotNull Grant $toPublic(boolean toPublic);
        @CheckReturnValue
        @NotNull Grant $withGrantOption(boolean withGrantOption);
    }

    /**
     * The <code>REVOKE</code> statement.
     */
    public /*sealed*/ interface Revoke
        extends
            DDLQuery
        //permits
        //    RevokeImpl
    {
        @NotNull UnmodifiableList<? extends Privilege> $privileges();
        boolean $grantOptionFor();
        @NotNull Table<?> $on();
        @Nullable Role $from();
        boolean $fromPublic();
        @CheckReturnValue
        @NotNull Revoke $privileges(Collection<? extends Privilege> privileges);
        @CheckReturnValue
        @NotNull Revoke $grantOptionFor(boolean grantOptionFor);
        @CheckReturnValue
        @NotNull Revoke $on(Table<?> on);
        @CheckReturnValue
        @NotNull Revoke $from(Role from);
        @CheckReturnValue
        @NotNull Revoke $fromPublic(boolean fromPublic);
    }

    /**
     * The <code>SET</code> statement.
     * <p>
     * Set a vendor specific session configuration to a new value.
     */
    public /*sealed*/ interface SetCommand
        extends
            org.jooq.RowCountQuery
        //permits
        //    SetCommand
    {
        @NotNull Name $name();
        @NotNull Param<?> $value();
        boolean $local();
        @CheckReturnValue
        @NotNull SetCommand $name(Name name);
        @CheckReturnValue
        @NotNull SetCommand $value(Param<?> value);
        @CheckReturnValue
        @NotNull SetCommand $local(boolean local);
    }

    /**
     * The <code>SET CATALOG</code> statement.
     * <p>
     * Set the current catalog to a new value.
     */
    public /*sealed*/ interface SetCatalog
        extends
            org.jooq.RowCountQuery
        //permits
        //    SetCatalog
    {
        @NotNull Catalog $catalog();
        @CheckReturnValue
        @NotNull SetCatalog $catalog(Catalog catalog);
    }

    /**
     * The <code>SET SCHEMA</code> statement.
     * <p>
     * Set the current schema to a new value.
     */
    public /*sealed*/ interface SetSchema
        extends
            org.jooq.RowCountQuery
        //permits
        //    SetSchema
    {
        @NotNull Schema $schema();
        @CheckReturnValue
        @NotNull SetSchema $schema(Schema schema);
    }

    /**
     * The <code>TRUNCATE</code> statement.
     */
    public /*sealed*/ interface Truncate<R extends Record>
        extends
            DDLQuery
        //permits
        //    TruncateImpl
    {
        @NotNull Table<R> $table();
        @Nullable IdentityRestartOption $restartIdentity();
        @Nullable Cascade $cascade();
        @CheckReturnValue
        @NotNull Truncate<R> $table(Table<R> table);
        @CheckReturnValue
        @NotNull Truncate<R> $restartIdentity(IdentityRestartOption restartIdentity);
        @CheckReturnValue
        @NotNull Truncate<R> $cascade(Cascade cascade);
    }























    /**
     * The <code>START TRANSACTION</code> statement.
     * <p>
     * Start a transaction
     */
    public /*sealed*/ interface StartTransaction
        extends
            UEmpty,
            org.jooq.Query
        //permits
        //    StartTransaction
    {}

    /**
     * The <code>SAVEPOINT</code> statement.
     * <p>
     * Specify a savepoint
     */
    public /*sealed*/ interface Savepoint
        extends
            org.jooq.Query
        //permits
        //    Savepoint
    {
        @NotNull Name $name();
        @CheckReturnValue
        @NotNull Savepoint $name(Name name);
    }

    /**
     * The <code>RELEASE SAVEPOINT</code> statement.
     * <p>
     * Release a savepoint
     */
    public /*sealed*/ interface ReleaseSavepoint
        extends
            org.jooq.Query
        //permits
        //    ReleaseSavepoint
    {
        @NotNull Name $name();
        @CheckReturnValue
        @NotNull ReleaseSavepoint $name(Name name);
    }

    /**
     * The <code>COMMIT</code> statement.
     * <p>
     * Commit a transaction
     */
    public /*sealed*/ interface Commit
        extends
            UEmpty,
            org.jooq.Query
        //permits
        //    Commit
    {}

    /**
     * The <code>ROLLBACK</code> statement.
     * <p>
     * Rollback a transaction
     */
    public /*sealed*/ interface Rollback
        extends
            RowCountQuery
        //permits
        //    Rollback
    {
        @Nullable Name $toSavepoint();
        @CheckReturnValue
        @NotNull Rollback $toSavepoint(Name toSavepoint);
    }

    /**
     * The <code>AND</code> operator.
     */
    public /*sealed*/ interface And
        extends
            UCommutativeOperator<Condition, And>,
            CombinedCondition<And>
        //permits
        //    And
    {}

    /**
     * The <code>EQ</code> operator.
     */
    public /*sealed*/ interface TableEq<R extends Record>
        extends
            UReturnsNullOnNullInput,
            UCommutativeOperator<Table<R>, TableEq<R>>,
            org.jooq.Condition
        //permits
        //    TableEq
    {}

    /**
     * The <code>EQ</code> operator.
     */
    public /*sealed*/ interface Eq<T>
        extends
            UReturnsNullOnNullInput,
            UCommutativeOperator<Field<T>, Eq<T>>,
            CompareCondition<T, Eq<T>>
        //permits
        //    Eq
    {}

    /**
     * The <code>EQ</code> operator.
     */
    public /*sealed*/ interface EqQuantified<T>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, org.jooq.QuantifiedSelect<? extends Record1<T>>, EqQuantified<T>>,
            org.jooq.Condition
        //permits
        //    EqQuantified
    {}

    /**
     * The <code>EXISTS</code> function.
     */
    public /*sealed*/ interface Exists
        extends
            UOperator1<Select<?>, Exists>,
            org.jooq.Condition
        //permits
        //    Exists
    {
        @NotNull default Select<?> $query() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Exists $query(Select<?> newQuery) { return $arg1(newQuery); }
    }

    /**
     * The <code>GE</code> operator.
     */
    public /*sealed*/ interface Ge<T>
        extends
            UReturnsNullOnNullInput,
            UConvertibleOperator<Field<T>, Ge<T>, Le<T>>,
            CompareCondition<T, Ge<T>>
        //permits
        //    Ge
    {
        @Override
        default Le<T> $converse() {
            return new org.jooq.impl.Le<>($arg2(), $arg1());
        }
    }

    /**
     * The <code>GE</code> operator.
     */
    public /*sealed*/ interface GeQuantified<T>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, org.jooq.QuantifiedSelect<? extends Record1<T>>, GeQuantified<T>>,
            org.jooq.Condition
        //permits
        //    GeQuantified
    {}

    /**
     * The <code>GT</code> operator.
     */
    public /*sealed*/ interface Gt<T>
        extends
            UReturnsNullOnNullInput,
            UConvertibleOperator<Field<T>, Gt<T>, Lt<T>>,
            CompareCondition<T, Gt<T>>
        //permits
        //    Gt
    {
        @Override
        default Lt<T> $converse() {
            return new org.jooq.impl.Lt<>($arg2(), $arg1());
        }
    }

    /**
     * The <code>GT</code> operator.
     */
    public /*sealed*/ interface GtQuantified<T>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, org.jooq.QuantifiedSelect<? extends Record1<T>>, GtQuantified<T>>,
            org.jooq.Condition
        //permits
        //    GtQuantified
    {}

    /**
     * The <code>IN</code> operator.
     * <p>
     * The subquery must return exactly one field. This is not checked
     * by jOOQ and will result in syntax errors in the database, if not used
     * correctly.
     */
    public /*sealed*/ interface In<T>
        extends
            UOperator2<Field<T>, Select<? extends Record1<T>>, In<T>>,
            org.jooq.Condition
        //permits
        //    In
    {}

    /**
     * The <code>IS DISTINCT FROM</code> operator.
     * <p>
     * The DISTINCT predicate allows for creating NULL safe comparisons where the two operands
     * are tested for non-equality
     */
    public /*sealed*/ interface IsDistinctFrom<T>
        extends
            UCommutativeOperator<Field<T>, IsDistinctFrom<T>>,
            CompareCondition<T, IsDistinctFrom<T>>
        //permits
        //    IsDistinctFrom
    {}

    /**
     * The <code>IS NULL</code> operator.
     */
    public /*sealed*/ interface IsNull
        extends
            UOperator1<Field<?>, IsNull>,
            org.jooq.Condition
        //permits
        //    IsNull
    {
        @NotNull default Field<?> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default IsNull $field(Field<?> newField) { return $arg1(newField); }
    }

    /**
     * The <code>IS NOT DISTINCT FROM</code> operator.
     * <p>
     * The NOT DISTINCT predicate allows for creating NULL safe comparisons where the two
     * operands are tested for equality
     */
    public /*sealed*/ interface IsNotDistinctFrom<T>
        extends
            UCommutativeOperator<Field<T>, IsNotDistinctFrom<T>>,
            CompareCondition<T, IsNotDistinctFrom<T>>
        //permits
        //    IsNotDistinctFrom
    {}

    /**
     * The <code>IS NOT NULL</code> operator.
     */
    public /*sealed*/ interface IsNotNull
        extends
            UOperator1<Field<?>, IsNotNull>,
            org.jooq.Condition
        //permits
        //    IsNotNull
    {
        @NotNull default Field<?> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default IsNotNull $field(Field<?> newField) { return $arg1(newField); }
    }

    /**
     * The <code>LE</code> operator.
     */
    public /*sealed*/ interface Le<T>
        extends
            UReturnsNullOnNullInput,
            UConvertibleOperator<Field<T>, Le<T>, Ge<T>>,
            CompareCondition<T, Le<T>>
        //permits
        //    Le
    {
        @Override
        default Ge<T> $converse() {
            return new org.jooq.impl.Ge<>($arg2(), $arg1());
        }
    }

    /**
     * The <code>LE</code> operator.
     */
    public /*sealed*/ interface LeQuantified<T>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, org.jooq.QuantifiedSelect<? extends Record1<T>>, LeQuantified<T>>,
            org.jooq.Condition
        //permits
        //    LeQuantified
    {}

    /**
     * The <code>LIKE</code> operator.
     */
    public /*sealed*/ interface Like
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<?>, Field<String>, Character, Like>,
            Condition
        //permits
        //    Like
    {
        @NotNull default Field<?> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Like $value(Field<?> newValue) { return $arg1(newValue); }
        @NotNull default Field<String> $pattern() { return $arg2(); }
        @CheckReturnValue
        @NotNull default Like $pattern(Field<String> newPattern) { return $arg2(newPattern); }
        @Nullable default Character $escape() { return $arg3(); }
        @CheckReturnValue
        @NotNull default Like $escape(Character newEscape) { return $arg3(newEscape); }
    }

    /**
     * The <code>LIKE</code> operator.
     */
    public /*sealed*/ interface LikeQuantified
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<?>, org.jooq.QuantifiedSelect<? extends Record1<String>>, Character, LikeQuantified>,
            Condition
        //permits
        //    LikeQuantified
    {
        @NotNull default Field<?> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default LikeQuantified $value(Field<?> newValue) { return $arg1(newValue); }
        @NotNull default org.jooq.QuantifiedSelect<? extends Record1<String>> $pattern() { return $arg2(); }
        @CheckReturnValue
        @NotNull default LikeQuantified $pattern(org.jooq.QuantifiedSelect<? extends Record1<String>> newPattern) { return $arg2(newPattern); }
        @Nullable default Character $escape() { return $arg3(); }
        @CheckReturnValue
        @NotNull default LikeQuantified $escape(Character newEscape) { return $arg3(newEscape); }
    }

    /**
     * The <code>LIKE IGNORE CASE</code> operator.
     * <p>
     * Create a condition to case-insensitively pattern-check this field against
     * a value.
     * <p>
     * This translates to <code>this not ilike value</code> in
     * {@link SQLDialect#POSTGRES}, or to
     * <code>lower(this) not like lower(value)</code> in all other dialects.
     */
    public /*sealed*/ interface LikeIgnoreCase
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<?>, Field<String>, Character, LikeIgnoreCase>,
            Condition
        //permits
        //    LikeIgnoreCase
    {
        @NotNull default Field<?> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default LikeIgnoreCase $value(Field<?> newValue) { return $arg1(newValue); }
        @NotNull default Field<String> $pattern() { return $arg2(); }
        @CheckReturnValue
        @NotNull default LikeIgnoreCase $pattern(Field<String> newPattern) { return $arg2(newPattern); }
        @Nullable default Character $escape() { return $arg3(); }
        @CheckReturnValue
        @NotNull default LikeIgnoreCase $escape(Character newEscape) { return $arg3(newEscape); }
    }

    /**
     * The <code>LT</code> operator.
     */
    public /*sealed*/ interface Lt<T>
        extends
            UReturnsNullOnNullInput,
            UConvertibleOperator<Field<T>, Lt<T>, Gt<T>>,
            CompareCondition<T, Lt<T>>
        //permits
        //    Lt
    {
        @Override
        default Gt<T> $converse() {
            return new org.jooq.impl.Gt<>($arg2(), $arg1());
        }
    }

    /**
     * The <code>LT</code> operator.
     */
    public /*sealed*/ interface LtQuantified<T>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, org.jooq.QuantifiedSelect<? extends Record1<T>>, LtQuantified<T>>,
            org.jooq.Condition
        //permits
        //    LtQuantified
    {}

    /**
     * The <code>NE</code> operator.
     */
    public /*sealed*/ interface TableNe<R extends Record>
        extends
            UReturnsNullOnNullInput,
            UCommutativeOperator<Table<R>, TableNe<R>>,
            org.jooq.Condition
        //permits
        //    TableNe
    {}

    /**
     * The <code>NE</code> operator.
     */
    public /*sealed*/ interface Ne<T>
        extends
            UReturnsNullOnNullInput,
            UCommutativeOperator<Field<T>, Ne<T>>,
            CompareCondition<T, Ne<T>>
        //permits
        //    Ne
    {}

    /**
     * The <code>NE</code> operator.
     */
    public /*sealed*/ interface NeQuantified<T>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, org.jooq.QuantifiedSelect<? extends Record1<T>>, NeQuantified<T>>,
            org.jooq.Condition
        //permits
        //    NeQuantified
    {}

    /**
     * The <code>NOT</code> operator.
     */
    public /*sealed*/ interface Not
        extends
            UReturnsNullOnNullInput,
            UOperator1<Condition, Not>,
            org.jooq.Condition
        //permits
        //    Not
    {
        @NotNull default Condition $condition() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Not $condition(Condition newCondition) { return $arg1(newCondition); }
    }

    /**
     * The <code>NOT</code> operator.
     */
    public /*sealed*/ interface NotField
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<Boolean>, NotField>,
            org.jooq.Field<Boolean>
        //permits
        //    NotField
    {
        @NotNull default Field<Boolean> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default NotField $field(Field<Boolean> newField) { return $arg1(newField); }
    }

    /**
     * The <code>NOT IN</code> operator.
     * <p>
     * The subquery must return exactly one field. This is not checked
     * by jOOQ and will result in syntax errors in the database, if not used
     * correctly.
     * <p>
     * If any of the passed values is <code>NULL</code>, then the
     * condition will be <code>NULL</code> (or <code>false</code>, depending on
     * the dialect) as well. This is standard SQL behaviour.
     */
    public /*sealed*/ interface NotIn<T>
        extends
            UOperator2<Field<T>, Select<? extends Record1<T>>, NotIn<T>>,
            org.jooq.Condition
        //permits
        //    NotIn
    {}

    /**
     * The <code>NOT LIKE</code> operator.
     */
    public /*sealed*/ interface NotLike
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<?>, Field<String>, Character, NotLike>,
            Condition
        //permits
        //    NotLike
    {
        @NotNull default Field<?> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default NotLike $value(Field<?> newValue) { return $arg1(newValue); }
        @NotNull default Field<String> $pattern() { return $arg2(); }
        @CheckReturnValue
        @NotNull default NotLike $pattern(Field<String> newPattern) { return $arg2(newPattern); }
        @Nullable default Character $escape() { return $arg3(); }
        @CheckReturnValue
        @NotNull default NotLike $escape(Character newEscape) { return $arg3(newEscape); }
    }

    /**
     * The <code>NOT LIKE</code> operator.
     */
    public /*sealed*/ interface NotLikeQuantified
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<?>, org.jooq.QuantifiedSelect<? extends Record1<String>>, Character, NotLikeQuantified>,
            Condition
        //permits
        //    NotLikeQuantified
    {
        @NotNull default Field<?> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default NotLikeQuantified $value(Field<?> newValue) { return $arg1(newValue); }
        @NotNull default org.jooq.QuantifiedSelect<? extends Record1<String>> $pattern() { return $arg2(); }
        @CheckReturnValue
        @NotNull default NotLikeQuantified $pattern(org.jooq.QuantifiedSelect<? extends Record1<String>> newPattern) { return $arg2(newPattern); }
        @Nullable default Character $escape() { return $arg3(); }
        @CheckReturnValue
        @NotNull default NotLikeQuantified $escape(Character newEscape) { return $arg3(newEscape); }
    }

    /**
     * The <code>NOT LIKE IGNORE CASE</code> operator.
     * <p>
     * Create a condition to case-insensitively pattern-check this field against
     * a value.
     * <p>
     * This translates to <code>this not ilike value</code> in
     * {@link SQLDialect#POSTGRES}, or to
     * <code>lower(this) not like lower(value)</code> in all other dialects.
     */
    public /*sealed*/ interface NotLikeIgnoreCase
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<?>, Field<String>, Character, NotLikeIgnoreCase>,
            Condition
        //permits
        //    NotLikeIgnoreCase
    {
        @NotNull default Field<?> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default NotLikeIgnoreCase $value(Field<?> newValue) { return $arg1(newValue); }
        @NotNull default Field<String> $pattern() { return $arg2(); }
        @CheckReturnValue
        @NotNull default NotLikeIgnoreCase $pattern(Field<String> newPattern) { return $arg2(newPattern); }
        @Nullable default Character $escape() { return $arg3(); }
        @CheckReturnValue
        @NotNull default NotLikeIgnoreCase $escape(Character newEscape) { return $arg3(newEscape); }
    }

    /**
     * The <code>NOT SIMILAR TO</code> operator.
     */
    public /*sealed*/ interface NotSimilarTo
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<?>, Field<String>, Character, NotSimilarTo>,
            Condition
        //permits
        //    NotSimilarTo
    {
        @NotNull default Field<?> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default NotSimilarTo $value(Field<?> newValue) { return $arg1(newValue); }
        @NotNull default Field<String> $pattern() { return $arg2(); }
        @CheckReturnValue
        @NotNull default NotSimilarTo $pattern(Field<String> newPattern) { return $arg2(newPattern); }
        @Nullable default Character $escape() { return $arg3(); }
        @CheckReturnValue
        @NotNull default NotSimilarTo $escape(Character newEscape) { return $arg3(newEscape); }
    }

    /**
     * The <code>NOT SIMILAR TO</code> operator.
     */
    public /*sealed*/ interface NotSimilarToQuantified
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<?>, org.jooq.QuantifiedSelect<? extends Record1<String>>, Character, NotSimilarToQuantified>,
            Condition
        //permits
        //    NotSimilarToQuantified
    {
        @NotNull default Field<?> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default NotSimilarToQuantified $value(Field<?> newValue) { return $arg1(newValue); }
        @NotNull default org.jooq.QuantifiedSelect<? extends Record1<String>> $pattern() { return $arg2(); }
        @CheckReturnValue
        @NotNull default NotSimilarToQuantified $pattern(org.jooq.QuantifiedSelect<? extends Record1<String>> newPattern) { return $arg2(newPattern); }
        @Nullable default Character $escape() { return $arg3(); }
        @CheckReturnValue
        @NotNull default NotSimilarToQuantified $escape(Character newEscape) { return $arg3(newEscape); }
    }

    /**
     * The <code>OR</code> operator.
     */
    public /*sealed*/ interface Or
        extends
            UCommutativeOperator<Condition, Or>,
            CombinedCondition<Or>
        //permits
        //    Or
    {}

    /**
     * The <code>SIMILAR TO</code> operator.
     */
    public /*sealed*/ interface SimilarTo
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<?>, Field<String>, Character, SimilarTo>,
            Condition
        //permits
        //    SimilarTo
    {
        @NotNull default Field<?> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default SimilarTo $value(Field<?> newValue) { return $arg1(newValue); }
        @NotNull default Field<String> $pattern() { return $arg2(); }
        @CheckReturnValue
        @NotNull default SimilarTo $pattern(Field<String> newPattern) { return $arg2(newPattern); }
        @Nullable default Character $escape() { return $arg3(); }
        @CheckReturnValue
        @NotNull default SimilarTo $escape(Character newEscape) { return $arg3(newEscape); }
    }

    /**
     * The <code>SIMILAR TO</code> operator.
     */
    public /*sealed*/ interface SimilarToQuantified
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<?>, org.jooq.QuantifiedSelect<? extends Record1<String>>, Character, SimilarToQuantified>,
            Condition
        //permits
        //    SimilarToQuantified
    {
        @NotNull default Field<?> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default SimilarToQuantified $value(Field<?> newValue) { return $arg1(newValue); }
        @NotNull default org.jooq.QuantifiedSelect<? extends Record1<String>> $pattern() { return $arg2(); }
        @CheckReturnValue
        @NotNull default SimilarToQuantified $pattern(org.jooq.QuantifiedSelect<? extends Record1<String>> newPattern) { return $arg2(newPattern); }
        @Nullable default Character $escape() { return $arg3(); }
        @CheckReturnValue
        @NotNull default SimilarToQuantified $escape(Character newEscape) { return $arg3(newEscape); }
    }

    /**
     * The <code>UNIQUE</code> function.
     */
    public /*sealed*/ interface Unique
        extends
            UOperator1<Select<?>, Unique>,
            org.jooq.Condition
        //permits
        //    Unique
    {
        @NotNull default Select<?> $query() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Unique $query(Select<?> newQuery) { return $arg1(newQuery); }
    }

    /**
     * The <code>XOR</code> operator.
     */
    public /*sealed*/ interface Xor
        extends
            UReturnsNullOnNullInput,
            UCommutativeOperator<Condition, Xor>,
            CombinedCondition<Xor>
        //permits
        //    Xor
    {}

    /**
     * The <code>ROW EQ</code> operator.
     */
    public /*sealed*/ interface RowEq<T extends Row>
        extends
            UReturnsNullOnNullInput,
            UCommutativeOperator<T, RowEq<T>>,
            org.jooq.Condition
        //permits
        //    RowEq
    {}

    /**
     * The <code>ROW NE</code> operator.
     */
    public /*sealed*/ interface RowNe<T extends Row>
        extends
            UReturnsNullOnNullInput,
            UCommutativeOperator<T, RowNe<T>>,
            org.jooq.Condition
        //permits
        //    RowNe
    {}

    /**
     * The <code>ROW GT</code> operator.
     */
    public /*sealed*/ interface RowGt<T extends Row>
        extends
            UReturnsNullOnNullInput,
            UConvertibleOperator<T, RowGt<T>, RowLt<T>>,
            org.jooq.Condition
        //permits
        //    RowGt
    {
        @Override
        default RowLt<T> $converse() {
            return new org.jooq.impl.RowLt<>($arg2(), $arg1());
        }
    }

    /**
     * The <code>ROW GE</code> operator.
     */
    public /*sealed*/ interface RowGe<T extends Row>
        extends
            UReturnsNullOnNullInput,
            UConvertibleOperator<T, RowGe<T>, RowLe<T>>,
            org.jooq.Condition
        //permits
        //    RowGe
    {
        @Override
        default RowLe<T> $converse() {
            return new org.jooq.impl.RowLe<>($arg2(), $arg1());
        }
    }

    /**
     * The <code>ROW LT</code> operator.
     */
    public /*sealed*/ interface RowLt<T extends Row>
        extends
            UReturnsNullOnNullInput,
            UConvertibleOperator<T, RowLt<T>, RowGt<T>>,
            org.jooq.Condition
        //permits
        //    RowLt
    {
        @Override
        default RowGt<T> $converse() {
            return new org.jooq.impl.RowGt<>($arg2(), $arg1());
        }
    }

    /**
     * The <code>ROW LE</code> operator.
     */
    public /*sealed*/ interface RowLe<T extends Row>
        extends
            UReturnsNullOnNullInput,
            UConvertibleOperator<T, RowLe<T>, RowGe<T>>,
            org.jooq.Condition
        //permits
        //    RowLe
    {
        @Override
        default RowGe<T> $converse() {
            return new org.jooq.impl.RowGe<>($arg2(), $arg1());
        }
    }

    /**
     * The <code>IS DOCUMENT</code> operator.
     * <p>
     * Create a condition to check if this field contains XML data.
     */
    public /*sealed*/ interface IsDocument
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<?>, IsDocument>,
            org.jooq.Condition
        //permits
        //    IsDocument
    {
        @NotNull default Field<?> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default IsDocument $field(Field<?> newField) { return $arg1(newField); }
    }

    /**
     * The <code>IS NOT DOCUMENT</code> operator.
     * <p>
     * Create a condition to check if this field does not contain XML data.
     */
    public /*sealed*/ interface IsNotDocument
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<?>, IsNotDocument>,
            org.jooq.Condition
        //permits
        //    IsNotDocument
    {
        @NotNull default Field<?> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default IsNotDocument $field(Field<?> newField) { return $arg1(newField); }
    }

    /**
     * The <code>IS JSON</code> operator.
     * <p>
     * Create a condition to check if this field contains JSON data.
     */
    public /*sealed*/ interface IsJson
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<?>, IsJson>,
            org.jooq.Condition
        //permits
        //    IsJson
    {
        @NotNull default Field<?> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default IsJson $field(Field<?> newField) { return $arg1(newField); }
    }

    /**
     * The <code>IS NOT JSON</code> operator.
     * <p>
     * Create a condition to check if this field does not contain JSON data.
     */
    public /*sealed*/ interface IsNotJson
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<?>, IsNotJson>,
            org.jooq.Condition
        //permits
        //    IsNotJson
    {
        @NotNull default Field<?> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default IsNotJson $field(Field<?> newField) { return $arg1(newField); }
    }

    /**
     * The <code>EXCLUDED</code> function.
     * <p>
     * Provide "EXCLUDED" qualification for a column for use in ON CONFLICT or ON DUPLICATE
     * KEY UPDATE.
     */
    public /*sealed*/ interface Excluded<T>
        extends
            UOperator1<Field<T>, Excluded<T>>,
            org.jooq.Field<T>
        //permits
        //    Excluded
    {

        /**
         * The excluded field.
         */
        @NotNull default Field<T> $field() { return $arg1(); }

        /**
         * The excluded field.
         */
        @CheckReturnValue
        @NotNull default Excluded<T> $field(Field<T> newField) { return $arg1(newField); }
    }

    /**
     * The <code>ROWID</code> operator.
     * <p>
     * Get a <code>table.rowid</code> reference from this table.
     * <p>
     * A rowid value describes the physical location of a row on the disk, which
     * can be used as a replacement for a primary key in some situations -
     * especially within a query, e.g. to self-join a table:
     * <p>
     * <pre><code>
     * -- Emulating this MySQL statement...
     * DELETE FROM x ORDER BY x.y LIMIT 1
     *
     * -- ... in other databases
     * DELETE FROM x
     * WHERE x.rowid IN (
     *   SELECT x.rowid FROM x ORDER BY x.a LIMIT 1
     * )
     * </code></pre>
     * <p>
     * It is <em>not</em> recommended to use <code>rowid</code> values in client
     * applications as actual row identifiers as the database system may move a
     * row to a different physical location at any time, thus changing the rowid
     * value. In general, use primary keys, instead.
     */
    public /*sealed*/ interface QualifiedRowid
        extends
            UOperator1<Table<?>, QualifiedRowid>,
            org.jooq.Field<RowId>
        //permits
        //    QualifiedRowid
    {
        @NotNull default Table<?> $table() { return $arg1(); }
        @CheckReturnValue
        @NotNull default QualifiedRowid $table(Table<?> newTable) { return $arg1(newTable); }
    }

    /**
     * The <code>ABS</code> function.
     */
    public /*sealed*/ interface Abs<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<T>, Abs<T>>,
            org.jooq.Field<T>
        //permits
        //    Abs
    {
        @NotNull default Field<T> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Abs<T> $value(Field<T> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>ACOS</code> function.
     */
    public /*sealed*/ interface Acos
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Acos>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Acos
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Acos $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>ACOSH</code> function.
     */
    public /*sealed*/ interface Acosh
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Acosh>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Acosh
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Acosh $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>ACOTH</code> function.
     */
    public /*sealed*/ interface Acoth
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Acoth>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Acoth
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Acoth $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>ADD</code> operator.
     */
    public /*sealed*/ interface Add<T>
        extends
            UReturnsNullOnNullInput,
            UCommutativeOperator<Field<T>, Add<T>>,
            org.jooq.Field<T>
        //permits
        //    Add
    {}

    /**
     * The <code>ASIN</code> function.
     */
    public /*sealed*/ interface Asin
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Asin>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Asin
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Asin $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>ASINH</code> function.
     */
    public /*sealed*/ interface Asinh
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Asinh>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Asinh
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Asinh $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>ATAN</code> function.
     */
    public /*sealed*/ interface Atan
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Atan>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Atan
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Atan $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>ATAN2</code> function.
     */
    public /*sealed*/ interface Atan2
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<? extends Number>, Field<? extends Number>, Atan2>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Atan2
    {
        @NotNull default Field<? extends Number> $x() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Atan2 $x(Field<? extends Number> newX) { return $arg1(newX); }
        @NotNull default Field<? extends Number> $y() { return $arg2(); }
        @CheckReturnValue
        @NotNull default Atan2 $y(Field<? extends Number> newY) { return $arg2(newY); }
    }

    /**
     * The <code>ATANH</code> function.
     */
    public /*sealed*/ interface Atanh
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Atanh>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Atanh
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Atanh $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>BIT AND</code> operator.
     */
    public /*sealed*/ interface BitAnd<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UCommutativeOperator<Field<T>, BitAnd<T>>,
            org.jooq.Field<T>
        //permits
        //    BitAnd
    {}

    /**
     * The <code>BIT COUNT</code> function.
     * <p>
     * Count the number of bits set in a number
     */
    public /*sealed*/ interface BitCount
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, BitCount>,
            org.jooq.Field<Integer>
        //permits
        //    BitCount
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default BitCount $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>BIT GET</code> function.
     */
    public /*sealed*/ interface BitGet<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, Field<? extends Number>, BitGet<T>>,
            org.jooq.Field<T>
        //permits
        //    BitGet
    {
        @NotNull default Field<T> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default BitGet<T> $value(Field<T> newValue) { return $arg1(newValue); }
        @NotNull default Field<? extends Number> $bit() { return $arg2(); }
        @CheckReturnValue
        @NotNull default BitGet<T> $bit(Field<? extends Number> newBit) { return $arg2(newBit); }
    }

    /**
     * The <code>BIT NAND</code> operator.
     */
    public /*sealed*/ interface BitNand<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UCommutativeOperator<Field<T>, BitNand<T>>,
            org.jooq.Field<T>
        //permits
        //    BitNand
    {}

    /**
     * The <code>BIT NOR</code> operator.
     */
    public /*sealed*/ interface BitNor<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UCommutativeOperator<Field<T>, BitNor<T>>,
            org.jooq.Field<T>
        //permits
        //    BitNor
    {}

    /**
     * The <code>BIT NOT</code> operator.
     */
    public /*sealed*/ interface BitNot<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<T>, BitNot<T>>,
            org.jooq.Field<T>
        //permits
        //    BitNot
    {}

    /**
     * The <code>BIT OR</code> operator.
     */
    public /*sealed*/ interface BitOr<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UCommutativeOperator<Field<T>, BitOr<T>>,
            org.jooq.Field<T>
        //permits
        //    BitOr
    {}

    /**
     * The <code>BIT SET</code> function.
     */
    public /*sealed*/ interface BitSet<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<T>, Field<? extends Number>, Field<T>, BitSet<T>>,
            org.jooq.Field<T>
        //permits
        //    BitSet
    {
        @NotNull default Field<T> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default BitSet<T> $value(Field<T> newValue) { return $arg1(newValue); }
        @NotNull default Field<? extends Number> $bit() { return $arg2(); }
        @CheckReturnValue
        @NotNull default BitSet<T> $bit(Field<? extends Number> newBit) { return $arg2(newBit); }
        @Nullable default Field<T> $newValue() { return $arg3(); }
        @CheckReturnValue
        @NotNull default BitSet<T> $newValue(Field<T> newNewValue) { return $arg3(newNewValue); }
    }

    /**
     * The <code>BIT X NOR</code> operator.
     */
    public /*sealed*/ interface BitXNor<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UCommutativeOperator<Field<T>, BitXNor<T>>,
            org.jooq.Field<T>
        //permits
        //    BitXNor
    {}

    /**
     * The <code>BIT XOR</code> operator.
     */
    public /*sealed*/ interface BitXor<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UCommutativeOperator<Field<T>, BitXor<T>>,
            org.jooq.Field<T>
        //permits
        //    BitXor
    {}

    /**
     * The <code>CEIL</code> function.
     * <p>
     * Get the smallest integer value equal or greater to a value.
     */
    public /*sealed*/ interface Ceil<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<T>, Ceil<T>>,
            org.jooq.Field<T>
        //permits
        //    Ceil
    {
        @NotNull default Field<T> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Ceil<T> $value(Field<T> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>COS</code> function.
     */
    public /*sealed*/ interface Cos
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Cos>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Cos
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Cos $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>COSH</code> function.
     */
    public /*sealed*/ interface Cosh
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Cosh>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Cosh
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Cosh $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>COT</code> function.
     */
    public /*sealed*/ interface Cot
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Cot>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Cot
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Cot $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>COTH</code> function.
     */
    public /*sealed*/ interface Coth
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Coth>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Coth
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Coth $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>DEGREES</code> function.
     * <p>
     * Turn a value in radians to degrees.
     */
    public /*sealed*/ interface Degrees
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Degrees>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Degrees
    {

        /**
         * The value in radians.
         */
        @NotNull default Field<? extends Number> $radians() { return $arg1(); }

        /**
         * The value in radians.
         */
        @CheckReturnValue
        @NotNull default Degrees $radians(Field<? extends Number> newRadians) { return $arg1(newRadians); }
    }

    /**
     * The <code>DIV</code> operator.
     */
    public /*sealed*/ interface Div<T>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, Field<T>, Div<T>>,
            org.jooq.Field<T>
        //permits
        //    Div
    {}

    /**
     * The <code>E</code> function.
     * <p>
     * The E literal (Euler number).
     */
    public /*sealed*/ interface Euler
        extends
            UOperator0<Euler>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Euler
    {}

    /**
     * The <code>EXP</code> function.
     */
    public /*sealed*/ interface Exp
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Exp>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Exp
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Exp $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>FLOOR</code> function.
     * <p>
     * Get the biggest integer value equal or less than a value.
     */
    public /*sealed*/ interface Floor<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<T>, Floor<T>>,
            org.jooq.Field<T>
        //permits
        //    Floor
    {
        @NotNull default Field<T> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Floor<T> $value(Field<T> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>LN</code> function.
     * <p>
     * Get the natural logarithm of a value.
     */
    public /*sealed*/ interface Ln
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Ln>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Ln
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Ln $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>LOG</code> function.
     * <p>
     * Get the logarithm of a value for a base.
     */
    public /*sealed*/ interface Log
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<? extends Number>, Field<? extends Number>, Log>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Log
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Log $value(Field<? extends Number> newValue) { return $arg1(newValue); }
        @NotNull default Field<? extends Number> $base() { return $arg2(); }
        @CheckReturnValue
        @NotNull default Log $base(Field<? extends Number> newBase) { return $arg2(newBase); }
    }

    /**
     * The <code>LOG10</code> function.
     * <p>
     * Get the logarithm of a value for base 10.
     */
    public /*sealed*/ interface Log10
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Log10>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Log10
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Log10 $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>MOD</code> operator.
     */
    public /*sealed*/ interface Mod<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, Field<? extends Number>, Mod<T>>,
            org.jooq.Field<T>
        //permits
        //    Mod
    {
        @NotNull default Field<T> $dividend() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Mod<T> $dividend(Field<T> newDividend) { return $arg1(newDividend); }
        @NotNull default Field<? extends Number> $divisor() { return $arg2(); }
        @CheckReturnValue
        @NotNull default Mod<T> $divisor(Field<? extends Number> newDivisor) { return $arg2(newDivisor); }
    }

    /**
     * The <code>MUL</code> operator.
     */
    public /*sealed*/ interface Mul<T>
        extends
            UReturnsNullOnNullInput,
            UCommutativeOperator<Field<T>, Mul<T>>,
            org.jooq.Field<T>
        //permits
        //    Mul
    {}

    /**
     * The <code>PI</code> function.
     * <p>
     * The π literal.
     */
    public /*sealed*/ interface Pi
        extends
            UOperator0<Pi>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Pi
    {}

    /**
     * The <code>POWER</code> operator.
     */
    public /*sealed*/ interface Power
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<? extends Number>, Field<? extends Number>, Power>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Power
    {
        @NotNull default Field<? extends Number> $base() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Power $base(Field<? extends Number> newBase) { return $arg1(newBase); }
        @NotNull default Field<? extends Number> $exponent() { return $arg2(); }
        @CheckReturnValue
        @NotNull default Power $exponent(Field<? extends Number> newExponent) { return $arg2(newExponent); }
    }

    /**
     * The <code>RADIANS</code> function.
     * <p>
     * Turn a value in degrees to radians.
     */
    public /*sealed*/ interface Radians
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Radians>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Radians
    {

        /**
         * The value in degrees.
         */
        @NotNull default Field<? extends Number> $degrees() { return $arg1(); }

        /**
         * The value in degrees.
         */
        @CheckReturnValue
        @NotNull default Radians $degrees(Field<? extends Number> newDegrees) { return $arg1(newDegrees); }
    }

    /**
     * The <code>RAND</code> function.
     * <p>
     * Get a random numeric value.
     */
    public /*sealed*/ interface Rand
        extends
            UOperator0<Rand>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Rand
    {}

    /**
     * The <code>ROUND</code> function.
     * <p>
     * Round a numeric value to the nearest decimal precision.
     */
    public /*sealed*/ interface Round<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, Field<Integer>, Round<T>>,
            org.jooq.Field<T>
        //permits
        //    Round
    {

        /**
         * The number to be rounded.
         */
        @NotNull default Field<T> $value() { return $arg1(); }

        /**
         * The number to be rounded.
         */
        @CheckReturnValue
        @NotNull default Round<T> $value(Field<T> newValue) { return $arg1(newValue); }

        /**
         * The decimals to round to.
         */
        @Nullable default Field<Integer> $decimals() { return $arg2(); }

        /**
         * The decimals to round to.
         */
        @CheckReturnValue
        @NotNull default Round<T> $decimals(Field<Integer> newDecimals) { return $arg2(newDecimals); }
    }

    /**
     * The <code>SHL</code> operator.
     * <p>
     * Left shift all bits in a number
     */
    public /*sealed*/ interface Shl<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, Field<? extends Number>, Shl<T>>,
            org.jooq.Field<T>
        //permits
        //    Shl
    {

        /**
         * The number whose bits to shift left.
         */
        @NotNull default Field<T> $value() { return $arg1(); }

        /**
         * The number whose bits to shift left.
         */
        @CheckReturnValue
        @NotNull default Shl<T> $value(Field<T> newValue) { return $arg1(newValue); }

        /**
         * The number of bits to shift.
         */
        @NotNull default Field<? extends Number> $count() { return $arg2(); }

        /**
         * The number of bits to shift.
         */
        @CheckReturnValue
        @NotNull default Shl<T> $count(Field<? extends Number> newCount) { return $arg2(newCount); }
    }

    /**
     * The <code>SHR</code> operator.
     * <p>
     * Right shift all bits in a number
     */
    public /*sealed*/ interface Shr<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, Field<? extends Number>, Shr<T>>,
            org.jooq.Field<T>
        //permits
        //    Shr
    {

        /**
         * The number whose bits to shift right
         */
        @NotNull default Field<T> $value() { return $arg1(); }

        /**
         * The number whose bits to shift right
         */
        @CheckReturnValue
        @NotNull default Shr<T> $value(Field<T> newValue) { return $arg1(newValue); }

        /**
         * The number of bits to shift.
         */
        @NotNull default Field<? extends Number> $count() { return $arg2(); }

        /**
         * The number of bits to shift.
         */
        @CheckReturnValue
        @NotNull default Shr<T> $count(Field<? extends Number> newCount) { return $arg2(newCount); }
    }

    /**
     * The <code>SIGN</code> function.
     * <p>
     * Get the sign of a number and return it as any of +1, 0, -1.
     */
    public /*sealed*/ interface Sign
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Sign>,
            org.jooq.Field<Integer>
        //permits
        //    Sign
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Sign $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>SIN</code> function.
     */
    public /*sealed*/ interface Sin
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Sin>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Sin
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Sin $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>SINH</code> function.
     */
    public /*sealed*/ interface Sinh
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Sinh>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Sinh
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Sinh $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>SQRT</code> function.
     */
    public /*sealed*/ interface Sqrt
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Sqrt>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Sqrt
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Sqrt $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>SQUARE</code> function.
     */
    public /*sealed*/ interface Square<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<T>, Square<T>>,
            org.jooq.Field<T>
        //permits
        //    Square
    {
        @NotNull default Field<T> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Square<T> $value(Field<T> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>SUB</code> operator.
     */
    public /*sealed*/ interface Sub<T>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, Field<T>, Sub<T>>,
            org.jooq.Field<T>
        //permits
        //    Sub
    {}

    /**
     * The <code>TAN</code> function.
     */
    public /*sealed*/ interface Tan
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Tan>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Tan
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Tan $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>TANH</code> function.
     */
    public /*sealed*/ interface Tanh
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Tanh>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Tanh
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Tanh $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>TAU</code> function.
     * <p>
     * The τ literal, or π, in a better world.
     */
    public /*sealed*/ interface Tau
        extends
            UOperator0<Tau>,
            org.jooq.Field<BigDecimal>
        //permits
        //    Tau
    {}

    /**
     * The <code>TRUNC</code> function.
     * <p>
     * Truncate a number to a given number of decimals.
     */
    public /*sealed*/ interface Trunc<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, Field<Integer>, Trunc<T>>,
            org.jooq.Field<T>
        //permits
        //    Trunc
    {

        /**
         * The number to be truncated
         */
        @NotNull default Field<T> $value() { return $arg1(); }

        /**
         * The number to be truncated
         */
        @CheckReturnValue
        @NotNull default Trunc<T> $value(Field<T> newValue) { return $arg1(newValue); }

        /**
         * The decimals to truncate to.
         */
        @NotNull default Field<Integer> $decimals() { return $arg2(); }

        /**
         * The decimals to truncate to.
         */
        @CheckReturnValue
        @NotNull default Trunc<T> $decimals(Field<Integer> newDecimals) { return $arg2(newDecimals); }
    }

    /**
     * The <code>WIDTH BUCKET</code> function.
     * <p>
     * Divide a range into buckets of equal size.
     */
    public /*sealed*/ interface WidthBucket<T extends Number>
        extends
            UReturnsNullOnNullInput,
            UOperator4<Field<T>, Field<T>, Field<T>, Field<Integer>, WidthBucket<T>>,
            org.jooq.Field<T>
        //permits
        //    WidthBucket
    {

        /**
         * The value to divide into the range.
         */
        @NotNull default Field<T> $field() { return $arg1(); }

        /**
         * The value to divide into the range.
         */
        @CheckReturnValue
        @NotNull default WidthBucket<T> $field(Field<T> newField) { return $arg1(newField); }

        /**
         * The lower bound of the range.
         */
        @NotNull default Field<T> $low() { return $arg2(); }

        /**
         * The lower bound of the range.
         */
        @CheckReturnValue
        @NotNull default WidthBucket<T> $low(Field<T> newLow) { return $arg2(newLow); }

        /**
         * The upper bound of the range.
         */
        @NotNull default Field<T> $high() { return $arg3(); }

        /**
         * The upper bound of the range.
         */
        @CheckReturnValue
        @NotNull default WidthBucket<T> $high(Field<T> newHigh) { return $arg3(newHigh); }

        /**
         * The number of buckets to produce.
         */
        @NotNull default Field<Integer> $buckets() { return $arg4(); }

        /**
         * The number of buckets to produce.
         */
        @CheckReturnValue
        @NotNull default WidthBucket<T> $buckets(Field<Integer> newBuckets) { return $arg4(newBuckets); }
    }

    /**
     * The <code>ASCII</code> function.
     * <p>
     * The ASCII value of a character.
     */
    public /*sealed*/ interface Ascii
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<String>, Ascii>,
            org.jooq.Field<Integer>
        //permits
        //    Ascii
    {
        @NotNull default Field<String> $string() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Ascii $string(Field<String> newString) { return $arg1(newString); }
    }

    /**
     * The <code>BIT LENGTH</code> function.
     * <p>
     * The length of a string in bits.
     */
    public /*sealed*/ interface BitLength
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<String>, BitLength>,
            org.jooq.Field<Integer>
        //permits
        //    BitLength
    {
        @NotNull default Field<String> $string() { return $arg1(); }
        @CheckReturnValue
        @NotNull default BitLength $string(Field<String> newString) { return $arg1(newString); }
    }

    /**
     * The <code>CHAR LENGTH</code> function.
     * <p>
     * The length of a string in characters.
     */
    public /*sealed*/ interface CharLength
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<String>, CharLength>,
            org.jooq.Field<Integer>
        //permits
        //    CharLength
    {
        @NotNull default Field<String> $string() { return $arg1(); }
        @CheckReturnValue
        @NotNull default CharLength $string(Field<String> newString) { return $arg1(newString); }
    }

    /**
     * The <code>CHR</code> function.
     */
    public /*sealed*/ interface Chr
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Chr>,
            org.jooq.Field<String>
        //permits
        //    Chr
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Chr $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>CONTAINS</code> operator.
     * <p>
     * Convenience method for {@link Field#like(String, char)} including proper
     * adding of wildcards and escaping.
     * <p>
     * SQL: <code>this like ('%' || escape(value, '\') || '%') escape '\'</code>
     * <p>
     * Note: This also works with numbers, for instance
     * <code>val(1133).contains(13)</code>
     * <p>
     * If you're using {@link SQLDialect#POSTGRES}, then you can use this method
     * also to express the "ARRAY contains" operator. For example: <pre><code>
     * // Use this expression
     * val(new Integer[] { 1, 2, 3 }).contains(new Integer[] { 1, 2 })
     *
     * // ... to render this SQL
     * ARRAY[1, 2, 3] @&gt; ARRAY[1, 2]
     * </code></pre>
     * <p>
     * Note, this does not correspond to the Oracle Text <code>CONTAINS()</code>
     * function. Refer to {@link OracleDSL#contains(Field, String)} instead.
     */
    public /*sealed*/ interface Contains<T>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, Field<T>, Contains<T>>,
            CompareCondition<T, Contains<T>>
        //permits
        //    Contains
    {
        @NotNull default Field<T> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Contains<T> $value(Field<T> newValue) { return $arg1(newValue); }
        @NotNull default Field<T> $content() { return $arg2(); }
        @CheckReturnValue
        @NotNull default Contains<T> $content(Field<T> newContent) { return $arg2(newContent); }
    }

    /**
     * The <code>CONTAINS IGNORE CASE</code> operator.
     * <p>
     * Convenience method for {@link Field#likeIgnoreCase(String, char)} including
     * proper adding of wildcards and escaping.
     * <p>
     * This translates to
     * <code>this ilike ('%' || escape(value, '\') || '%') escape '\'</code> in
     * {@link SQLDialect#POSTGRES}, or to
     * <code>lower(this) not like lower(('%' || escape(value, '\') || '%') escape '\')</code>
     * in all other dialects.
     */
    public /*sealed*/ interface ContainsIgnoreCase<T>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, Field<T>, ContainsIgnoreCase<T>>,
            CompareCondition<T, ContainsIgnoreCase<T>>
        //permits
        //    ContainsIgnoreCase
    {
        @NotNull default Field<T> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default ContainsIgnoreCase<T> $value(Field<T> newValue) { return $arg1(newValue); }
        @NotNull default Field<T> $content() { return $arg2(); }
        @CheckReturnValue
        @NotNull default ContainsIgnoreCase<T> $content(Field<T> newContent) { return $arg2(newContent); }
    }

    /**
     * The <code>DIGITS</code> function.
     */
    public /*sealed*/ interface Digits
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Digits>,
            org.jooq.Field<String>
        //permits
        //    Digits
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Digits $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>ENDS WITH</code> operator.
     * <p>
     * Convenience method for {@link Field#like(String, char)} including proper
     * adding of wildcards and escaping.
     * <p>
     * SQL: <code>this like ('%' || escape(value, '\')) escape '\'</code>
     * <p>
     * Note: This also works with numbers, for instance
     * <code>val(1133).endsWith(33)</code>
     */
    public /*sealed*/ interface EndsWith<T>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, Field<T>, EndsWith<T>>,
            CompareCondition<T, EndsWith<T>>
        //permits
        //    EndsWith
    {
        @NotNull default Field<T> $string() { return $arg1(); }
        @CheckReturnValue
        @NotNull default EndsWith<T> $string(Field<T> newString) { return $arg1(newString); }
        @NotNull default Field<T> $suffix() { return $arg2(); }
        @CheckReturnValue
        @NotNull default EndsWith<T> $suffix(Field<T> newSuffix) { return $arg2(newSuffix); }
    }

    /**
     * The <code>ENDS WITH IGNORE CASE</code> operator.
     * <p>
     * Convenience method for {@link Field#like(String, char)} including proper
     * adding of wildcards and escaping.
     * <p>
     * SQL: <code>lower(this) like ('%' || lower(escape(value, '\'))) escape '\'</code>
     * <p>
     * Note: This also works with numbers, for instance
     * <code>val(1133).endsWithIgnoreCase(33)</code>
     */
    public /*sealed*/ interface EndsWithIgnoreCase<T>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, Field<T>, EndsWithIgnoreCase<T>>,
            CompareCondition<T, EndsWithIgnoreCase<T>>
        //permits
        //    EndsWithIgnoreCase
    {
        @NotNull default Field<T> $string() { return $arg1(); }
        @CheckReturnValue
        @NotNull default EndsWithIgnoreCase<T> $string(Field<T> newString) { return $arg1(newString); }
        @NotNull default Field<T> $suffix() { return $arg2(); }
        @CheckReturnValue
        @NotNull default EndsWithIgnoreCase<T> $suffix(Field<T> newSuffix) { return $arg2(newSuffix); }
    }

    /**
     * The <code>LEFT</code> function.
     * <p>
     * Get the left outermost characters from a string.
     */
    public /*sealed*/ interface Left
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<String>, Field<? extends Number>, Left>,
            org.jooq.Field<String>
        //permits
        //    Left
    {

        /**
         * The string whose characters are extracted.
         */
        @NotNull default Field<String> $string() { return $arg1(); }

        /**
         * The string whose characters are extracted.
         */
        @CheckReturnValue
        @NotNull default Left $string(Field<String> newString) { return $arg1(newString); }

        /**
         * The number of characters to extract from the string.
         */
        @NotNull default Field<? extends Number> $length() { return $arg2(); }

        /**
         * The number of characters to extract from the string.
         */
        @CheckReturnValue
        @NotNull default Left $length(Field<? extends Number> newLength) { return $arg2(newLength); }
    }

    /**
     * The <code>LOWER</code> function.
     * <p>
     * Turn a string into lower case.
     */
    public /*sealed*/ interface Lower
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<String>, Lower>,
            org.jooq.Field<String>
        //permits
        //    Lower
    {
        @NotNull default Field<String> $string() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Lower $string(Field<String> newString) { return $arg1(newString); }
    }

    /**
     * The <code>LPAD</code> function.
     * <p>
     * Left-pad a string with a character (whitespace as default) for a number of times.
     */
    public /*sealed*/ interface Lpad
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<String>, Field<? extends Number>, Field<String>, Lpad>,
            org.jooq.Field<String>
        //permits
        //    Lpad
    {

        /**
         * The string to be padded.
         */
        @NotNull default Field<String> $string() { return $arg1(); }

        /**
         * The string to be padded.
         */
        @CheckReturnValue
        @NotNull default Lpad $string(Field<String> newString) { return $arg1(newString); }

        /**
         * The maximum length to pad the string to.
         */
        @NotNull default Field<? extends Number> $length() { return $arg2(); }

        /**
         * The maximum length to pad the string to.
         */
        @CheckReturnValue
        @NotNull default Lpad $length(Field<? extends Number> newLength) { return $arg2(newLength); }

        /**
         * The padding character, if different from whitespace
         */
        @Nullable default Field<String> $character() { return $arg3(); }

        /**
         * The padding character, if different from whitespace
         */
        @CheckReturnValue
        @NotNull default Lpad $character(Field<String> newCharacter) { return $arg3(newCharacter); }
    }

    /**
     * The <code>LTRIM</code> function.
     * <p>
     * Trim characters (whitespace as default) from both sides of a string.
     */
    public /*sealed*/ interface Ltrim
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<String>, Field<String>, Ltrim>,
            org.jooq.Field<String>
        //permits
        //    Ltrim
    {

        /**
         * The string to be trimmed.
         */
        @NotNull default Field<String> $string() { return $arg1(); }

        /**
         * The string to be trimmed.
         */
        @CheckReturnValue
        @NotNull default Ltrim $string(Field<String> newString) { return $arg1(newString); }

        /**
         * The characters to be trimmed.
         */
        @Nullable default Field<String> $characters() { return $arg2(); }

        /**
         * The characters to be trimmed.
         */
        @CheckReturnValue
        @NotNull default Ltrim $characters(Field<String> newCharacters) { return $arg2(newCharacters); }
    }

    /**
     * The <code>MD5</code> function.
     * <p>
     * Calculate an MD5 hash from a string.
     */
    public /*sealed*/ interface Md5
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<String>, Md5>,
            org.jooq.Field<String>
        //permits
        //    Md5
    {
        @NotNull default Field<String> $string() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Md5 $string(Field<String> newString) { return $arg1(newString); }
    }

    /**
     * The <code>OCTET LENGTH</code> function.
     * <p>
     * The length of a string in octets.
     */
    public /*sealed*/ interface OctetLength
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<String>, OctetLength>,
            org.jooq.Field<Integer>
        //permits
        //    OctetLength
    {
        @NotNull default Field<String> $string() { return $arg1(); }
        @CheckReturnValue
        @NotNull default OctetLength $string(Field<String> newString) { return $arg1(newString); }
    }

    /**
     * The <code>OVERLAY</code> function.
     * <p>
     * Place a string on top of another string, replacing the original contents.
     */
    public /*sealed*/ interface Overlay
        extends
            UReturnsNullOnNullInput,
            UOperator4<Field<String>, Field<String>, Field<? extends Number>, Field<? extends Number>, Overlay>,
            org.jooq.Field<String>
        //permits
        //    Overlay
    {

        /**
         * The original string on top of which the overlay is placed.
         */
        @NotNull default Field<String> $in() { return $arg1(); }

        /**
         * The original string on top of which the overlay is placed.
         */
        @CheckReturnValue
        @NotNull default Overlay $in(Field<String> newIn) { return $arg1(newIn); }

        /**
         * The string that is being placed on top of the other string.
         */
        @NotNull default Field<String> $placing() { return $arg2(); }

        /**
         * The string that is being placed on top of the other string.
         */
        @CheckReturnValue
        @NotNull default Overlay $placing(Field<String> newPlacing) { return $arg2(newPlacing); }

        /**
         * The start index (1-based) starting from where the overlay is placed.
         */
        @NotNull default Field<? extends Number> $startIndex() { return $arg3(); }

        /**
         * The start index (1-based) starting from where the overlay is placed.
         */
        @CheckReturnValue
        @NotNull default Overlay $startIndex(Field<? extends Number> newStartIndex) { return $arg3(newStartIndex); }

        /**
         * The length in the original string that will be replaced, if different from the overlay length.
         */
        @Nullable default Field<? extends Number> $length() { return $arg4(); }

        /**
         * The length in the original string that will be replaced, if different from the overlay length.
         */
        @CheckReturnValue
        @NotNull default Overlay $length(Field<? extends Number> newLength) { return $arg4(newLength); }
    }

    /**
     * The <code>POSITION</code> function.
     * <p>
     * Search the position (1-based) of a substring in another string.
     */
    public /*sealed*/ interface Position
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<String>, Field<String>, Field<? extends Number>, Position>,
            org.jooq.Field<Integer>
        //permits
        //    Position
    {

        /**
         * The string in which to search the substring.
         */
        @NotNull default Field<String> $in() { return $arg1(); }

        /**
         * The string in which to search the substring.
         */
        @CheckReturnValue
        @NotNull default Position $in(Field<String> newIn) { return $arg1(newIn); }

        /**
         * The substring to search for.
         */
        @NotNull default Field<String> $search() { return $arg2(); }

        /**
         * The substring to search for.
         */
        @CheckReturnValue
        @NotNull default Position $search(Field<String> newSearch) { return $arg2(newSearch); }

        /**
         * The start index (1-based) from which to start looking for the substring.
         */
        @Nullable default Field<? extends Number> $startIndex() { return $arg3(); }

        /**
         * The start index (1-based) from which to start looking for the substring.
         */
        @CheckReturnValue
        @NotNull default Position $startIndex(Field<? extends Number> newStartIndex) { return $arg3(newStartIndex); }
    }

    /**
     * The <code>REPEAT</code> function.
     * <p>
     * Repeat a string a number of times.
     */
    public /*sealed*/ interface Repeat
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<String>, Field<? extends Number>, Repeat>,
            org.jooq.Field<String>
        //permits
        //    Repeat
    {

        /**
         * The string to be repeated.
         */
        @NotNull default Field<String> $string() { return $arg1(); }

        /**
         * The string to be repeated.
         */
        @CheckReturnValue
        @NotNull default Repeat $string(Field<String> newString) { return $arg1(newString); }

        /**
         * The number of times to repeat the string.
         */
        @NotNull default Field<? extends Number> $count() { return $arg2(); }

        /**
         * The number of times to repeat the string.
         */
        @CheckReturnValue
        @NotNull default Repeat $count(Field<? extends Number> newCount) { return $arg2(newCount); }
    }

    /**
     * The <code>REPLACE</code> function.
     * <p>
     * Replace all occurrences of a substring in another string.
     */
    public /*sealed*/ interface Replace
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<String>, Field<String>, Field<String>, Replace>,
            org.jooq.Field<String>
        //permits
        //    Replace
    {

        /**
         * The string in which to replace contents.
         */
        @NotNull default Field<String> $string() { return $arg1(); }

        /**
         * The string in which to replace contents.
         */
        @CheckReturnValue
        @NotNull default Replace $string(Field<String> newString) { return $arg1(newString); }

        /**
         * The substring to search for.
         */
        @NotNull default Field<String> $search() { return $arg2(); }

        /**
         * The substring to search for.
         */
        @CheckReturnValue
        @NotNull default Replace $search(Field<String> newSearch) { return $arg2(newSearch); }

        /**
         * The replacement for each substring, if not empty.
         */
        @Nullable default Field<String> $replace() { return $arg3(); }

        /**
         * The replacement for each substring, if not empty.
         */
        @CheckReturnValue
        @NotNull default Replace $replace(Field<String> newReplace) { return $arg3(newReplace); }
    }

    /**
     * The <code>REVERSE</code> function.
     * <p>
     * Reverse a string.
     */
    public /*sealed*/ interface Reverse
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<String>, Reverse>,
            org.jooq.Field<String>
        //permits
        //    Reverse
    {
        @NotNull default Field<String> $string() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Reverse $string(Field<String> newString) { return $arg1(newString); }
    }

    /**
     * The <code>RIGHT</code> function.
     * <p>
     * Get the right outermost characters from a string.
     */
    public /*sealed*/ interface Right
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<String>, Field<? extends Number>, Right>,
            org.jooq.Field<String>
        //permits
        //    Right
    {

        /**
         * The string whose characters are extracted.
         */
        @NotNull default Field<String> $string() { return $arg1(); }

        /**
         * The string whose characters are extracted.
         */
        @CheckReturnValue
        @NotNull default Right $string(Field<String> newString) { return $arg1(newString); }

        /**
         * The number of characters to extract from the string.
         */
        @NotNull default Field<? extends Number> $length() { return $arg2(); }

        /**
         * The number of characters to extract from the string.
         */
        @CheckReturnValue
        @NotNull default Right $length(Field<? extends Number> newLength) { return $arg2(newLength); }
    }

    /**
     * The <code>RPAD</code> function.
     * <p>
     * Right-pad a string with a character (whitespace as default) for a number of times.
     */
    public /*sealed*/ interface Rpad
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<String>, Field<? extends Number>, Field<String>, Rpad>,
            org.jooq.Field<String>
        //permits
        //    Rpad
    {

        /**
         * The string to be padded.
         */
        @NotNull default Field<String> $string() { return $arg1(); }

        /**
         * The string to be padded.
         */
        @CheckReturnValue
        @NotNull default Rpad $string(Field<String> newString) { return $arg1(newString); }

        /**
         * The maximum length to pad the string to.
         */
        @NotNull default Field<? extends Number> $length() { return $arg2(); }

        /**
         * The maximum length to pad the string to.
         */
        @CheckReturnValue
        @NotNull default Rpad $length(Field<? extends Number> newLength) { return $arg2(newLength); }

        /**
         * The padding character, if different from whitespace
         */
        @Nullable default Field<String> $character() { return $arg3(); }

        /**
         * The padding character, if different from whitespace
         */
        @CheckReturnValue
        @NotNull default Rpad $character(Field<String> newCharacter) { return $arg3(newCharacter); }
    }

    /**
     * The <code>RTRIM</code> function.
     * <p>
     * Trim characters (whitespace as default) from both sides of a string.
     */
    public /*sealed*/ interface Rtrim
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<String>, Field<String>, Rtrim>,
            org.jooq.Field<String>
        //permits
        //    Rtrim
    {

        /**
         * The string to be trimmed.
         */
        @NotNull default Field<String> $string() { return $arg1(); }

        /**
         * The string to be trimmed.
         */
        @CheckReturnValue
        @NotNull default Rtrim $string(Field<String> newString) { return $arg1(newString); }

        /**
         * The characters to be trimmed.
         */
        @Nullable default Field<String> $characters() { return $arg2(); }

        /**
         * The characters to be trimmed.
         */
        @CheckReturnValue
        @NotNull default Rtrim $characters(Field<String> newCharacters) { return $arg2(newCharacters); }
    }

    /**
     * The <code>SPACE</code> function.
     * <p>
     * Get a string of spaces of a given length.
     */
    public /*sealed*/ interface Space
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, Space>,
            org.jooq.Field<String>
        //permits
        //    Space
    {

        /**
         * The number of spaces to produce.
         */
        @NotNull default Field<? extends Number> $count() { return $arg1(); }

        /**
         * The number of spaces to produce.
         */
        @CheckReturnValue
        @NotNull default Space $count(Field<? extends Number> newCount) { return $arg1(newCount); }
    }

    /**
     * The <code>SPLIT PART</code> function.
     * <p>
     * Split a string into tokens, and retrieve the nth token.
     */
    public /*sealed*/ interface SplitPart
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<String>, Field<String>, Field<? extends Number>, SplitPart>,
            org.jooq.Field<String>
        //permits
        //    SplitPart
    {

        /**
         * The string to be split into parts.
         */
        @NotNull default Field<String> $string() { return $arg1(); }

        /**
         * The string to be split into parts.
         */
        @CheckReturnValue
        @NotNull default SplitPart $string(Field<String> newString) { return $arg1(newString); }

        /**
         * The delimiter used for splitting.
         */
        @NotNull default Field<String> $delimiter() { return $arg2(); }

        /**
         * The delimiter used for splitting.
         */
        @CheckReturnValue
        @NotNull default SplitPart $delimiter(Field<String> newDelimiter) { return $arg2(newDelimiter); }

        /**
         * The token number (1-based).
         */
        @NotNull default Field<? extends Number> $n() { return $arg3(); }

        /**
         * The token number (1-based).
         */
        @CheckReturnValue
        @NotNull default SplitPart $n(Field<? extends Number> newN) { return $arg3(newN); }
    }

    /**
     * The <code>STARTS WITH</code> operator.
     * <p>
     * Convenience method for {@link Field#like(String, char)} including proper
     * adding of wildcards and escaping.
     * <p>
     * SQL: <code>this like (escape(value, '\') || '%') escape '\'</code>
     * <p>
     * Note: This also works with numbers, for instance
     * <code>val(1133).startsWith(11)</code>
     */
    public /*sealed*/ interface StartsWith<T>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, Field<T>, StartsWith<T>>,
            CompareCondition<T, StartsWith<T>>
        //permits
        //    StartsWith
    {
        @NotNull default Field<T> $string() { return $arg1(); }
        @CheckReturnValue
        @NotNull default StartsWith<T> $string(Field<T> newString) { return $arg1(newString); }
        @NotNull default Field<T> $prefix() { return $arg2(); }
        @CheckReturnValue
        @NotNull default StartsWith<T> $prefix(Field<T> newPrefix) { return $arg2(newPrefix); }
    }

    /**
     * The <code>STARTS WITH IGNORE CASE</code> operator.
     * <p>
     * Convenience method for {@link Field#like(String, char)} including proper
     * adding of wildcards and escaping.
     * <p>
     * SQL: <code>lower(this) like (lower(escape(value, '\')) || '%') escape '\'</code>
     * <p>
     * Note: This also works with numbers, for instance
     * <code>val(1133).startsWithIgnoreCase(11)</code>
     */
    public /*sealed*/ interface StartsWithIgnoreCase<T>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T>, Field<T>, StartsWithIgnoreCase<T>>,
            CompareCondition<T, StartsWithIgnoreCase<T>>
        //permits
        //    StartsWithIgnoreCase
    {
        @NotNull default Field<T> $string() { return $arg1(); }
        @CheckReturnValue
        @NotNull default StartsWithIgnoreCase<T> $string(Field<T> newString) { return $arg1(newString); }
        @NotNull default Field<T> $prefix() { return $arg2(); }
        @CheckReturnValue
        @NotNull default StartsWithIgnoreCase<T> $prefix(Field<T> newPrefix) { return $arg2(newPrefix); }
    }

    /**
     * The <code>SUBSTRING</code> function.
     * <p>
     * Get a substring of a string, from a given position.
     */
    public /*sealed*/ interface Substring
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<String>, Field<? extends Number>, Field<? extends Number>, Substring>,
            org.jooq.Field<String>
        //permits
        //    Substring
    {

        /**
         * The string from which to get the substring.
         */
        @NotNull default Field<String> $string() { return $arg1(); }

        /**
         * The string from which to get the substring.
         */
        @CheckReturnValue
        @NotNull default Substring $string(Field<String> newString) { return $arg1(newString); }

        /**
         * The position (1-based) from which to get the substring.
         */
        @NotNull default Field<? extends Number> $startingPosition() { return $arg2(); }

        /**
         * The position (1-based) from which to get the substring.
         */
        @CheckReturnValue
        @NotNull default Substring $startingPosition(Field<? extends Number> newStartingPosition) { return $arg2(newStartingPosition); }

        /**
         * The maximum length of the substring.
         */
        @Nullable default Field<? extends Number> $length() { return $arg3(); }

        /**
         * The maximum length of the substring.
         */
        @CheckReturnValue
        @NotNull default Substring $length(Field<? extends Number> newLength) { return $arg3(newLength); }
    }

    /**
     * The <code>SUBSTRING INDEX</code> function.
     * <p>
     * Get a substring of a string, from the beginning until the nth occurrence of a substring.
     */
    public /*sealed*/ interface SubstringIndex
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<String>, Field<String>, Field<? extends Number>, SubstringIndex>,
            org.jooq.Field<String>
        //permits
        //    SubstringIndex
    {

        /**
         * The string from which to get the substring.
         */
        @NotNull default Field<String> $string() { return $arg1(); }

        /**
         * The string from which to get the substring.
         */
        @CheckReturnValue
        @NotNull default SubstringIndex $string(Field<String> newString) { return $arg1(newString); }

        /**
         * The delimiter.
         */
        @NotNull default Field<String> $delimiter() { return $arg2(); }

        /**
         * The delimiter.
         */
        @CheckReturnValue
        @NotNull default SubstringIndex $delimiter(Field<String> newDelimiter) { return $arg2(newDelimiter); }

        /**
         * The number of occurrences of the delimiter.
         */
        @NotNull default Field<? extends Number> $n() { return $arg3(); }

        /**
         * The number of occurrences of the delimiter.
         */
        @CheckReturnValue
        @NotNull default SubstringIndex $n(Field<? extends Number> newN) { return $arg3(newN); }
    }

    /**
     * The <code>TO CHAR</code> function.
     * <p>
     * Format an arbitrary value as a string.
     */
    public /*sealed*/ interface ToChar
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<?>, Field<String>, ToChar>,
            org.jooq.Field<String>
        //permits
        //    ToChar
    {

        /**
         * The value to be formatted.
         */
        @NotNull default Field<?> $value() { return $arg1(); }

        /**
         * The value to be formatted.
         */
        @CheckReturnValue
        @NotNull default ToChar $value(Field<?> newValue) { return $arg1(newValue); }

        /**
         * The vendor-specific formatting string.
         */
        @Nullable default Field<String> $formatMask() { return $arg2(); }

        /**
         * The vendor-specific formatting string.
         */
        @CheckReturnValue
        @NotNull default ToChar $formatMask(Field<String> newFormatMask) { return $arg2(newFormatMask); }
    }

    /**
     * The <code>TO DATE</code> function.
     * <p>
     * Parse a string-formatted date value to a date.
     */
    public /*sealed*/ interface ToDate
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<String>, Field<String>, ToDate>,
            org.jooq.Field<Date>
        //permits
        //    ToDate
    {

        /**
         * The formatted DATE value.
         */
        @NotNull default Field<String> $value() { return $arg1(); }

        /**
         * The formatted DATE value.
         */
        @CheckReturnValue
        @NotNull default ToDate $value(Field<String> newValue) { return $arg1(newValue); }

        /**
         * The vendor-specific formatting string.
         */
        @NotNull default Field<String> $formatMask() { return $arg2(); }

        /**
         * The vendor-specific formatting string.
         */
        @CheckReturnValue
        @NotNull default ToDate $formatMask(Field<String> newFormatMask) { return $arg2(newFormatMask); }
    }

    /**
     * The <code>TO HEX</code> function.
     * <p>
     * Format a number to its hex value.
     */
    public /*sealed*/ interface ToHex
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Number>, ToHex>,
            org.jooq.Field<String>
        //permits
        //    ToHex
    {
        @NotNull default Field<? extends Number> $value() { return $arg1(); }
        @CheckReturnValue
        @NotNull default ToHex $value(Field<? extends Number> newValue) { return $arg1(newValue); }
    }

    /**
     * The <code>TO TIMESTAMP</code> function.
     * <p>
     * Parse a string-formatted timestamp value to a timestamp.
     */
    public /*sealed*/ interface ToTimestamp
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<String>, Field<String>, ToTimestamp>,
            org.jooq.Field<Timestamp>
        //permits
        //    ToTimestamp
    {

        /**
         * The formatted TIMESTAMP value.
         */
        @NotNull default Field<String> $value() { return $arg1(); }

        /**
         * The formatted TIMESTAMP value.
         */
        @CheckReturnValue
        @NotNull default ToTimestamp $value(Field<String> newValue) { return $arg1(newValue); }

        /**
         * The vendor-specific formatting string.
         */
        @NotNull default Field<String> $formatMask() { return $arg2(); }

        /**
         * The vendor-specific formatting string.
         */
        @CheckReturnValue
        @NotNull default ToTimestamp $formatMask(Field<String> newFormatMask) { return $arg2(newFormatMask); }
    }

    /**
     * The <code>TRANSLATE</code> function.
     * <p>
     * Translate a set of characters to another set of characters in a string.
     */
    public /*sealed*/ interface Translate
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<String>, Field<String>, Field<String>, Translate>,
            org.jooq.Field<String>
        //permits
        //    Translate
    {

        /**
         * The string to translate.
         */
        @NotNull default Field<String> $string() { return $arg1(); }

        /**
         * The string to translate.
         */
        @CheckReturnValue
        @NotNull default Translate $string(Field<String> newString) { return $arg1(newString); }

        /**
         * The set of source characters.
         */
        @NotNull default Field<String> $from() { return $arg2(); }

        /**
         * The set of source characters.
         */
        @CheckReturnValue
        @NotNull default Translate $from(Field<String> newFrom) { return $arg2(newFrom); }

        /**
         * The set of target characters, matched with source characters by position.
         */
        @NotNull default Field<String> $to() { return $arg3(); }

        /**
         * The set of target characters, matched with source characters by position.
         */
        @CheckReturnValue
        @NotNull default Translate $to(Field<String> newTo) { return $arg3(newTo); }
    }

    /**
     * The <code>TRIM</code> function.
     * <p>
     * Trim characters (whitespace as default) from both sides of a string.
     */
    public /*sealed*/ interface Trim
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<String>, Field<String>, Trim>,
            org.jooq.Field<String>
        //permits
        //    Trim
    {

        /**
         * The string to be trimmed.
         */
        @NotNull default Field<String> $string() { return $arg1(); }

        /**
         * The string to be trimmed.
         */
        @CheckReturnValue
        @NotNull default Trim $string(Field<String> newString) { return $arg1(newString); }

        /**
         * The characters to be trimmed.
         */
        @Nullable default Field<String> $characters() { return $arg2(); }

        /**
         * The characters to be trimmed.
         */
        @CheckReturnValue
        @NotNull default Trim $characters(Field<String> newCharacters) { return $arg2(newCharacters); }
    }

    /**
     * The <code>UPPER</code> function.
     * <p>
     * Turn a string into upper case.
     */
    public /*sealed*/ interface Upper
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<String>, Upper>,
            org.jooq.Field<String>
        //permits
        //    Upper
    {
        @NotNull default Field<String> $string() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Upper $string(Field<String> newString) { return $arg1(newString); }
    }

    /**
     * The <code>UUID</code> function.
     * <p>
     * Generate a random UUID.
     */
    public /*sealed*/ interface Uuid
        extends
            UOperator0<Uuid>,
            org.jooq.Field<UUID>
        //permits
        //    Uuid
    {}

    /**
     * The <code>DATE ADD</code> function.
     * <p>
     * Add an interval to a date.
     */
    public /*sealed*/ interface DateAdd<T>
        extends
            UReturnsNullOnNullInput,
            UOperator3<Field<T>, Field<? extends Number>, DatePart, DateAdd<T>>,
            org.jooq.Field<T>
        //permits
        //    DateAdd
    {

        /**
         * The date to add an interval to
         */
        @NotNull default Field<T> $date() { return $arg1(); }

        /**
         * The date to add an interval to
         */
        @CheckReturnValue
        @NotNull default DateAdd<T> $date(Field<T> newDate) { return $arg1(newDate); }

        /**
         * The interval to add to the date
         */
        @NotNull default Field<? extends Number> $interval() { return $arg2(); }

        /**
         * The interval to add to the date
         */
        @CheckReturnValue
        @NotNull default DateAdd<T> $interval(Field<? extends Number> newInterval) { return $arg2(newInterval); }

        /**
         * The date part describing the interval
         */
        @Nullable default DatePart $datePart() { return $arg3(); }

        /**
         * The date part describing the interval
         */
        @CheckReturnValue
        @NotNull default DateAdd<T> $datePart(DatePart newDatePart) { return $arg3(newDatePart); }
    }

    /**
     * The <code>CARDINALITY</code> function.
     * <p>
     * Calculate the cardinality of an array field.
     */
    public /*sealed*/ interface Cardinality
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<? extends Object[]>, Cardinality>,
            org.jooq.Field<Integer>
        //permits
        //    Cardinality
    {
        @NotNull default Field<? extends Object[]> $array() { return $arg1(); }
        @CheckReturnValue
        @NotNull default Cardinality $array(Field<? extends Object[]> newArray) { return $arg1(newArray); }
    }

    /**
     * The <code>ARRAY GET</code> function.
     * <p>
     * Get an array element at a given index (1 based).
     */
    public /*sealed*/ interface ArrayGet<T>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T[]>, Field<Integer>, ArrayGet<T>>,
            org.jooq.Field<T>
        //permits
        //    ArrayGet
    {
        @NotNull default Field<T[]> $array() { return $arg1(); }
        @CheckReturnValue
        @NotNull default ArrayGet<T> $array(Field<T[]> newArray) { return $arg1(newArray); }
        @NotNull default Field<Integer> $index() { return $arg2(); }
        @CheckReturnValue
        @NotNull default ArrayGet<T> $index(Field<Integer> newIndex) { return $arg2(newIndex); }
    }

    /**
     * The <code>ARRAY CONCAT</code> function.
     * <p>
     * Concatenate two arrays.
     */
    public /*sealed*/ interface ArrayConcat<T>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T[]>, Field<T[]>, ArrayConcat<T>>,
            org.jooq.Field<T[]>
        //permits
        //    ArrayConcat
    {}

    /**
     * The <code>ARRAY APPEND</code> function.
     * <p>
     * Append an element to an array.
     */
    public /*sealed*/ interface ArrayAppend<T>
        extends
            UOperator2<Field<T[]>, Field<T>, ArrayAppend<T>>,
            org.jooq.Field<T[]>
        //permits
        //    ArrayAppend
    {}

    /**
     * The <code>ARRAY PREPEND</code> function.
     * <p>
     * Prepend an element to an array.
     */
    public /*sealed*/ interface ArrayPrepend<T>
        extends
            UOperator2<Field<T>, Field<T[]>, ArrayPrepend<T>>,
            org.jooq.Field<T[]>
        //permits
        //    ArrayPrepend
    {}

    /**
     * The <code>ARRAY OVERLAP</code> function.
     * <p>
     * Check if 2 arrays overlap.
     */
    public /*sealed*/ interface ArrayOverlap<T>
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<T[]>, Field<T[]>, ArrayOverlap<T>>,
            org.jooq.Condition
        //permits
        //    ArrayOverlap
    {}

    /**
     * The <code>ARRAY REMOVE</code> function.
     * <p>
     * Remove an element from an array.
     */
    public /*sealed*/ interface ArrayRemove<T>
        extends
            UOperator2<Field<T[]>, Field<T>, ArrayRemove<T>>,
            org.jooq.Field<T[]>
        //permits
        //    ArrayRemove
    {}

    /**
     * The <code>ARRAY REPLACE</code> function.
     * <p>
     * Replace an element in an array.
     */
    public /*sealed*/ interface ArrayReplace<T>
        extends
            UOperator3<Field<T[]>, Field<T>, Field<T>, ArrayReplace<T>>,
            org.jooq.Field<T[]>
        //permits
        //    ArrayReplace
    {}

    /**
     * The <code>NVL</code> function.
     * <p>
     * Return the first non-null argument.
     */
    public /*sealed*/ interface Nvl<T>
        extends
            UOperator2<Field<T>, Field<T>, Nvl<T>>,
            org.jooq.Field<T>
        //permits
        //    Nvl
    {

        /**
         * The nullable value.
         */
        @NotNull default Field<T> $value() { return $arg1(); }

        /**
         * The nullable value.
         */
        @CheckReturnValue
        @NotNull default Nvl<T> $value(Field<T> newValue) { return $arg1(newValue); }

        /**
         * The default value if the other value is null.
         */
        @NotNull default Field<T> $defaultValue() { return $arg2(); }

        /**
         * The default value if the other value is null.
         */
        @CheckReturnValue
        @NotNull default Nvl<T> $defaultValue(Field<T> newDefaultValue) { return $arg2(newDefaultValue); }
    }

    /**
     * The <code>NULLIF</code> function.
     */
    public /*sealed*/ interface Nullif<T>
        extends
            UOperator2<Field<T>, Field<T>, Nullif<T>>,
            org.jooq.Field<T>
        //permits
        //    Nullif
    {

        /**
         * The result value if the other value is not equal.
         */
        @NotNull default Field<T> $value() { return $arg1(); }

        /**
         * The result value if the other value is not equal.
         */
        @CheckReturnValue
        @NotNull default Nullif<T> $value(Field<T> newValue) { return $arg1(newValue); }

        /**
         * The value to compare the result value with.
         */
        @NotNull default Field<T> $other() { return $arg2(); }

        /**
         * The value to compare the result value with.
         */
        @CheckReturnValue
        @NotNull default Nullif<T> $other(Field<T> newOther) { return $arg2(newOther); }
    }

    /**
     * The <code>CURRENT CATALOG</code> function.
     */
    public /*sealed*/ interface CurrentCatalog
        extends
            UOperator0<CurrentCatalog>,
            org.jooq.Field<String>
        //permits
        //    CurrentCatalog
    {}

    /**
     * The <code>CURRENT SCHEMA</code> function.
     */
    public /*sealed*/ interface CurrentSchema
        extends
            UOperator0<CurrentSchema>,
            org.jooq.Field<String>
        //permits
        //    CurrentSchema
    {}

    /**
     * The <code>CURRENT USER</code> function.
     */
    public /*sealed*/ interface CurrentUser
        extends
            UOperator0<CurrentUser>,
            org.jooq.Field<String>
        //permits
        //    CurrentUser
    {}























































































































































    /**
     * The <code>XMLCOMMENT</code> function.
     */
    public /*sealed*/ interface XMLComment
        extends
            UOperator1<Field<String>, XMLComment>,
            org.jooq.Field<XML>
        //permits
        //    XMLComment
    {
        @NotNull default Field<String> $comment() { return $arg1(); }
        @CheckReturnValue
        @NotNull default XMLComment $comment(Field<String> newComment) { return $arg1(newComment); }
    }

    /**
     * The <code>XMLCONCAT</code> function.
     */
    public /*sealed*/ interface XMLConcat
        extends
            UOperator1<UnmodifiableList<? extends Field<?>>, XMLConcat>,
            org.jooq.Field<XML>
        //permits
        //    XMLConcat
    {}



















    /**
     * The <code>XMLFOREST</code> function.
     */
    public /*sealed*/ interface XMLForest
        extends
            UOperator1<UnmodifiableList<? extends Field<?>>, XMLForest>,
            org.jooq.Field<XML>
        //permits
        //    XMLForest
    {
        @NotNull default UnmodifiableList<? extends Field<?>> $fields() { return $arg1(); }
        @CheckReturnValue
        @NotNull default XMLForest $fields(UnmodifiableList<? extends Field<?>> newFields) { return $arg1(newFields); }
    }

    /**
     * The <code>XMLPI</code> function.
     */
    public /*sealed*/ interface XMLPi
        extends
            UOperator2<Name, Field<?>, XMLPi>,
            org.jooq.Field<XML>
        //permits
        //    XMLPi
    {
        @NotNull default Name $target() { return $arg1(); }
        @CheckReturnValue
        @NotNull default XMLPi $target(Name newTarget) { return $arg1(newTarget); }
        @Nullable default Field<?> $content() { return $arg2(); }
        @CheckReturnValue
        @NotNull default XMLPi $content(Field<?> newContent) { return $arg2(newContent); }
    }

    /**
     * The <code>XMLSERIALIZE</code> function.
     */
    public /*sealed*/ interface XMLSerialize<T>
        extends
            UOperator3<Boolean, Field<XML>, DataType<T>, XMLSerialize<T>>,
            org.jooq.Field<T>
        //permits
        //    XMLSerialize
    {
        @NotNull default Boolean $content() { return $arg1(); }
        @CheckReturnValue
        @NotNull default XMLSerialize<T> $content(Boolean newContent) { return $arg1(newContent); }
        @NotNull default Field<XML> $value() { return $arg2(); }
        @CheckReturnValue
        @NotNull default XMLSerialize<T> $value(Field<XML> newValue) { return $arg2(newValue); }
        @NotNull default DataType<T> $type() { return $arg3(); }
        @CheckReturnValue
        @NotNull default XMLSerialize<T> $type(DataType<T> newType) { return $arg3(newType); }
    }

    /**
     * The <code>JSON ARRAY</code> function.
     */
    public /*sealed*/ interface JSONArray<T>
        extends
            UOperator4<DataType<T>, UnmodifiableList<? extends Field<?>>, JSONOnNull, DataType<?>, JSONArray<T>>,
            Field<T>
        //permits
        //    JSONArray
    {
        @NotNull default DataType<T> $type() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONArray<T> $type(DataType<T> newType) { return $arg1(newType); }
        @NotNull default UnmodifiableList<? extends Field<?>> $fields() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONArray<T> $fields(UnmodifiableList<? extends Field<?>> newFields) { return $arg2(newFields); }
        @Nullable default JSONOnNull $onNull() { return $arg3(); }
        @CheckReturnValue
        @NotNull default JSONArray<T> $onNull(JSONOnNull newOnNull) { return $arg3(newOnNull); }
        @Nullable default DataType<?> $returning() { return $arg4(); }
        @CheckReturnValue
        @NotNull default JSONArray<T> $returning(DataType<?> newReturning) { return $arg4(newReturning); }
    }

    /**
     * The <code>JSON OBJECT</code> function.
     */
    public /*sealed*/ interface JSONObject<T>
        extends
            UOperator4<DataType<T>, UnmodifiableList<? extends JSONEntry<?>>, JSONOnNull, DataType<?>, JSONObject<T>>,
            Field<T>
        //permits
        //    JSONObject
    {
        @NotNull default DataType<T> $type() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONObject<T> $type(DataType<T> newType) { return $arg1(newType); }
        @NotNull default UnmodifiableList<? extends JSONEntry<?>> $entries() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONObject<T> $entries(UnmodifiableList<? extends JSONEntry<?>> newEntries) { return $arg2(newEntries); }
        @Nullable default JSONOnNull $onNull() { return $arg3(); }
        @CheckReturnValue
        @NotNull default JSONObject<T> $onNull(JSONOnNull newOnNull) { return $arg3(newOnNull); }
        @Nullable default DataType<?> $returning() { return $arg4(); }
        @CheckReturnValue
        @NotNull default JSONObject<T> $returning(DataType<?> newReturning) { return $arg4(newReturning); }
    }

    /**
     * The <code>JSON GET ELEMENT</code> function.
     * <p>
     * Access an array element from a JSON array expression.
     */
    public /*sealed*/ interface JSONGetElement
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<JSON>, Field<Integer>, JSONGetElement>,
            org.jooq.Field<JSON>
        //permits
        //    JSONGetElement
    {
        @NotNull default Field<JSON> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONGetElement $field(Field<JSON> newField) { return $arg1(newField); }
        @NotNull default Field<Integer> $index() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONGetElement $index(Field<Integer> newIndex) { return $arg2(newIndex); }
    }

    /**
     * The <code>JSONB GET ELEMENT</code> function.
     * <p>
     * Access an array element from a JSONB array expression.
     */
    public /*sealed*/ interface JSONBGetElement
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<JSONB>, Field<Integer>, JSONBGetElement>,
            org.jooq.Field<JSONB>
        //permits
        //    JSONBGetElement
    {
        @NotNull default Field<JSONB> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONBGetElement $field(Field<JSONB> newField) { return $arg1(newField); }
        @NotNull default Field<Integer> $index() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONBGetElement $index(Field<Integer> newIndex) { return $arg2(newIndex); }
    }

    /**
     * The <code>JSON GET ELEMENT AS TEXT</code> function.
     * <p>
     * Access an array element from a JSON array expression and return it as a string.
     */
    public /*sealed*/ interface JSONGetElementAsText
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<JSON>, Field<Integer>, JSONGetElementAsText>,
            org.jooq.Field<String>
        //permits
        //    JSONGetElementAsText
    {
        @NotNull default Field<JSON> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONGetElementAsText $field(Field<JSON> newField) { return $arg1(newField); }
        @NotNull default Field<Integer> $index() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONGetElementAsText $index(Field<Integer> newIndex) { return $arg2(newIndex); }
    }

    /**
     * The <code>JSONB GET ELEMENT AS TEXT</code> function.
     * <p>
     * Access an array element from a JSONB array expression and return it as a string.
     */
    public /*sealed*/ interface JSONBGetElementAsText
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<JSONB>, Field<Integer>, JSONBGetElementAsText>,
            org.jooq.Field<String>
        //permits
        //    JSONBGetElementAsText
    {
        @NotNull default Field<JSONB> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONBGetElementAsText $field(Field<JSONB> newField) { return $arg1(newField); }
        @NotNull default Field<Integer> $index() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONBGetElementAsText $index(Field<Integer> newIndex) { return $arg2(newIndex); }
    }

    /**
     * The <code>JSON GET ATTRIBUTE</code> function.
     * <p>
     * Access an object attribute value from a JSON object expression.
     */
    public /*sealed*/ interface JSONGetAttribute
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<JSON>, Field<String>, JSONGetAttribute>,
            org.jooq.Field<JSON>
        //permits
        //    JSONGetAttribute
    {
        @NotNull default Field<JSON> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONGetAttribute $field(Field<JSON> newField) { return $arg1(newField); }
        @NotNull default Field<String> $attribute() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONGetAttribute $attribute(Field<String> newAttribute) { return $arg2(newAttribute); }
    }

    /**
     * The <code>JSONB GET ATTRIBUTE</code> function.
     * <p>
     * Access an object attribute value from a JSONB object expression.
     */
    public /*sealed*/ interface JSONBGetAttribute
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<JSONB>, Field<String>, JSONBGetAttribute>,
            org.jooq.Field<JSONB>
        //permits
        //    JSONBGetAttribute
    {
        @NotNull default Field<JSONB> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONBGetAttribute $field(Field<JSONB> newField) { return $arg1(newField); }
        @NotNull default Field<String> $attribute() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONBGetAttribute $attribute(Field<String> newAttribute) { return $arg2(newAttribute); }
    }

    /**
     * The <code>JSON GET ATTRIBUTE AS TEXT</code> function.
     * <p>
     * Access an object attribute value from a JSON object expression and return it as string.
     */
    public /*sealed*/ interface JSONGetAttributeAsText
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<JSON>, Field<String>, JSONGetAttributeAsText>,
            org.jooq.Field<String>
        //permits
        //    JSONGetAttributeAsText
    {
        @NotNull default Field<JSON> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONGetAttributeAsText $field(Field<JSON> newField) { return $arg1(newField); }
        @NotNull default Field<String> $attribute() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONGetAttributeAsText $attribute(Field<String> newAttribute) { return $arg2(newAttribute); }
    }

    /**
     * The <code>JSONB GET ATTRIBUTE AS TEXT</code> function.
     * <p>
     * Access an object attribute value from a JSONB object expression and return it as
     * string.
     */
    public /*sealed*/ interface JSONBGetAttributeAsText
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<JSONB>, Field<String>, JSONBGetAttributeAsText>,
            org.jooq.Field<String>
        //permits
        //    JSONBGetAttributeAsText
    {
        @NotNull default Field<JSONB> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONBGetAttributeAsText $field(Field<JSONB> newField) { return $arg1(newField); }
        @NotNull default Field<String> $attribute() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONBGetAttributeAsText $attribute(Field<String> newAttribute) { return $arg2(newAttribute); }
    }

    /**
     * The <code>JSON KEYS</code> function.
     * <p>
     * Retrieve all keys from a JSON object as an array of strings.
     */
    public /*sealed*/ interface JSONKeys
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<JSON>, JSONKeys>,
            org.jooq.Field<JSON>
        //permits
        //    JSONKeys
    {
        @NotNull default Field<JSON> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONKeys $field(Field<JSON> newField) { return $arg1(newField); }
    }

    /**
     * The <code>JSONB KEYS</code> function.
     * <p>
     * Retrieve all keys from a JSONB object as an array of strings.
     */
    public /*sealed*/ interface JSONBKeys
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<JSONB>, JSONBKeys>,
            org.jooq.Field<JSONB>
        //permits
        //    JSONBKeys
    {
        @NotNull default Field<JSONB> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONBKeys $field(Field<JSONB> newField) { return $arg1(newField); }
    }

    /**
     * The <code>JSON SET</code> function.
     * <p>
     * Add or replace a JSON value to a JSON field at a given path.
     */
    public /*sealed*/ interface JSONSet
        extends
            UOperator3<Field<JSON>, Field<String>, Field<?>, JSONSet>,
            org.jooq.Field<JSON>
        //permits
        //    JSONSet
    {
        @NotNull default Field<JSON> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONSet $field(Field<JSON> newField) { return $arg1(newField); }
        @NotNull default Field<String> $path() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONSet $path(Field<String> newPath) { return $arg2(newPath); }
        @NotNull default Field<?> $value() { return $arg3(); }
        @CheckReturnValue
        @NotNull default JSONSet $value(Field<?> newValue) { return $arg3(newValue); }
    }

    /**
     * The <code>JSONB SET</code> function.
     * <p>
     * Add or replace a JSONB value to a JSONB field at a given path.
     */
    public /*sealed*/ interface JSONBSet
        extends
            UOperator3<Field<JSONB>, Field<String>, Field<?>, JSONBSet>,
            org.jooq.Field<JSONB>
        //permits
        //    JSONBSet
    {
        @NotNull default Field<JSONB> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONBSet $field(Field<JSONB> newField) { return $arg1(newField); }
        @NotNull default Field<String> $path() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONBSet $path(Field<String> newPath) { return $arg2(newPath); }
        @NotNull default Field<?> $value() { return $arg3(); }
        @CheckReturnValue
        @NotNull default JSONBSet $value(Field<?> newValue) { return $arg3(newValue); }
    }

    /**
     * The <code>JSON INSERT</code> function.
     * <p>
     * Add (but not replace) a JSON value to a JSON field at a given path.
     */
    public /*sealed*/ interface JSONInsert
        extends
            UOperator3<Field<JSON>, Field<String>, Field<?>, JSONInsert>,
            org.jooq.Field<JSON>
        //permits
        //    JSONInsert
    {
        @NotNull default Field<JSON> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONInsert $field(Field<JSON> newField) { return $arg1(newField); }
        @NotNull default Field<String> $path() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONInsert $path(Field<String> newPath) { return $arg2(newPath); }
        @NotNull default Field<?> $value() { return $arg3(); }
        @CheckReturnValue
        @NotNull default JSONInsert $value(Field<?> newValue) { return $arg3(newValue); }
    }

    /**
     * The <code>JSONB INSERT</code> function.
     * <p>
     * Add (but not replace) a JSON value to a JSON field at a given path.
     */
    public /*sealed*/ interface JSONBInsert
        extends
            UOperator3<Field<JSONB>, Field<String>, Field<?>, JSONBInsert>,
            org.jooq.Field<JSONB>
        //permits
        //    JSONBInsert
    {
        @NotNull default Field<JSONB> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONBInsert $field(Field<JSONB> newField) { return $arg1(newField); }
        @NotNull default Field<String> $path() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONBInsert $path(Field<String> newPath) { return $arg2(newPath); }
        @NotNull default Field<?> $value() { return $arg3(); }
        @CheckReturnValue
        @NotNull default JSONBInsert $value(Field<?> newValue) { return $arg3(newValue); }
    }

    /**
     * The <code>JSON REPLACE</code> function.
     * <p>
     * Replace (but not add) a JSON value to a JSON field at a given path.
     */
    public /*sealed*/ interface JSONReplace
        extends
            UOperator3<Field<JSON>, Field<String>, Field<?>, JSONReplace>,
            org.jooq.Field<JSON>
        //permits
        //    JSONReplace
    {
        @NotNull default Field<JSON> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONReplace $field(Field<JSON> newField) { return $arg1(newField); }
        @NotNull default Field<String> $path() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONReplace $path(Field<String> newPath) { return $arg2(newPath); }
        @NotNull default Field<?> $value() { return $arg3(); }
        @CheckReturnValue
        @NotNull default JSONReplace $value(Field<?> newValue) { return $arg3(newValue); }
    }

    /**
     * The <code>JSONB REPLACE</code> function.
     * <p>
     * Replace (but not add) a JSONB value to a JSONB field at a given path.
     */
    public /*sealed*/ interface JSONBReplace
        extends
            UOperator3<Field<JSONB>, Field<String>, Field<?>, JSONBReplace>,
            org.jooq.Field<JSONB>
        //permits
        //    JSONBReplace
    {
        @NotNull default Field<JSONB> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONBReplace $field(Field<JSONB> newField) { return $arg1(newField); }
        @NotNull default Field<String> $path() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONBReplace $path(Field<String> newPath) { return $arg2(newPath); }
        @NotNull default Field<?> $value() { return $arg3(); }
        @CheckReturnValue
        @NotNull default JSONBReplace $value(Field<?> newValue) { return $arg3(newValue); }
    }

    /**
     * The <code>JSON REMOVE</code> function.
     * <p>
     * Remove a JSON value from a JSON field at a given path.
     */
    public /*sealed*/ interface JSONRemove
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<JSON>, Field<String>, JSONRemove>,
            org.jooq.Field<JSON>
        //permits
        //    JSONRemove
    {
        @NotNull default Field<JSON> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONRemove $field(Field<JSON> newField) { return $arg1(newField); }
        @NotNull default Field<String> $path() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONRemove $path(Field<String> newPath) { return $arg2(newPath); }
    }

    /**
     * The <code>JSONB REMOVE</code> function.
     * <p>
     * Remove a JSONB value from a JSONB field at a given path.
     */
    public /*sealed*/ interface JSONBRemove
        extends
            UReturnsNullOnNullInput,
            UOperator2<Field<JSONB>, Field<String>, JSONBRemove>,
            org.jooq.Field<JSONB>
        //permits
        //    JSONBRemove
    {
        @NotNull default Field<JSONB> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default JSONBRemove $field(Field<JSONB> newField) { return $arg1(newField); }
        @NotNull default Field<String> $path() { return $arg2(); }
        @CheckReturnValue
        @NotNull default JSONBRemove $path(Field<String> newPath) { return $arg2(newPath); }
    }







































    /**
     * The <code>FIELD</code> function.
     * <p>
     * Wrap a condition in a boolean field.
     */
    public /*sealed*/ interface ConditionAsField
        extends
            UReturnsNullOnNullInput,
            UOperator1<Condition, ConditionAsField>,
            org.jooq.Field<Boolean>
        //permits
        //    ConditionAsField
    {
        @NotNull default Condition $condition() { return $arg1(); }
        @CheckReturnValue
        @NotNull default ConditionAsField $condition(Condition newCondition) { return $arg1(newCondition); }
    }

    /**
     * The <code>CONDITION</code> function.
     * <p>
     * Create a condition from a boolean field.
     * <p>
     * Databases that support boolean data types can use boolean expressions
     * as predicates or as columns interchangeably. This extends to any type
     * of field, including functions. A Postgres example:
     * <p>
     * <pre><code>
     * select 1 where texteq('a', 'a');
     * </code></pre>
     */
    public /*sealed*/ interface FieldCondition
        extends
            UReturnsNullOnNullInput,
            UOperator1<Field<Boolean>, FieldCondition>,
            org.jooq.Condition
        //permits
        //    FieldCondition
    {
        @NotNull default Field<Boolean> $field() { return $arg1(); }
        @CheckReturnValue
        @NotNull default FieldCondition $field(Field<Boolean> newField) { return $arg1(newField); }
    }

    /**
     * The <code>ANY VALUE</code> function.
     * <p>
     * Get any arbitrary value from the group.
     */
    public /*sealed*/ interface AnyValue<T>
        extends
            org.jooq.AggregateFunction<T>
        //permits
        //    AnyValue
    {
        @NotNull Field<T> $field();
        @CheckReturnValue
        @NotNull AnyValue<T> $field(Field<T> field);
    }

    /**
     * The <code>AVG</code> function.
     */
    public /*sealed*/ interface Avg
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    Avg
    {
        @NotNull Field<? extends Number> $field();
        boolean $distinct();
        @CheckReturnValue
        @NotNull Avg $field(Field<? extends Number> field);
        @CheckReturnValue
        @NotNull Avg $distinct(boolean distinct);
    }

    /**
     * The <code>BIT AND AGG</code> function.
     * <p>
     * Calculate the bitwise <code>AND</code> aggregate value.
     */
    public /*sealed*/ interface BitAndAgg<T extends Number>
        extends
            org.jooq.AggregateFunction<T>
        //permits
        //    BitAndAgg
    {
        @NotNull Field<T> $value();
        @CheckReturnValue
        @NotNull BitAndAgg<T> $value(Field<T> value);
    }

    /**
     * The <code>BIT OR AGG</code> function.
     * <p>
     * Calculate the bitwise <code>OR</code> aggregate value.
     */
    public /*sealed*/ interface BitOrAgg<T extends Number>
        extends
            org.jooq.AggregateFunction<T>
        //permits
        //    BitOrAgg
    {
        @NotNull Field<T> $value();
        @CheckReturnValue
        @NotNull BitOrAgg<T> $value(Field<T> value);
    }

    /**
     * The <code>BIT XOR AGG</code> function.
     * <p>
     * Calculate the bitwise <code>XOR</code> aggregate value.
     */
    public /*sealed*/ interface BitXorAgg<T extends Number>
        extends
            org.jooq.AggregateFunction<T>
        //permits
        //    BitXorAgg
    {
        @NotNull Field<T> $value();
        @CheckReturnValue
        @NotNull BitXorAgg<T> $value(Field<T> value);
    }

    /**
     * The <code>BIT NAND AGG</code> function.
     * <p>
     * Calculate the bitwise <code>NAND</code> aggregate value.
     */
    public /*sealed*/ interface BitNandAgg<T extends Number>
        extends
            org.jooq.AggregateFunction<T>
        //permits
        //    BitNandAgg
    {
        @NotNull Field<T> $value();
        @CheckReturnValue
        @NotNull BitNandAgg<T> $value(Field<T> value);
    }

    /**
     * The <code>BIT NOR AGG</code> function.
     * <p>
     * Calculate the bitwise <code>NOR</code> aggregate value.
     */
    public /*sealed*/ interface BitNorAgg<T extends Number>
        extends
            org.jooq.AggregateFunction<T>
        //permits
        //    BitNorAgg
    {
        @NotNull Field<T> $value();
        @CheckReturnValue
        @NotNull BitNorAgg<T> $value(Field<T> value);
    }

    /**
     * The <code>BIT X NOR AGG</code> function.
     * <p>
     * Calculate the bitwise <code>XNOR</code> aggregate value.
     */
    public /*sealed*/ interface BitXNorAgg<T extends Number>
        extends
            org.jooq.AggregateFunction<T>
        //permits
        //    BitXNorAgg
    {
        @NotNull Field<T> $value();
        @CheckReturnValue
        @NotNull BitXNorAgg<T> $value(Field<T> value);
    }

    /**
     * The <code>BOOL AND</code> function.
     */
    public /*sealed*/ interface BoolAnd
        extends
            org.jooq.AggregateFunction<Boolean>
        //permits
        //    BoolAnd
    {
        @NotNull Condition $condition();
        @CheckReturnValue
        @NotNull BoolAnd $condition(Condition condition);
    }

    /**
     * The <code>BOOL OR</code> function.
     */
    public /*sealed*/ interface BoolOr
        extends
            org.jooq.AggregateFunction<Boolean>
        //permits
        //    BoolOr
    {
        @NotNull Condition $condition();
        @CheckReturnValue
        @NotNull BoolOr $condition(Condition condition);
    }

    /**
     * The <code>CORR</code> function.
     * <p>
     * Calculate the correlation coefficient. This standard SQL function may be supported
     * natively, or emulated using {@link DSL#covarPop(Field, Field)} and {@link DSL#stddevPop(Field)}.
     * If an emulation is applied, beware of the risk of "<a href="https://en.wikipedia.org/wiki/Catastrophic_cancellation">Catastrophic
     * cancellation</a>" in case the calculations are performed using floating point arithmetic.
     */
    public /*sealed*/ interface Corr
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    Corr
    {
        @NotNull Field<? extends Number> $y();
        @NotNull Field<? extends Number> $x();
        @CheckReturnValue
        @NotNull Corr $y(Field<? extends Number> y);
        @CheckReturnValue
        @NotNull Corr $x(Field<? extends Number> x);
    }

    /**
     * The <code>COUNT</code> function.
     */
    public /*sealed*/ interface Count
        extends
            org.jooq.AggregateFunction<Integer>
        //permits
        //    Count
    {
        @NotNull Field<?> $field();
        boolean $distinct();
        @CheckReturnValue
        @NotNull Count $field(Field<?> field);
        @CheckReturnValue
        @NotNull Count $distinct(boolean distinct);
    }

    /**
     * The <code>COVAR SAMP</code> function.
     * <p>
     * Calculate the sample covariance. This standard SQL function may be supported natively,
     * or emulated using {@link DSL#sum(Field)} and {@link DSL#count(Field)}. If an emulation
     * is applied, beware of the risk of "<a href="https://en.wikipedia.org/wiki/Catastrophic_cancellation">Catastrophic
     * cancellation</a>" in case the calculations are performed using floating point arithmetic.
     */
    public /*sealed*/ interface CovarSamp
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    CovarSamp
    {
        @NotNull Field<? extends Number> $y();
        @NotNull Field<? extends Number> $x();
        @CheckReturnValue
        @NotNull CovarSamp $y(Field<? extends Number> y);
        @CheckReturnValue
        @NotNull CovarSamp $x(Field<? extends Number> x);
    }

    /**
     * The <code>COVAR POP</code> function.
     * <p>
     * Calculate the population covariance. This standard SQL function may be supported
     * natively, or emulated using {@link DSL#sum(Field)} and {@link DSL#count(Field)}.
     * If an emulation is applied, beware of the risk of "<a href="https://en.wikipedia.org/wiki/Catastrophic_cancellation">Catastrophic
     * cancellation</a>" in case the calculations are performed using floating point arithmetic.
     */
    public /*sealed*/ interface CovarPop
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    CovarPop
    {
        @NotNull Field<? extends Number> $y();
        @NotNull Field<? extends Number> $x();
        @CheckReturnValue
        @NotNull CovarPop $y(Field<? extends Number> y);
        @CheckReturnValue
        @NotNull CovarPop $x(Field<? extends Number> x);
    }

    /**
     * The <code>MAX</code> function.
     */
    public /*sealed*/ interface Max<T>
        extends
            org.jooq.AggregateFunction<T>
        //permits
        //    Max
    {
        @NotNull Field<T> $field();
        boolean $distinct();
        @CheckReturnValue
        @NotNull Max<T> $field(Field<T> field);
        @CheckReturnValue
        @NotNull Max<T> $distinct(boolean distinct);
    }

    /**
     * The <code>MEDIAN</code> function.
     */
    public /*sealed*/ interface Median
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    Median
    {
        @NotNull Field<? extends Number> $field();
        @CheckReturnValue
        @NotNull Median $field(Field<? extends Number> field);
    }

    /**
     * The <code>MIN</code> function.
     */
    public /*sealed*/ interface Min<T>
        extends
            org.jooq.AggregateFunction<T>
        //permits
        //    Min
    {
        @NotNull Field<T> $field();
        boolean $distinct();
        @CheckReturnValue
        @NotNull Min<T> $field(Field<T> field);
        @CheckReturnValue
        @NotNull Min<T> $distinct(boolean distinct);
    }

    /**
     * The <code>PRODUCT</code> function.
     * <p>
     * Get the sum over a numeric field: product(distinct field).
     * <p>
     * Few dialects currently support multiplicative aggregation natively. jOOQ
     * emulates this using <code>exp(sum(log(arg)))</code> for strictly positive
     * numbers, and does some additional handling for zero and negative numbers.
     * <p>
     * Note that this implementation may introduce rounding errors, even for
     * integer multiplication.
     * <p>
     * More information here: <a href=
     * "https://blog.jooq.org/how-to-write-a-multiplication-aggregate-function-in-sql">https://blog.jooq.org/how-to-write-a-multiplication-aggregate-function-in-sql</a>.
     */
    public /*sealed*/ interface Product
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    Product
    {
        @NotNull Field<? extends Number> $field();
        boolean $distinct();
        @CheckReturnValue
        @NotNull Product $field(Field<? extends Number> field);
        @CheckReturnValue
        @NotNull Product $distinct(boolean distinct);
    }

    /**
     * The <code>REGR AVGX</code> function.
     * <p>
     * Calculate the average of the independent values (x). This standard SQL function may
     * be supported natively, or emulated using {@link DSL#sum(Field)} and {@link DSL#count(Field)}.
     * If an emulation is applied, beware of the risk of "<a href="https://en.wikipedia.org/wiki/Catastrophic_cancellation">Catastrophic
     * cancellation</a>" in case the calculations are performed using floating point arithmetic.
     */
    public /*sealed*/ interface RegrAvgX
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    RegrAvgX
    {
        @NotNull Field<? extends Number> $y();
        @NotNull Field<? extends Number> $x();
        @CheckReturnValue
        @NotNull RegrAvgX $y(Field<? extends Number> y);
        @CheckReturnValue
        @NotNull RegrAvgX $x(Field<? extends Number> x);
    }

    /**
     * The <code>REGR AVGY</code> function.
     * <p>
     * Calculate the average of the dependent values (y). This standard SQL function may
     * be supported natively, or emulated using {@link DSL#sum(Field)} and {@link DSL#count(Field)}.
     * If an emulation is applied, beware of the risk of "<a href="https://en.wikipedia.org/wiki/Catastrophic_cancellation">Catastrophic
     * cancellation</a>" in case the calculations are performed using floating point arithmetic.
     */
    public /*sealed*/ interface RegrAvgY
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    RegrAvgY
    {
        @NotNull Field<? extends Number> $y();
        @NotNull Field<? extends Number> $x();
        @CheckReturnValue
        @NotNull RegrAvgY $y(Field<? extends Number> y);
        @CheckReturnValue
        @NotNull RegrAvgY $x(Field<? extends Number> x);
    }

    /**
     * The <code>REGR COUNT</code> function.
     * <p>
     * Calculate the number of non-<code>NULL</code> pairs. This standard SQL function may
     * be supported natively, or emulated using {@link DSL#sum(Field)} and {@link DSL#count(Field)}.
     * If an emulation is applied, beware of the risk of "<a href="https://en.wikipedia.org/wiki/Catastrophic_cancellation">Catastrophic
     * cancellation</a>" in case the calculations are performed using floating point arithmetic.
     */
    public /*sealed*/ interface RegrCount
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    RegrCount
    {
        @NotNull Field<? extends Number> $y();
        @NotNull Field<? extends Number> $x();
        @CheckReturnValue
        @NotNull RegrCount $y(Field<? extends Number> y);
        @CheckReturnValue
        @NotNull RegrCount $x(Field<? extends Number> x);
    }

    /**
     * The <code>REGR INTERCEPT</code> function.
     * <p>
     * Calculate the y intercept of the regression line. This standard SQL function may
     * be supported natively, or emulated using {@link DSL#sum(Field)} and {@link DSL#count(Field)}.
     * If an emulation is applied, beware of the risk of "<a href="https://en.wikipedia.org/wiki/Catastrophic_cancellation">Catastrophic
     * cancellation</a>" in case the calculations are performed using floating point arithmetic.
     */
    public /*sealed*/ interface RegrIntercept
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    RegrIntercept
    {
        @NotNull Field<? extends Number> $y();
        @NotNull Field<? extends Number> $x();
        @CheckReturnValue
        @NotNull RegrIntercept $y(Field<? extends Number> y);
        @CheckReturnValue
        @NotNull RegrIntercept $x(Field<? extends Number> x);
    }

    /**
     * The <code>REGR R2</code> function.
     * <p>
     * Calculate the coefficient of determination. This standard SQL function may be supported
     * natively, or emulated using {@link DSL#sum(Field)} and {@link DSL#count(Field)}.
     * If an emulation is applied, beware of the risk of "<a href="https://en.wikipedia.org/wiki/Catastrophic_cancellation">Catastrophic
     * cancellation</a>" in case the calculations are performed using floating point arithmetic.
     */
    public /*sealed*/ interface RegrR2
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    RegrR2
    {
        @NotNull Field<? extends Number> $y();
        @NotNull Field<? extends Number> $x();
        @CheckReturnValue
        @NotNull RegrR2 $y(Field<? extends Number> y);
        @CheckReturnValue
        @NotNull RegrR2 $x(Field<? extends Number> x);
    }

    /**
     * The <code>REGR SLOPE</code> function.
     * <p>
     * Calculate the slope of the regression line. This standard SQL function may be supported
     * natively, or emulated using {@link DSL#sum(Field)} and {@link DSL#count(Field)}.
     * If an emulation is applied, beware of the risk of "<a href="https://en.wikipedia.org/wiki/Catastrophic_cancellation">Catastrophic
     * cancellation</a>" in case the calculations are performed using floating point arithmetic.
     */
    public /*sealed*/ interface RegrSlope
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    RegrSlope
    {
        @NotNull Field<? extends Number> $y();
        @NotNull Field<? extends Number> $x();
        @CheckReturnValue
        @NotNull RegrSlope $y(Field<? extends Number> y);
        @CheckReturnValue
        @NotNull RegrSlope $x(Field<? extends Number> x);
    }

    /**
     * The <code>REGR SXX</code> function.
     * <p>
     * Calculate the <code>REGR_SXX</code> auxiliary function. This standard SQL function
     * may be supported natively, or emulated using {@link DSL#sum(Field)} and {@link DSL#count(Field)}.
     * If an emulation is applied, beware of the risk of "<a href="https://en.wikipedia.org/wiki/Catastrophic_cancellation">Catastrophic
     * cancellation</a>" in case the calculations are performed using floating point arithmetic.
     */
    public /*sealed*/ interface RegrSxx
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    RegrSxx
    {
        @NotNull Field<? extends Number> $y();
        @NotNull Field<? extends Number> $x();
        @CheckReturnValue
        @NotNull RegrSxx $y(Field<? extends Number> y);
        @CheckReturnValue
        @NotNull RegrSxx $x(Field<? extends Number> x);
    }

    /**
     * The <code>REGR SXY</code> function.
     * <p>
     * Calculate the <code>REGR_SXY</code> auxiliary function. This standard SQL function
     * may be supported natively, or emulated using {@link DSL#sum(Field)} and {@link DSL#count(Field)}.
     * If an emulation is applied, beware of the risk of "<a href="https://en.wikipedia.org/wiki/Catastrophic_cancellation">Catastrophic
     * cancellation</a>" in case the calculations are performed using floating point arithmetic.
     */
    public /*sealed*/ interface RegrSxy
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    RegrSxy
    {
        @NotNull Field<? extends Number> $y();
        @NotNull Field<? extends Number> $x();
        @CheckReturnValue
        @NotNull RegrSxy $y(Field<? extends Number> y);
        @CheckReturnValue
        @NotNull RegrSxy $x(Field<? extends Number> x);
    }

    /**
     * The <code>REGR SYY</code> function.
     * <p>
     * Calculate the <code>REGR_SYY</code> auxiliary function. This standard SQL function
     * may be supported natively, or emulated using {@link DSL#sum(Field)} and {@link DSL#count(Field)}.
     * If an emulation is applied, beware of the risk of "<a href="https://en.wikipedia.org/wiki/Catastrophic_cancellation">Catastrophic
     * cancellation</a>" in case the calculations are performed using floating point arithmetic.
     */
    public /*sealed*/ interface RegrSyy
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    RegrSyy
    {
        @NotNull Field<? extends Number> $y();
        @NotNull Field<? extends Number> $x();
        @CheckReturnValue
        @NotNull RegrSyy $y(Field<? extends Number> y);
        @CheckReturnValue
        @NotNull RegrSyy $x(Field<? extends Number> x);
    }

    /**
     * The <code>STDDEV POP</code> function.
     * <p>
     * Calculate the population standard deviation. This standard SQL function may be supported
     * natively, or emulated using {@link DSL#sum(Field)} and {@link DSL#count(Field)}.
     * If an emulation is applied, beware of the risk of "<a href="https://en.wikipedia.org/wiki/Catastrophic_cancellation">Catastrophic
     * cancellation</a>" in case the calculations are performed using floating point arithmetic.
     */
    public /*sealed*/ interface StddevPop
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    StddevPop
    {
        @NotNull Field<? extends Number> $field();
        @CheckReturnValue
        @NotNull StddevPop $field(Field<? extends Number> field);
    }

    /**
     * The <code>STDDEV SAMP</code> function.
     * <p>
     * Calculate the sample standard deviation. This standard SQL function may be supported
     * natively, or emulated using {@link DSL#sum(Field)} and {@link DSL#count(Field)}.
     * If an emulation is applied, beware of the risk of "<a href="https://en.wikipedia.org/wiki/Catastrophic_cancellation">Catastrophic
     * cancellation</a>" in case the calculations are performed using floating point arithmetic.
     */
    public /*sealed*/ interface StddevSamp
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    StddevSamp
    {
        @NotNull Field<? extends Number> $field();
        @CheckReturnValue
        @NotNull StddevSamp $field(Field<? extends Number> field);
    }

    /**
     * The <code>SUM</code> function.
     */
    public /*sealed*/ interface Sum
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    Sum
    {
        @NotNull Field<? extends Number> $field();
        boolean $distinct();
        @CheckReturnValue
        @NotNull Sum $field(Field<? extends Number> field);
        @CheckReturnValue
        @NotNull Sum $distinct(boolean distinct);
    }

    /**
     * The <code>VAR POP</code> function.
     * <p>
     * Calculate the population variance. This standard SQL function may be supported natively,
     * or emulated using {@link DSL#sum(Field)} and {@link DSL#count(Field)}. If an emulation
     * is applied, beware of the risk of "<a href="https://en.wikipedia.org/wiki/Catastrophic_cancellation">Catastrophic
     * cancellation</a>" in case the calculations are performed using floating point arithmetic.
     */
    public /*sealed*/ interface VarPop
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    VarPop
    {
        @NotNull Field<? extends Number> $field();
        @CheckReturnValue
        @NotNull VarPop $field(Field<? extends Number> field);
    }

    /**
     * The <code>VAR SAMP</code> function.
     * <p>
     * Calculate the sample variance. This standard SQL function may be supported natively,
     * or emulated using {@link DSL#sum(Field)} and {@link DSL#count(Field)}. If an emulation
     * is applied, beware of the risk of "<a href="https://en.wikipedia.org/wiki/Catastrophic_cancellation">Catastrophic
     * cancellation</a>" in case the calculations are performed using floating point arithmetic.
     */
    public /*sealed*/ interface VarSamp
        extends
            org.jooq.AggregateFunction<BigDecimal>
        //permits
        //    VarSamp
    {
        @NotNull Field<? extends Number> $field();
        @CheckReturnValue
        @NotNull VarSamp $field(Field<? extends Number> field);
    }





























































































































































































































































































































































































































































































































































































































































































































































    /**
     * The <code>Cascade</code> type.
     * <p>
     * Cascade a DDL operation to all dependent objects, or restrict it to this object only.
     */
    public enum Cascade {
        CASCADE(keyword("cascade")),
        RESTRICT(keyword("restrict")),
        ;

        final Keyword keyword;

        private Cascade(Keyword keyword) {
            this.keyword = keyword;
        }
    }

    /**
     * The <code>CycleOption</code> type.
     * <p>
     * Specify whether a sequence cycles to its minvalue once it reaches its maxvalue.
     */
    public enum CycleOption {
        CYCLE(keyword("cycle")),
        NO_CYCLE(keyword("no cycle")),
        ;

        final Keyword keyword;

        private CycleOption(Keyword keyword) {
            this.keyword = keyword;
        }
    }

    /**
     * The <code>IdentityRestartOption</code> type.
     * <p>
     * Specify whether an identity column should be restarted upon truncation.
     */
    public enum IdentityRestartOption {
        CONTINUE_IDENTITY(keyword("continue identity")),
        RESTART_IDENTITY(keyword("restart identity")),
        ;

        final Keyword keyword;

        private IdentityRestartOption(Keyword keyword) {
            this.keyword = keyword;
        }
    }

    /**
     * The <code>GenerationLocation</code> type.
     * <p>
     * Specify where a computed column should be computed, i.e. in the client or on the
     * server.
     */
    public enum GenerationLocation {
        CLIENT(keyword("client")),
        SERVER(keyword("server")),
        ;

        final Keyword keyword;

        private GenerationLocation(Keyword keyword) {
            this.keyword = keyword;
        }
    }

    /**
     * The <code>GenerationOption</code> type.
     * <p>
     * Specify whether a computed column should be stored, or computed virtually / on the
     * fly.
     */
    public enum GenerationOption {
        STORED(keyword("stored")),
        VIRTUAL(keyword("virtual")),
        DEFAULT(keyword("default")),
        ;

        final Keyword keyword;

        private GenerationOption(Keyword keyword) {
            this.keyword = keyword;
        }
    }

    /**
     * The <code>WithOrWithoutData</code> type.
     * <p>
     * Specify whether a table created from a subquery should include the subquery's data.
     */
    public enum WithOrWithoutData {
        WITH_DATA(keyword("with data")),
        WITH_NO_DATA(keyword("with no data")),
        ;

        final Keyword keyword;

        private WithOrWithoutData(Keyword keyword) {
            this.keyword = keyword;
        }
    }

    /**
     * The <code>TableCommitAction</code> type.
     * <p>
     * Specify the action to be taken on temporary tables when committing.
     */
    public enum TableCommitAction {
        DELETE_ROWS(keyword("delete rows")),
        PRESERVE_ROWS(keyword("preserve rows")),
        DROP(keyword("drop")),
        ;

        final Keyword keyword;

        private TableCommitAction(Keyword keyword) {
            this.keyword = keyword;
        }
    }





























































    /**
     * The <code>NullOrdering</code> type.
     * <p>
     * The explicit ordering of NULL values in ORDER BY clauses. If unspecified, the behaviour
     * is implementation defined.
     */
    public enum NullOrdering {
        NULLS_FIRST(keyword("nulls first")),
        NULLS_LAST(keyword("nulls last")),
        ;

        final Keyword keyword;

        private NullOrdering(Keyword keyword) {
            this.keyword = keyword;
        }
    }

    /**
     * The <code>NullTreatment</code> type.
     * <p>
     * Specify whether to include NULL values or ignore NULL values in certain window functions.
     */
    public enum NullTreatment {
        RESPECT_NULLS(keyword("respect nulls")),
        IGNORE_NULLS(keyword("ignore nulls")),
        ;

        final Keyword keyword;

        private NullTreatment(Keyword keyword) {
            this.keyword = keyword;
        }
    }

    /**
     * The <code>FromFirstOrLast</code> type.
     * <p>
     * Specify whether the NTH_VALUE window function should count N values from the first
     * or last value in the window.
     */
    public enum FromFirstOrLast {
        FROM_FIRST(keyword("from first")),
        FROM_LAST(keyword("from last")),
        ;

        final Keyword keyword;

        private FromFirstOrLast(Keyword keyword) {
            this.keyword = keyword;
        }
    }

    /**
     * The <code>FrameUnits</code> type.
     * <p>
     * The window frame unit specification.
     */
    public enum FrameUnits {
        ROWS(keyword("rows")),
        RANGE(keyword("range")),
        GROUPS(keyword("groups")),
        ;

        final Keyword keyword;

        private FrameUnits(Keyword keyword) {
            this.keyword = keyword;
        }
    }

    /**
     * The <code>FrameExclude</code> type.
     * <p>
     * Specify which values within the window frame should be excluded.
     */
    public enum FrameExclude {
        CURRENT_ROW(keyword("current row")),
        TIES(keyword("ties")),
        GROUP(keyword("group")),
        NO_OTHERS(keyword("no others")),
        ;

        final Keyword keyword;

        private FrameExclude(Keyword keyword) {
            this.keyword = keyword;
        }
    }

    /**
     * The <code>JSONOnNull</code> type.
     * <p>
     * Specify whether a JSON array or object should include NULL values in the output.
     */
    public enum JSONOnNull {
        NULL_ON_NULL(keyword("null on null")),
        ABSENT_ON_NULL(keyword("absent on null")),
        ;

        final Keyword keyword;

        private JSONOnNull(Keyword keyword) {
            this.keyword = keyword;
        }
    }

    /**
     * The <code>XMLPassingMechanism</code> type.
     * <p>
     * Specify how XML contents should be passed to certain XML functions.
     */
    public enum XMLPassingMechanism {
        BY_REF(keyword("by ref")),
        BY_VALUE(keyword("by value")),
        DEFAULT(keyword("default")),
        ;

        final Keyword keyword;

        private XMLPassingMechanism(Keyword keyword) {
            this.keyword = keyword;
        }
    }

    /**
     * The <code>DocumentOrContent</code> type.
     * <p>
     * Specify whether XML content is a DOM document or a document fragment (content).
     */
    public enum DocumentOrContent {
        DOCUMENT(keyword("document")),
        CONTENT(keyword("content")),
        ;

        final Keyword keyword;

        private DocumentOrContent(Keyword keyword) {
            this.keyword = keyword;
        }
    }

    /**
     * The <code>Materialized</code> type.
     * <p>
     * Hint whether a CTE should be materialised or inlined. If unspecified, the optimiser
     * may produce implementation defined behaviour.
     */
    public enum Materialized {
        MATERIALIZED(keyword("materialized")),
        NOT_MATERIALIZED(keyword("not materialized")),
        ;

        final Keyword keyword;

        private Materialized(Keyword keyword) {
            this.keyword = keyword;
        }
    }

    /**
     * The <code>ResultOption</code> type.
     * <p>
     * The data change delta table result semantics.
     */
    public enum ResultOption {
        OLD(keyword("old")),
        NEW(keyword("new")),
        FINAL(keyword("final")),
        ;

        final Keyword keyword;

        private ResultOption(Keyword keyword) {
            this.keyword = keyword;
        }
    }

    /**
     * The <code>Quantifier</code> type.
     * <p>
     * A quantifier for quantified selects.
     */
    public enum Quantifier {
        ANY(keyword("any")),
        ALL(keyword("all")),
        ;

        final Keyword keyword;

        private Quantifier(Keyword keyword) {
            this.keyword = keyword;
        }
    }



    // -------------------------------------------------------------------------
    // XXX: Utility API
    // -------------------------------------------------------------------------

    interface UOperator<R extends org.jooq.QueryPart> extends org.jooq.QueryPart {
        @NotNull
        List<?> $args();
    }
    interface UOperator0<R extends UOperator0<R>> extends UOperator<R> {

        @NotNull
        Function0<? extends R> $constructor();

        @NotNull
        @Override
        default List<?> $args() {
            return Collections.emptyList();
        }



















    }

    interface UOperator1<Q1, R extends UOperator1<Q1, R>> extends UOperator<R> {
        Q1 $arg1();

        @CheckReturnValue
        @NotNull default R $arg1(Q1 newArg1) { return $constructor().apply(newArg1); }

        @NotNull
        Function1<? super Q1, ? extends R> $constructor();

        @NotNull
        @Override
        default List<?> $args() {
            return unmodifiableList(asList($arg1()));
        }




















    }

    interface UOperator2<Q1, Q2, R extends UOperator2<Q1, Q2, R>> extends UOperator<R> {
        Q1 $arg1();
        Q2 $arg2();

        @CheckReturnValue
        @NotNull default R $arg1(Q1 newArg1) { return $constructor().apply(newArg1, $arg2()); }
        @CheckReturnValue
        @NotNull default R $arg2(Q2 newArg2) { return $constructor().apply($arg1(), newArg2); }

        @NotNull
        Function2<? super Q1, ? super Q2, ? extends R> $constructor();

        @NotNull
        @Override
        default List<?> $args() {
            return unmodifiableList(asList($arg1(), $arg2()));
        }





















    }

    interface UOperator3<Q1, Q2, Q3, R extends UOperator3<Q1, Q2, Q3, R>> extends UOperator<R> {
        Q1 $arg1();
        Q2 $arg2();
        Q3 $arg3();

        @CheckReturnValue
        @NotNull default R $arg1(Q1 newArg1) { return $constructor().apply(newArg1, $arg2(), $arg3()); }
        @CheckReturnValue
        @NotNull default R $arg2(Q2 newArg2) { return $constructor().apply($arg1(), newArg2, $arg3()); }
        @CheckReturnValue
        @NotNull default R $arg3(Q3 newArg3) { return $constructor().apply($arg1(), $arg2(), newArg3); }

        @NotNull
        Function3<? super Q1, ? super Q2, ? super Q3, ? extends R> $constructor();

        @NotNull
        @Override
        default List<?> $args() {
            return unmodifiableList(asList($arg1(), $arg2(), $arg3()));
        }






















    }

    interface UOperator4<Q1, Q2, Q3, Q4, R extends UOperator4<Q1, Q2, Q3, Q4, R>> extends UOperator<R> {
        Q1 $arg1();
        Q2 $arg2();
        Q3 $arg3();
        Q4 $arg4();

        @CheckReturnValue
        @NotNull default R $arg1(Q1 newArg1) { return $constructor().apply(newArg1, $arg2(), $arg3(), $arg4()); }
        @CheckReturnValue
        @NotNull default R $arg2(Q2 newArg2) { return $constructor().apply($arg1(), newArg2, $arg3(), $arg4()); }
        @CheckReturnValue
        @NotNull default R $arg3(Q3 newArg3) { return $constructor().apply($arg1(), $arg2(), newArg3, $arg4()); }
        @CheckReturnValue
        @NotNull default R $arg4(Q4 newArg4) { return $constructor().apply($arg1(), $arg2(), $arg3(), newArg4); }

        @NotNull
        Function4<? super Q1, ? super Q2, ? super Q3, ? super Q4, ? extends R> $constructor();

        @NotNull
        @Override
        default List<?> $args() {
            return unmodifiableList(asList($arg1(), $arg2(), $arg3(), $arg4()));
        }























    }

    /**
     * A binary {@link UOperator2} whose operands can be swapped using
     * {@link #$converse()} producing the converse relation.
     */
    interface UConvertibleOperator<Q, R extends UConvertibleOperator<Q, R, C>, C extends UConvertibleOperator<Q, C, R>> extends UOperator2<Q, Q, R> {

        /**
         * Create a new expression with swapped operands, using the converse
         * operator.
         */
        @NotNull
        C $converse();
    }

    /**
     * A binary {@link UOperator2} whose operands can be swapped using
     * {@link #$swap()} without changing the operator's semantics.
     */
    interface UCommutativeOperator<Q, R extends UCommutativeOperator<Q, R>> extends UConvertibleOperator<Q, R, R> {

        /**
         * Create a new expression with swapped operands.
         */
        @NotNull
        default R $swap() {
            return $constructor().apply($arg2(), $arg1());
        }

        @Override
        default R $converse() {
            return $swap();
        }
    }

    /**
     * A marker interface for {@link QueryPart} implementations that represent
     * functions or operators who evaluate to <code>NULL</code> as soon as at
     * least one argument is <code>NULL</code>.
     */
    interface UReturnsNullOnNullInput extends org.jooq.QueryPart {}

    /**
     * A marker interface for {@link QueryPart} implementations that are used
     * only to render SQL, i.e. they're transient to the expression tree and
     * don't persist in client code.
     */
    interface UTransient extends UEmpty {}

    /**
     * A marker interface for {@link QueryPart} implementations that are mainly
     * used to render SQL, but unlike {@link UTransient} parts, can also appear
     * in user expression trees.
     */
    sealed interface UOpaque
        extends
            UEmpty
        permits



            CustomField,
            CustomTable,
            CustomCondition,
            CustomQueryPart
    {}

    /**
     * A marker interface for {@link QueryPart} implementations whose
     * {@link QueryPart} semantics has not yet been implemented.
     *
     * @deprecated - [#12425] - 3.16.0 - Missing implementations should be added
     *             as soon as possible!
     */
    @Deprecated(forRemoval = true)
    interface UNotYetImplemented extends UEmpty {}

    /**
     * A marker interface for {@link QueryPart} methods that have not yet been
     * implemented.
     *
     * @deprecated - [#12425] - 3.16.0 - Missing implementations should be added
     *             as soon as possible!
     */
    @Deprecated(forRemoval = true)
    public static class NotYetImplementedException extends RuntimeException {}

    interface UProxy<Q extends org.jooq.QueryPart> extends org.jooq.QueryPart {
        Q $delegate();















    }

    interface UEmpty extends org.jooq.QueryPart {

















    }

    // -------------------------------------------------------------------------
    // XXX: Undisclosed, internal query parts
    // -------------------------------------------------------------------------

    interface UEmptyCondition extends Condition, UEmpty {}
    interface UEmptyField<T> extends Field<T>, UEmpty {}
    interface UEmptyTable<R extends Record> extends Table<R>, UEmpty {}
    interface UEmptyStatement extends Statement, UEmpty {}
    interface UEmptyQuery extends Query, UEmpty {}



















































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































    /**
     * Turn an array into an unmodifiable {@link UnmodifiableList}.
     */
    @Internal
    public static final <Q extends QueryPart> UnmodifiableList<Q> unmodifiable(Q[] array) {
        return unmodifiable(QueryPartListView.wrap(array));
    }

    /**
     * Turn a {@link List} into an unmodifiable {@link UnmodifiableList}.
     */
    @Internal
    public static final <Q extends QueryPart> UnmodifiableList<Q> unmodifiable(List<Q> list) {
        return QueryPartListView.wrap(unmodifiableList(list));
    }

    /**
     * Turn a {@link Collection} into an unmodifiable {@link UnmodifiableList}.
     */
    @Internal
    public static final <Q extends QueryPart> UnmodifiableList<Q> unmodifiable(Collection<Q> collection) {
        if (collection instanceof List)
            return unmodifiable((List<Q>) collection);
        else
            return new QueryPartList<>(unmodifiableCollection(collection));
    }

    /**
     * Turn a {@link Map} into an unmodifiable {@link UnmodifiableMap}.
     */
    @Internal
    public static final <K extends QueryPart, V extends QueryPart> UnmodifiableMap<K, V> unmodifiable(Map<K, V> map) {
        return new QueryPartMapView<>(unmodifiableMap(map));
    }

    @Internal
    public static final <Q1 extends QueryPart, Q2 extends QueryPart> Tuple2<Q1, Q2> tuple(Q1 q1, Q2 q2) {
        return new TupleImpl2<>(q1, q2);
    }

    static final <Q extends QueryPart> boolean commutativeCheck(UCommutativeOperator<Q, ?> op, Predicate<? super Q> f) {
        return f.test(op.$arg1()) || f.test(op.$arg2());
    }

    static final <Q extends QueryPart> boolean commutativeCheck(UCommutativeOperator<Q, ?> op, BiPredicate<? super Q, ? super Q> f) {
        return f.test(op.$arg1(), op.$arg2()) || f.test(op.$arg2(), op.$arg1());
    }
}
