data-finder-ts 0.1.4 → 0.1.5

package/dist/model/relational.d.ts

@@ -8,6 +8,13 @@ declare enum ComparisonOperator {
     LIKE = "LIKE",
     NOT_LIKE = "NOT_LIKE"
 }
+/** The character that makes the next one literal in a LIKE pattern built from a value (`contains`, `startsWith`, ...). */
+declare const LIKE_ESCAPE = "!";
+/**
+ * `value` as part of a LIKE pattern that matches it literally: `%`, `_` and the escape character itself
+ * would otherwise be wildcards.
+ */
+declare function escapeLike(value: string): string;
 declare enum LogicalOperator {
     AND = "AND",
     OR = "OR"
@@ -17,7 +24,15 @@ declare enum AggregateOperator {
     SUM = "SUM",
     MIN = "MIN",
     MAX = "MAX",
-    AVERAGE = "AVERAGE"
+    AVERAGE = "AVERAGE",
+    STRING_AGG = "STRING_AGG",
+    COUNT_DISTINCT = "COUNT_DISTINCT",
+    STDDEV_SAMP = "STDDEV_SAMP",
+    STDDEV_POP = "STDDEV_POP",
+    VAR_SAMP = "VAR_SAMP",
+    VAR_POP = "VAR_POP",
+    BOOL_AND = "BOOL_AND",
+    BOOL_OR = "BOOL_OR"
 }
 declare enum ScalarFunction {
     ABS = "ABS",
@@ -38,7 +53,8 @@ declare enum ScalarFunction {
     RIGHT = "RIGHT",
     REPEAT = "REPEAT",
     REPLACE = "REPLACE",
-    SUBSTRING = "SUBSTRING"
+    SUBSTRING = "SUBSTRING",
+    COALESCE = "COALESCE"
 }
 declare enum DatePart {
     YEAR = "YEAR",
@@ -57,19 +73,37 @@ declare enum SortDirection {
 }
 declare abstract class RelationalOperationElement {
 }
-declare abstract class Operation extends RelationalOperationElement {
-    andOp(other: RelationalOperationElement): Operation;
+/**
+ * Something that can be a column of the result, so can be given a name there:
+ * `f.price().sum().alias('Total')`. The name is held by an `Alias` that wraps the column.
+ */
+interface Aliasable {
+    alias(name: string): Alias;
+}
+/** Something the result can be ordered by: `f.id().count().ascending()`. */
+interface Sortable {
+    /** Sort by this expression, smallest first. */
+    ascending(): SortOperation;
+    /** Sort by this expression, largest first. */
+    descending(): SortOperation;
+}
+declare abstract class Operation extends RelationalOperationElement implements Aliasable {
+    /** Name this column in the result: `f.price().sum().alias('Total')`, `f.age().gt(30).alias('Adult')`. */
+    alias(name: string): Alias;
+    and(other: RelationalOperationElement): Operation;
+    /** Combine with `other` using OR. A chain reads left to right: `a.or(b).and(c)` is `(a OR b) AND c`. */
+    or(other: RelationalOperationElement): Operation;
 }
 declare class NoOperation extends Operation {
-    andOp(other: RelationalOperationElement): Operation;
+    and(other: RelationalOperationElement): Operation;
+    /** No filter matches every row, so OR-ing anything with it still matches every row. */
+    or(_other: RelationalOperationElement): Operation;
 }
-declare abstract class ConstantOperation extends RelationalOperationElement {
-}
-declare class IntegerConstantOperation extends ConstantOperation {
+declare class IntegerConstantOperation extends NumericConstantOperation {
     readonly value: number;
     constructor(value: number);
 }
-declare class FloatConstantOperation extends ConstantOperation {
+declare class FloatConstantOperation extends NumericConstantOperation {
     readonly value: number;
     constructor(value: number);
 }
@@ -77,6 +111,15 @@ declare class StringConstantOperation extends ConstantOperation {
     readonly value: string;
     constructor(value: string);
 }
+/** Matches a zone-less calendar date such as `2024-06-01`. */
+declare const DATE_ONLY_PATTERN: RegExp;
+/**
+ * A calendar date, held as UTC midnight. JavaScript has no date-only type, so this marks a `Date`
+ * that was given as a date rather than a timestamp, and is rendered as a date literal (`'2024-06-01'`)
+ * instead of a timestamp literal (`'2024-06-01 00:00:00'`).
+ */
+declare class DateOnly extends Date {
+}
 declare class DateConstantOperation extends ConstantOperation {
     readonly value: Date;
     constructor(value: Date);
@@ -85,7 +128,7 @@ declare class DateTimeConstantOperation extends ConstantOperation {
     readonly value: Date;
     constructor(value: Date);
 }
-declare class DecimalConstantOperation extends ConstantOperation {
+declare class DecimalConstantOperation extends NumericConstantOperation {
     readonly value: number;
     constructor(value: number);
 }
@@ -102,30 +145,11 @@ declare abstract class BinaryOperation extends Operation {
     readonly right: RelationalOperationElement;
     constructor(left: RelationalOperationElement, right: RelationalOperationElement);
 }
-declare class IsNullOperation extends UnaryOperation {
-}
-declare class IsNotNullOperation extends UnaryOperation {
-}
-declare class ComparisonOperation extends BinaryOperation {
-    readonly operator: ComparisonOperator;
-    constructor(left: RelationalOperationElement, operator: ComparisonOperator, right: RelationalOperationElement);
-}
-declare class LogicalOperation extends BinaryOperation {
-    readonly operator: LogicalOperator;
-    constructor(left: RelationalOperationElement, operator: LogicalOperator, right: RelationalOperationElement);
-}
 declare class WindowSpecification {
     readonly partitionBy: RelationalOperationElement[];
     readonly orderBy: SortOperation[];
     constructor(partitionBy?: RelationalOperationElement[], orderBy?: SortOperation[]);
 }
-declare class AggregateOperation extends UnaryOperation {
-    readonly operator: AggregateOperator;
-    readonly displayName?: string | undefined;
-    readonly window?: WindowSpecification | undefined;
-    constructor(element: RelationalOperationElement, operator: AggregateOperator, displayName?: string | undefined, window?: WindowSpecification | undefined);
-    over(partitionBy?: RelationalOperationElement[], orderBy?: SortOperation[]): AggregateOperation;
-}
 declare enum WindowFunction {
     ROW_NUMBER = "ROW_NUMBER",
     RANK = "RANK",
@@ -138,38 +162,49 @@ declare enum WindowFunction {
     CUME_DIST = "CUME_DIST",
     PERCENT_RANK = "PERCENT_RANK"
 }
-declare class WindowFunctionOperation extends UnaryOperation {
+declare class WindowFunctionOperation extends UnaryOperation implements Sortable {
     readonly func: WindowFunction;
     readonly displayName?: string | undefined;
     readonly secondArg?: number | undefined;
     readonly extraArgs: (string | number)[];
     readonly window?: WindowSpecification | undefined;
+    /** Sort by this expression, smallest first. */
+    ascending(): SortOperation;
+    /** Sort by this expression, largest first. */
+    descending(): SortOperation;
     constructor(element: RelationalOperationElement | null, func: WindowFunction, displayName?: string | undefined, secondArg?: number | undefined, extraArgs?: (string | number)[], window?: WindowSpecification | undefined);
     over(partitionBy?: RelationalOperationElement[], orderBy?: SortOperation[]): WindowFunctionOperation;
 }
-declare class ScalarFunctionOperation extends UnaryOperation {
-    readonly func: ScalarFunction;
-    readonly displayName?: string | undefined;
-    readonly secondArg?: number | undefined;
-    readonly extraArgs: (string | number)[];
-    constructor(element: RelationalOperationElement, func: ScalarFunction, displayName?: string | undefined, secondArg?: number | undefined, extraArgs?: (string | number)[]);
-}
-declare class DateExtractOperation extends UnaryOperation {
+/** The functions that give a number, which arithmetic and `Numeric` functions apply to. */
+declare const NUMERIC_FUNCTIONS: ReadonlySet<ScalarFunction>;
+declare class DateExtractOperation extends UnaryOperation implements Sortable {
     readonly part: DatePart;
     readonly displayName?: string | undefined;
+    /** Sort by this expression, smallest first. */
+    ascending(): SortOperation;
+    /** Sort by this expression, largest first. */
+    descending(): SortOperation;
     constructor(element: RelationalOperationElement, part: DatePart, displayName?: string | undefined);
 }
-declare class DateArithmeticOperation extends UnaryOperation {
+declare class DateArithmeticOperation extends UnaryOperation implements Sortable {
     readonly n: number;
     readonly unit: DatePart;
     readonly isAdd: boolean;
     readonly displayName?: string | undefined;
+    /** Sort by this expression, smallest first. */
+    ascending(): SortOperation;
+    /** Sort by this expression, largest first. */
+    descending(): SortOperation;
     constructor(element: RelationalOperationElement, n: number, unit: DatePart, isAdd?: boolean, displayName?: string | undefined);
 }
-declare class DateDiffOperation extends UnaryOperation {
+declare class DateDiffOperation extends UnaryOperation implements Sortable {
     readonly other: Date;
     readonly unit: DatePart;
     readonly displayName?: string | undefined;
+    /** Sort by this expression, smallest first. */
+    ascending(): SortOperation;
+    /** Sort by this expression, largest first. */
+    descending(): SortOperation;
     constructor(element: RelationalOperationElement, other: Date, unit: DatePart, displayName?: string | undefined);
 }
 declare class Column extends RelationalOperationElement {
@@ -178,7 +213,9 @@ declare class Column extends RelationalOperationElement {
     readonly owner?: string | undefined;
     readonly primaryKey: boolean;
     table?: Table;
-    constructor(name: string, type: string, owner?: string | undefined, primaryKey?: boolean);
+    /** Whether the column may hold NULL. As in Legend, a primary key is never null. */
+    readonly nullable: boolean;
+    constructor(name: string, type: string, owner?: string | undefined, primaryKey?: boolean, nullable?: boolean);
 }
 declare class ForeignKey {
     readonly column: Column;
@@ -230,43 +267,75 @@ declare class JoinOperation {
 declare class JoinTreeNodeOperation {
     readonly join: JoinOperation;
     readonly parent?: JoinTreeNodeOperation | undefined;
-    constructor(join: JoinOperation, parent?: JoinTreeNodeOperation | undefined);
+    /**
+     * True when the property this step follows is to-many, so a value read through it repeats the row. As in
+     * Pure, that is the multiplicity of the property, not something the join itself says.
+     */
+    readonly many: boolean;
+    /** True when the property this step follows can be missing (its lower bound is 0). */
+    readonly optional: boolean;
+    constructor(join: JoinOperation, parent?: JoinTreeNodeOperation | undefined, 
+    /**
+     * True when the property this step follows is to-many, so a value read through it repeats the row. As in
+     * Pure, that is the multiplicity of the property, not something the join itself says.
+     */
+    many?: boolean, 
+    /** True when the property this step follows can be missing (its lower bound is 0). */
+    optional?: boolean);
 }
 declare class ColumnWithJoin extends RelationalOperationElement {
     readonly column: Column;
     readonly parent?: JoinTreeNodeOperation | undefined;
     readonly embedded?: ColumnWithJoin | undefined;
+    private readonly _optional;
     /**
      * `embedded` is an alternate reference to a flat (denormalized) column on the owning table that
      * holds the same value without the join; the SQL generator uses it when the join can be elided.
      */
-    constructor(column: Column, parent?: JoinTreeNodeOperation | undefined, embedded?: ColumnWithJoin | undefined);
+    constructor(column: Column, parent?: JoinTreeNodeOperation | undefined, embedded?: ColumnWithJoin | undefined, _optional?: boolean);
+    /** Whether the value can be missing: its property is optional, or a navigation on the way to it is. */
+    get optional(): boolean;
 }
 declare class SortOperation {
-    readonly column: ColumnWithJoin;
+    /** What the rows are ordered by: a column, or an expression such as an aggregate. */
+    readonly column: RelationalOperationElement;
     readonly direction: SortDirection;
-    constructor(column: ColumnWithJoin, direction: SortDirection);
-}
-declare class CountAllOperation extends RelationalOperationElement {
-    readonly table: string;
-    constructor(table: string);
-}
-declare class Alias extends RelationalOperationElement {
+    constructor(
+    /** What the rows are ordered by: a column, or an expression such as an aggregate. */
+    column: RelationalOperationElement, direction: SortDirection);
+}
+/**
+ * A column of the result under another name, wrapping the column it names. Only things that can be a
+ * column of the result have `alias()` (an `Attribute`, an aggregate, a function, a constant, ...), so a
+ * filter cannot be aliased; aliasing an alias replaces its name.
+ */
+declare class Alias extends RelationalOperationElement implements Aliasable, Sortable {
     readonly element: RelationalOperationElement;
     readonly name: string;
     constructor(element: RelationalOperationElement, name: string);
+    alias(name: string): Alias;
+    /** Sorts by the column the alias names. */
+    ascending(): SortOperation;
+    /** Sorts by the column the alias names. */
+    descending(): SortOperation;
 }
 /** Returned by `RelatedFinder.exists()`. A backend translates it to a join-presence check. */
-declare class ExistsOperation extends RelationalOperationElement {
+declare class ExistsOperation extends RelationalOperationElement implements Aliasable {
     readonly node: JoinTreeNodeOperation;
+    /** Name this column in the result. */
+    alias(name: string): Alias;
     constructor(node: JoinTreeNodeOperation);
-    andOp(other: RelationalOperationElement): LogicalOperation;
+    and(other: RelationalOperationElement): LogicalOperation;
+    or(other: RelationalOperationElement): LogicalOperation;
 }
 /** Returned by `RelatedFinder.notExists()`. A backend translates it to a join-absence check. */
-declare class NotExistsOperation extends RelationalOperationElement {
+declare class NotExistsOperation extends RelationalOperationElement implements Aliasable {
     readonly node: JoinTreeNodeOperation;
+    /** Name this column in the result. */
+    alias(name: string): Alias;
     constructor(node: JoinTreeNodeOperation);
-    andOp(other: RelationalOperationElement): LogicalOperation;
+    and(other: RelationalOperationElement): LogicalOperation;
+    or(other: RelationalOperationElement): LogicalOperation;
 }
 declare class SelectOperation {
     readonly display: RelationalOperationElement[];
@@ -280,12 +349,307 @@ declare class SelectOperation {
      * Held here rather than on the shared JoinOperation, so queries that use the same node can't affect each other.
      */
     readonly joinFilters: ReadonlyMap<JoinTreeNodeOperation, Operation>;
+    /** Whether each distinct row is returned once (`SELECT DISTINCT`). */
+    readonly distinct: boolean;
+    /** How many rows to skip before the first one returned. */
+    readonly offset?: number | undefined;
+    /** Keeps the groups that satisfy it (`HAVING`). */
+    readonly having?: Operation | undefined;
     constructor(display: RelationalOperationElement[], filter: RelationalOperationElement, orderBy?: SortOperation[], groupBy?: RelationalOperationElement[], limit?: number | undefined, table?: Table | undefined, 
     /**
      * Extra ON conditions for this query's joins (milestoning and property filters), keyed by join node.
      * Held here rather than on the shared JoinOperation, so queries that use the same node can't affect each other.
      */
-    joinFilters?: ReadonlyMap<JoinTreeNodeOperation, Operation>);
+    joinFilters?: ReadonlyMap<JoinTreeNodeOperation, Operation>, 
+    /** Whether each distinct row is returned once (`SELECT DISTINCT`). */
+    distinct?: boolean, 
+    /** How many rows to skip before the first one returned. */
+    offset?: number | undefined, 
+    /** Keeps the groups that satisfy it (`HAVING`). */
+    having?: Operation | undefined);
+}
+/** Whether `op` holds an aggregate, a window function or a count. */
+declare function containsAggregateOrWindow(op: unknown): boolean;
+/** Whether `op` collapses rows: an aggregate or a count. Window functions keep every row. */
+declare function containsAggregate(op: unknown): boolean;
+/** A plain value as the constant it compares with. */
+declare function valueOperand(value: unknown): ConstantOperation;
+/** The thing to compare or calculate with: an expression as it is, an attribute as its column, a value as a constant. */
+declare function operandOf(other: unknown): RelationalOperationElement;
+/**
+ * Comparisons for an expression, as for a column: `f.name().toUpperCase().eq('ACME')`, `f.name().length().gt(10)`.
+ * The other side is a value or another expression. Each gives a filter. Mixed into the expressions that have it.
+ */
+declare abstract class Comparable {
+    abstract comparisonOperand(): RelationalOperationElement;
+    private _compared;
+    /** Filter to rows where this expression equals `other`. */
+    eq(other: unknown): ComparisonOperation;
+    /** Filter to rows where this expression does not equal `other`. */
+    ne(other: unknown): ComparisonOperation;
+    /** Filter to rows where this expression is less than `other`. */
+    lt(other: unknown): ComparisonOperation;
+    /** Filter to rows where this expression is at most `other`. */
+    lte(other: unknown): ComparisonOperation;
+    /** Filter to rows where this expression is greater than `other`. */
+    gt(other: unknown): ComparisonOperation;
+    /** Filter to rows where this expression is at least `other`. */
+    gte(other: unknown): ComparisonOperation;
+}
+/** Whether a standard deviation or variance is the sample one (`ddof` 1) or the population one (0). */
+declare function sample(ddof: number): boolean;
+/**
+ * Pattern tests on an expression that holds text, as on a column: `f.name().toUpperCase().startsWith('AC')`,
+ * `f.name().join(',').contains('John')`. Mixed into the expressions that have it.
+ */
+declare abstract class StringPredicates {
+    abstract comparisonOperand(): RelationalOperationElement;
+    private _like;
+    /** Filter to rows where this text contains `value`. */
+    contains(value: string): ComparisonOperation;
+    /** Filter to rows where this text starts with `prefix`. */
+    startsWith(prefix: string): ComparisonOperation;
+    /** Filter to rows where this text ends with `suffix`. */
+    endsWith(suffix: string): ComparisonOperation;
+}
+/**
+ * Aggregates of an expression, as a column has them: `f.price().times(f.quantity()).sum()`, `constant(1).sum()`,
+ * `when(f.price().gt(10)).then(5.0).otherwise(1.0).sum()`. Mixed into the expressions that have it.
+ */
+declare abstract class Aggregates {
+    private _aggregate;
+    /** Sum of the values in the group. */
+    sum(): AggregateOperation;
+    /** Smallest value in the group. */
+    min(): AggregateOperation;
+    /** Largest value in the group. */
+    max(): AggregateOperation;
+    /** Arithmetic mean of the values in the group. */
+    average(): AggregateOperation;
+    /** Number of non-null values in the group. */
+    count(): AggregateOperation;
+    /** Standard deviation of the values in the group: the sample one by default, `ddof = 0` for the population one. */
+    std(ddof?: number): AggregateOperation;
+    /** Variance of the values in the group: the sample one by default, `ddof = 0` for the population one. */
+    var(ddof?: number): AggregateOperation;
+}
+/**
+ * Aggregates of a condition: `f.quantity().gt(20).all()` is true for a group where every row holds, `.any()` where at
+ * least one does. Mixed into the conditions.
+ */
+declare abstract class BooleanAggregates {
+    /** True for a group where every row satisfies the condition. */
+    all(): AggregateOperation;
+    /** True for a group where at least one row satisfies the condition. */
+    any(): AggregateOperation;
+}
+/**
+ * Mix the methods of the base classes into `derived`, the TypeScript handbook's way to inherit from more than
+ * one class: the type side comes from an `interface Derived extends Base {}` beside the class.
+ */
+declare function applyMixins(derived: {
+    prototype: object;
+}, bases: {
+    prototype: object;
+}[]): void;
+declare enum ArithmeticOperator {
+    ADD = "+",
+    SUBTRACT = "-",
+    MULTIPLY = "*",
+    DIVIDE = "/"
+}
+/** A number or a numeric expression: what arithmetic takes on the other side. */
+type ArithmeticOperand = number | {
+    arithmeticOperand(): RelationalOperationElement;
+};
+/**
+ * `plus`, `minus`, `times` and `dividedBy` for an expression that holds a number: `f.price().times(f.quantity())`,
+ * `f.price().plus(1.5)`, `constant(100).minus(f.price())`. The other operand is a number or another numeric
+ * expression. Mixed into the expressions that have it.
+ */
+declare abstract class Arithmetic {
+    abstract arithmeticOperand(): RelationalOperationElement;
+    /** Raises if this expression is not a number. */
+    assertNumeric(): void;
+    private _arithmetic;
+    /** `this + other`. */
+    plus(other: ArithmeticOperand): ArithmeticOperation;
+    /** `this - other`. */
+    minus(other: ArithmeticOperand): ArithmeticOperation;
+    /** `this * other`. */
+    times(other: ArithmeticOperand): ArithmeticOperation;
+    /** `this / other`. */
+    dividedBy(other: ArithmeticOperand): ArithmeticOperation;
+}
+/** What can be joined as text: a string, a text column, a function that gives text, or another concatenation. */
+type ConcatPart = string | {
+    functionInput(): RelationalOperationElement;
+} | ConcatOperation;
+/**
+ * Join text: `concat(f.name(), ' (', f.category(), ')')`. A string is a constant; a concatenation among the
+ * parts is flattened into one.
+ */
+declare function concat(...parts: ConcatPart[]): ConcatOperation;
+/** Text joined end to end. A NULL in any part makes the whole NULL, as with SQL's `||`. */
+declare class ConcatOperation extends Operation implements Sortable {
+    readonly parts: RelationalOperationElement[];
+    readonly displayName?: string | undefined;
+    constructor(parts: RelationalOperationElement[], displayName?: string | undefined);
+    /** Join more text on the end: `f.first().concat(' ', f.last())`. A concatenation joins into one. */
+    concat(...more: ConcatPart[]): ConcatOperation;
+    /** Sort by this expression, smallest first. */
+    ascending(): SortOperation;
+    /** Sort by this expression, largest first. */
+    descending(): SortOperation;
+    comparisonOperand(): RelationalOperationElement;
+}
+interface ConcatOperation extends Comparable, StringPredicates {
+}
+/** The first day of the week, month, quarter or year that the date falls in, as a date. */
+declare class DateTruncOperation extends UnaryOperation implements Sortable {
+    readonly part: DatePart;
+    readonly displayName?: string | undefined;
+    constructor(element: RelationalOperationElement, part: DatePart, displayName?: string | undefined);
+    /** Sort by this expression, earliest first. */
+    ascending(): SortOperation;
+    /** Sort by this expression, latest first. */
+    descending(): SortOperation;
+    comparisonOperand(): RelationalOperationElement;
+}
+interface DateTruncOperation extends Comparable {
+}
+declare class AggregateOperation extends UnaryOperation implements Sortable {
+    readonly operator: AggregateOperator;
+    readonly displayName?: string | undefined;
+    readonly window?: WindowSpecification | undefined;
+    /** For STRING_AGG: what goes between the values. */
+    readonly separator?: string | undefined;
+    /** For STRING_AGG: the order the values are joined in. */
+    readonly orderBy: SortOperation[];
+    /** Sort by this expression, smallest first. */
+    ascending(): SortOperation;
+    /** Sort by this expression, largest first. */
+    descending(): SortOperation;
+    constructor(element: RelationalOperationElement, operator: AggregateOperator, displayName?: string | undefined, window?: WindowSpecification | undefined, 
+    /** For STRING_AGG: what goes between the values. */
+    separator?: string | undefined, 
+    /** For STRING_AGG: the order the values are joined in. */
+    orderBy?: SortOperation[]);
+    arithmeticOperand(): RelationalOperationElement;
+    comparisonOperand(): RelationalOperationElement;
+    over(partitionBy?: RelationalOperationElement[], orderBy?: SortOperation[]): AggregateOperation;
+}
+interface AggregateOperation extends Arithmetic, Comparable, StringPredicates {
+}
+declare class CountAllOperation extends RelationalOperationElement implements Aliasable, Sortable {
+    readonly table: string;
+    /** Name this column in the result. */
+    alias(name: string): Alias;
+    /** Sort by this expression, smallest first. */
+    ascending(): SortOperation;
+    /** Sort by this expression, largest first. */
+    descending(): SortOperation;
+    constructor(table: string);
+    comparisonOperand(): RelationalOperationElement;
+}
+interface CountAllOperation extends Comparable {
+}
+/** A constant that is a number, so it can be an operand of arithmetic: `constant(100).minus(f.price())`. */
+declare abstract class NumericConstantOperation extends ConstantOperation {
+    abstract readonly value: number;
+    arithmeticOperand(): RelationalOperationElement;
+}
+interface NumericConstantOperation extends Arithmetic {
+}
+declare abstract class ConstantOperation extends RelationalOperationElement implements Aliasable, Sortable {
+    /** Name this column in the result. */
+    alias(name: string): Alias;
+    /** Sort by this expression, smallest first. */
+    ascending(): SortOperation;
+    /** Sort by this expression, largest first. */
+    descending(): SortOperation;
+}
+interface ConstantOperation extends Aggregates {
+}
+/** `left operator right` on numbers, e.g. `price * quantity`. */
+declare class ArithmeticOperation extends BinaryOperation implements Sortable {
+    readonly operator: ArithmeticOperator;
+    readonly displayName?: string | undefined;
+    constructor(left: RelationalOperationElement, operator: ArithmeticOperator, right: RelationalOperationElement, displayName?: string | undefined);
+    /** Sort by this expression, smallest first. */
+    ascending(): SortOperation;
+    /** Sort by this expression, largest first. */
+    descending(): SortOperation;
+    arithmeticOperand(): RelationalOperationElement;
+    comparisonOperand(): RelationalOperationElement;
+}
+interface ArithmeticOperation extends Arithmetic, Comparable {
+}
+interface ArithmeticOperation extends Aggregates {
+}
+declare class ScalarFunctionOperation extends UnaryOperation implements Sortable {
+    readonly func: ScalarFunction;
+    readonly displayName?: string | undefined;
+    readonly secondArg?: number | undefined;
+    readonly extraArgs: (string | number | boolean)[];
+    /** Sort by this expression, smallest first. */
+    ascending(): SortOperation;
+    /** Sort by this expression, largest first. */
+    descending(): SortOperation;
+    constructor(element: RelationalOperationElement, func: ScalarFunction, displayName?: string | undefined, secondArg?: number | undefined, extraArgs?: (string | number | boolean)[]);
+    /** This expression as an operand of a comparison. */
+    comparisonOperand(): RelationalOperationElement;
+    arithmeticOperand(): RelationalOperationElement;
+    /** Only a function that gives a number can be used in arithmetic. */
+    assertNumeric(): void;
+}
+interface ScalarFunctionOperation extends Comparable, Arithmetic, StringPredicates {
+}
+interface ScalarFunctionOperation extends Aggregates {
+}
+/** `CASE WHEN condition THEN then ELSE fallback END`; without a `fallback` the value is NULL. */
+declare class CaseOperation extends Operation {
+    readonly condition: RelationalOperationElement;
+    readonly then: RelationalOperationElement;
+    readonly fallback?: RelationalOperationElement | undefined;
+    readonly displayName?: string | undefined;
+    constructor(condition: RelationalOperationElement, then: RelationalOperationElement, fallback?: RelationalOperationElement | undefined, displayName?: string | undefined);
+}
+interface CaseOperation extends Aggregates {
+}
+declare class IsNullOperation extends UnaryOperation {
+}
+interface IsNullOperation extends BooleanAggregates {
+}
+declare class IsNotNullOperation extends UnaryOperation {
+}
+interface IsNotNullOperation extends BooleanAggregates {
+}
+/** The element is one of `values` (`element IN (...)`). */
+declare class InOperation extends UnaryOperation {
+    readonly values: ConstantOperation[];
+    constructor(element: RelationalOperationElement, values: ConstantOperation[]);
+}
+interface InOperation extends BooleanAggregates {
+}
+/** The element is none of `values` (`element NOT IN (...)`). */
+declare class NotInOperation extends UnaryOperation {
+    readonly values: ConstantOperation[];
+    constructor(element: RelationalOperationElement, values: ConstantOperation[]);
+}
+interface NotInOperation extends BooleanAggregates {
+}
+declare class ComparisonOperation extends BinaryOperation {
+    readonly operator: ComparisonOperator;
+    constructor(left: RelationalOperationElement, operator: ComparisonOperator, right: RelationalOperationElement);
+}
+interface ComparisonOperation extends BooleanAggregates {
+}
+declare class LogicalOperation extends BinaryOperation {
+    readonly operator: LogicalOperator;
+    constructor(left: RelationalOperationElement, operator: LogicalOperator, right: RelationalOperationElement);
+}
+interface LogicalOperation extends BooleanAggregates {
 }
 
-export { AggregateOperation, AggregateOperator, Alias, BinaryOperation, BooleanConstantOperation, Column, ColumnWithJoin, ComparisonOperation, ComparisonOperator, ConstantOperation, CountAllOperation, DataCatalog, DataStore, Database, DateArithmeticOperation, DateConstantOperation, DateDiffOperation, DateExtractOperation, DatePart, DateTimeConstantOperation, DecimalConstantOperation, ExistsOperation, FloatConstantOperation, ForeignKey, IntegerConstantOperation, IsNotNullOperation, IsNullOperation, JoinOperation, JoinTreeNodeOperation, LogicalOperation, LogicalOperator, NoOperation, NotExistsOperation, Operation, RelationalOperationElement, ScalarFunction, ScalarFunctionOperation, Schema, SelectOperation, SortDirection, SortOperation, StringConstantOperation, Table, UnaryOperation, WindowFunction, WindowFunctionOperation, WindowSpecification };
+export { AggregateOperation, AggregateOperator, Aggregates, Alias, type Aliasable, Arithmetic, type ArithmeticOperand, ArithmeticOperation, ArithmeticOperator, BinaryOperation, BooleanAggregates, BooleanConstantOperation, CaseOperation, Column, ColumnWithJoin, Comparable, ComparisonOperation, ComparisonOperator, ConcatOperation, type ConcatPart, ConstantOperation, CountAllOperation, DATE_ONLY_PATTERN, DataCatalog, DataStore, Database, DateArithmeticOperation, DateConstantOperation, DateDiffOperation, DateExtractOperation, DateOnly, DatePart, DateTimeConstantOperation, DateTruncOperation, DecimalConstantOperation, ExistsOperation, FloatConstantOperation, ForeignKey, InOperation, IntegerConstantOperation, IsNotNullOperation, IsNullOperation, JoinOperation, JoinTreeNodeOperation, LIKE_ESCAPE, LogicalOperation, LogicalOperator, NUMERIC_FUNCTIONS, NoOperation, NotExistsOperation, NotInOperation, NumericConstantOperation, Operation, RelationalOperationElement, ScalarFunction, ScalarFunctionOperation, Schema, SelectOperation, SortDirection, SortOperation, type Sortable, StringConstantOperation, StringPredicates, Table, UnaryOperation, WindowFunction, WindowFunctionOperation, WindowSpecification, applyMixins, concat, containsAggregate, containsAggregateOrWindow, escapeLike, operandOf, sample, valueOperand };