kysely 0.22.0 → 0.23.0

package/dist/esm/parser/select-parser.d.ts

@@ -1,12 +1,11 @@
-import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
-import { AliasedQueryBuilder, SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { AliasedSelectQueryBuilder, SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
 import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, ExtractColumnType, ValueType } from '../util/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
-import { AliasedComplexExpression } from './complex-expression-parser.js';
+import { AliasedExpressionOrFactory } from './expression-parser.js';
 import { Selectable, SelectType } from '../util/column-type.js';
-import { AliasedAggregateFunctionBuilder } from '../query-builder/aggregate-function-builder.js';
-export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedComplexExpression<DB, TB> | AliasedAggregateFunctionBuilder<DB, TB>;
+import { AliasedExpression } from '../expression/expression.js';
+export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedExpressionOrFactory<DB, TB>;
 export declare type SelectExpressionOrList<DB, TB extends keyof DB> = SelectExpression<DB, TB> | ReadonlyArray<SelectExpression<DB, TB>>;
 /**
  * Given a selection expression returns a query builder type that
@@ -20,9 +19,9 @@ export declare type SelectAllQueryBuilder<DB, TB extends keyof DB, O, S extends
 export declare type Selection<DB, TB extends keyof DB, SE> = {
     [A in ExtractAliasFromSelectExpression<SE>]: SelectType<ExtractTypeFromSelectExpression<DB, TB, SE, A>>;
 };
-declare type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedRawBuilder<any, infer RA> ? RA : SE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : SE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : SE extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : SE extends AliasedAggregateFunctionBuilder<any, any, any, infer QA> ? QA : SE extends (qb: any) => AliasedAggregateFunctionBuilder<any, any, any, infer QA> ? QA : never;
+declare type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedExpression<any, infer EA> ? EA : SE extends (qb: any) => AliasedExpression<any, infer EA> ? EA : SE extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : never;
 declare type ExtractAliasFromStringSelectExpression<SE extends string> = SE extends `${string}.${string}.${string} as ${infer A}` ? A : SE extends `${string}.${string} as ${infer A}` ? A : SE extends `${string} as ${infer A}` ? A : SE extends `${string}.${string}.${infer C}` ? C : SE extends `${string}.${infer C}` ? C : SE;
-declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE, A extends keyof any> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE, A> : SE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : SE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : SE extends AliasedAggregateFunctionBuilder<any, any, infer O, infer FA> ? FA extends A ? O : never : SE extends (qb: any) => AliasedAggregateFunctionBuilder<any, any, infer O, infer FA> ? FA extends A ? O : never : never;
+declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE, A extends keyof any> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE, A> : SE extends AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends (qb: any) => AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : SE extends AliasedExpression<infer O, infer EA> ? EA extends A ? O : never : SE extends (qb: any) => AliasedExpression<infer O, infer EA> ? EA extends A ? O : never : SE extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : never;
 declare type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, SE extends string, A extends keyof any> = SE extends `${infer SC}.${infer T}.${infer C} as ${infer RA}` ? RA extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C} as ${infer RA}` ? RA extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends `${infer C} as ${infer RA}` ? RA extends A ? C extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, C> : never : never : SE extends `${infer SC}.${infer T}.${infer C}` ? C extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C}` ? C extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends A ? SE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, SE> : never : never;
 declare type AllSelection<DB, TB extends keyof DB> = Selectable<{
     [C in AnyColumn<DB, TB>]: {

package/dist/esm/parser/select-parser.js

@@ -3,7 +3,7 @@ import { isReadonlyArray, isString } from '../util/object-utils.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
 import { parseAliasedStringReference } from './reference-parser.js';
 import { isDynamicReferenceBuilder, } from '../dynamic/dynamic-reference-builder.js';
-import { parseAliasedComplexExpression, } from './complex-expression-parser.js';
+import { parseAliasedExpression, } from './expression-parser.js';
 import { parseTable } from './table-parser.js';
 export function parseSelectExpressionOrList(selection) {
     if (isReadonlyArray(selection)) {
@@ -21,7 +21,7 @@ function parseSelectExpression(selection) {
         return SelectionNode.create(selection.toOperationNode());
     }
     else {
-        return SelectionNode.create(parseAliasedComplexExpression(selection));
+        return SelectionNode.create(parseAliasedExpression(selection));
     }
 }
 export function parseSelectAll(table) {

package/dist/esm/parser/set-operation-parser.d.ts

@@ -1,5 +1,3 @@
+import { Expression } from '../expression/expression.js';
 import { SetOperator, SetOperationNode } from '../operation-node/set-operation-node.js';
-import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
-export declare type SetOperationExpression<DB, O> = SelectQueryBuilder<DB, any, O> | RawBuilder<O>;
-export declare function parseSetOperation(operator: SetOperator, expression: SetOperationExpression<any, any>, all: boolean): SetOperationNode;
+export declare function parseSetOperation(operator: SetOperator, expression: Expression<any>, all: boolean): SetOperationNode;

package/dist/esm/parser/table-parser.d.ts

@@ -1,22 +1,21 @@
-import { AliasedQueryBuilder } from '../query-builder/select-query-builder.js';
+import { AliasNode } from '../operation-node/alias-node.js';
 import { TableNode } from '../operation-node/table-node.js';
-import { AnyAliasedRawBuilder } from '../util/type-utils.js';
-import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
-import { TableExpressionNode } from '../operation-node/operation-node-utils.js';
-import { AliasedComplexExpression } from './complex-expression-parser.js';
-export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AliasedComplexExpression<DB, TB>;
+import { AliasedExpressionOrFactory } from './expression-parser.js';
+import { OperationNode } from '../operation-node/operation-node.js';
+import { AliasedExpression } from '../expression/expression.js';
+export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AliasedExpressionOrFactory<DB, TB>;
 export declare type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
-export declare type TableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB> | AnyAliasedRawBuilder;
+export declare type TableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpression<any, any>;
 export declare type From<DB, TE> = {
     [C in keyof DB | ExtractAliasFromTableExpression<DB, TE>]: C extends ExtractAliasFromTableExpression<DB, TE> ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
 };
 export declare type FromTables<DB, TB extends keyof DB, TE> = TB | ExtractAliasFromTableExpression<DB, TE>;
-declare type ExtractAliasFromTableExpression<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : TE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends AliasedRawBuilder<any, infer RA> ? RA : TE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : never;
-declare type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : TE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : never;
+declare type ExtractAliasFromTableExpression<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : TE extends AliasedExpression<any, infer QA> ? QA : TE extends (qb: any) => AliasedExpression<any, infer QA> ? QA : never;
+declare type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : never;
 declare type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
 declare type AnyTable<DB> = keyof DB & string;
-export declare function parseTableExpressionOrList(table: TableExpressionOrList<any, any>): TableExpressionNode[];
-export declare function parseTableExpression(table: TableExpression<any, any>): TableExpressionNode;
-export declare function parseAliasedTable(from: string): TableExpressionNode;
+export declare function parseTableExpressionOrList(table: TableExpressionOrList<any, any>): OperationNode[];
+export declare function parseTableExpression(table: TableExpression<any, any>): OperationNode;
+export declare function parseAliasedTable(from: string): TableNode | AliasNode;
 export declare function parseTable(from: string): TableNode;
 export {};

package/dist/esm/parser/table-parser.js

@@ -2,7 +2,7 @@
 import { isReadonlyArray, isString } from '../util/object-utils.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { TableNode } from '../operation-node/table-node.js';
-import { parseAliasedComplexExpression, } from './complex-expression-parser.js';
+import { parseAliasedExpression, } from './expression-parser.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
 export function parseTableExpressionOrList(table) {
     if (isReadonlyArray(table)) {
@@ -17,7 +17,7 @@ export function parseTableExpression(table) {
         return parseAliasedTable(table);
     }
     else {
-        return parseAliasedComplexExpression(table);
+        return parseAliasedExpression(table);
     }
 }
 export function parseAliasedTable(from) {

package/dist/esm/parser/unary-operation-parser.d.ts

@@ -0,0 +1,5 @@
+import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
+import { ExpressionOrFactory } from './expression-parser.js';
+export declare type ExistsExpression<DB, TB extends keyof DB> = ExpressionOrFactory<DB, TB, any>;
+export declare function parseExists(arg: ExistsExpression<any, any>): UnaryOperationNode;
+export declare function parseNotExists(arg: ExistsExpression<any, any>): UnaryOperationNode;

package/dist/esm/parser/unary-operation-parser.js

@@ -0,0 +1,13 @@
+/// <reference types="./unary-operation-parser.d.ts" />
+import { OperatorNode, } from '../operation-node/operator-node.js';
+import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
+import { parseValueExpressionOrList } from './value-parser.js';
+export function parseExists(arg) {
+    return parseUnaryOperation('exists', arg);
+}
+export function parseNotExists(arg) {
+    return parseUnaryOperation('not exists', arg);
+}
+function parseUnaryOperation(type, arg) {
+    return UnaryOperationNode.create(OperatorNode.create(type), parseValueExpressionOrList(arg));
+}

package/dist/esm/parser/update-set-parser.d.ts

@@ -2,6 +2,6 @@ import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
 import { UpdateKeys, UpdateType } from '../util/column-type.js';
 import { ValueExpression } from './value-parser.js';
 export declare type MutationObject<DB, TB extends keyof DB, TM extends keyof DB> = {
-    [C in UpdateKeys<DB[TM]>]?: ValueExpression<DB, TB, UpdateType<DB[TM][C]>>;
+    [C in UpdateKeys<DB[TM]>]?: ValueExpression<DB, TB, UpdateType<DB[TM][C]>> | undefined;
 };
 export declare function parseUpdateObject(row: MutationObject<any, any, any>): ReadonlyArray<ColumnUpdateNode>;

package/dist/esm/parser/value-parser.d.ts

@@ -1,10 +1,6 @@
-import { ValueExpressionNode } from '../operation-node/operation-node-utils.js';
-import { ValueNode } from '../operation-node/value-node.js';
-import { SelectQueryNode } from '../operation-node/select-query-node.js';
-import { RawNode } from '../operation-node/raw-node.js';
-import { ComplexExpression } from './complex-expression-parser.js';
-import { AggregateFunctionNode } from '../operation-node/aggregate-function-node.js';
-export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ComplexExpression<DB, TB, V>;
+import { ExpressionOrFactory } from './expression-parser.js';
+import { OperationNode } from '../operation-node/operation-node.js';
+export declare type ValueExpression<DB, TB extends keyof DB, V> = V | ExpressionOrFactory<DB, TB, V>;
 export declare type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
-export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, unknown>): ValueExpressionNode;
-export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): ValueNode | SelectQueryNode | RawNode | AggregateFunctionNode;
+export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, unknown>): OperationNode;
+export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): OperationNode;

package/dist/esm/parser/value-parser.js

@@ -3,7 +3,7 @@ import { PrimitiveValueListNode } from '../operation-node/primitive-value-list-n
 import { ValueListNode } from '../operation-node/value-list-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
 import { isReadonlyArray } from '../util/object-utils.js';
-import { parseComplexExpression, isComplexExpression, } from './complex-expression-parser.js';
+import { parseExpression, isExpressionOrFactory, } from './expression-parser.js';
 export function parseValueExpressionOrList(arg) {
     if (isReadonlyArray(arg)) {
         return parseValueExpressionList(arg);
@@ -13,13 +13,13 @@ export function parseValueExpressionOrList(arg) {
     }
 }
 export function parseValueExpression(exp) {
-    if (isComplexExpression(exp)) {
-        return parseComplexExpression(exp);
+    if (isExpressionOrFactory(exp)) {
+        return parseExpression(exp);
     }
     return ValueNode.create(exp);
 }
 function parseValueExpressionList(arg) {
-    if (arg.some(isComplexExpression)) {
+    if (arg.some(isExpressionOrFactory)) {
         return ValueListNode.create(arg.map((it) => parseValueExpression(it)));
     }
     return PrimitiveValueListNode.create(arg);

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

@@ -1,21 +1,20 @@
-import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { UpdateQueryBuilder } from '../query-builder/update-query-builder.js';
 import { DeleteQueryBuilder } from '../query-builder/delete-query-builder.js';
 import { InsertQueryBuilder } from '../query-builder/insert-query-builder.js';
 import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
 import { QueryCreator } from '../query-creator.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { Expression } from '../expression/expression.js';
 export declare type CommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB>) => CommonTableExpressionOutput<DB, CN>;
 export declare type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpressionName<CN>>>) => CommonTableExpressionOutput<DB, CN>;
 export declare type QueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpression<CTE>>>;
-declare type CommonTableExpressionOutput<DB, CN extends string> = SelectQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | RawBuilder<ExtractRowFromCommonTableExpressionName<CN>>;
+declare type CommonTableExpressionOutput<DB, CN extends string> = Expression<ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>>;
 /**
  * Given a common CommonTableExpression CTE extracts the row type from it.
  *
  * For example a CTE `(db) => db.selectFrom('person').select(['id', 'first_name'])`
  * would result in `Pick<Person, 'id' | 'first_name'>`.
  */
-declare type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends SelectQueryBuilder<any, any, infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
+declare type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends Expression<infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : never : never;
 /**
  * Extracts 'person' from a string like 'person(id, first_name)'.
  */

package/dist/esm/plugin/camel-case/camel-case-plugin.js

@@ -1,5 +1,5 @@
 /// <reference types="./camel-case-plugin.d.ts" />
-import { isBuffer, isDate, isObject } from '../../util/object-utils.js';
+import { isArrayBufferOrView, isBuffer, isDate, isObject, } from '../../util/object-utils.js';
 import { SnakeCaseTransformer } from './camel-case-transformer.js';
 import { createCamelCaseMapper, createSnakeCaseMapper, } from './camel-case.js';
 /**
@@ -108,5 +108,5 @@ export class CamelCasePlugin {
     }
 }
 function canMap(obj) {
-    return isObject(obj) && !isDate(obj) && !isBuffer(obj);
+    return (isObject(obj) && !isDate(obj) && !isBuffer(obj) && !isArrayBufferOrView(obj));
 }

package/dist/esm/query-builder/aggregate-function-builder.d.ts

@@ -1,10 +1,31 @@
 import { AggregateFunctionNode } from '../operation-node/aggregate-function-node.js';
-import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { OverBuilder } from './over-builder.js';
-export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown> implements OperationNodeSource {
+import { AliasedExpression, Expression } from '../expression/expression.js';
+import { ReferenceExpression } from '../parser/reference-parser.js';
+import { ComparisonOperatorExpression, OperandValueExpressionOrList, WhereGrouper } from '../parser/binary-operation-parser.js';
+import { ExistsExpression } from '../parser/unary-operation-parser.js';
+export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown> implements Expression<O> {
     #private;
     constructor(props: AggregateFunctionBuilderProps);
+    /** @private */
+    /**
+     * All expressions need to have this getter for complicated type-related reasons.
+     * Simply add this getter for your expression and always return `undefined` from it:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     * }
+     * ```
+     *
+     * The getter is needed to make the expression assignable to another expression only
+     * if the types `T` are assignable. Without this property (or some other property
+     * that references `T`), you could assing `Expression<string>` to `Expression<number>`.
+     */
+    get expressionType(): O | undefined;
     /**
      * Returns an aliased version of the function.
      *
@@ -32,13 +53,15 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      */
     as<A extends string>(alias: A): AliasedAggregateFunctionBuilder<DB, TB, O, A>;
     /**
-     * Adds a distinct clause inside the function.
+     * Adds a `distinct` clause inside the function.
+     *
+     * ### Examples
      *
      * ```ts
      * const result = await db
      *   .selectFrom('person')
-     *   .select(
-     *     eb => eb.fn.count<number>('first_name').distinct().as('first_name_count')
+     *   .select((eb) =>
+     *     eb.fn.count<number>('first_name').distinct().as('first_name_count')
      *   )
      *   .executeTakeFirstOrThrow()
      * ```
@@ -52,7 +75,197 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      */
     distinct(): AggregateFunctionBuilder<DB, TB, O>;
     /**
-     * Adds an over clause (window functions) after the function.
+     * Adds a `filter` clause with a nested `where` clause after the function.
+     *
+     * Similar to {@link WhereInterface}'s `where` method.
+     *
+     * Also see {@link orFilterWhere}, {@link filterWhereExists} and {@link filterWhereRef}.
+     *
+     * ### Examples
+     *
+     * Count by gender:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select([
+     *     (eb) =>
+     *       eb.fn
+     *         .count<number>('id')
+     *         .filterWhere('gender', '=', 'female')
+     *         .as('female_count'),
+     *     (eb) =>
+     *       eb.fn
+     *         .count<number>('id')
+     *         .filterWhere('gender', '=', 'male')
+     *         .as('male_count'),
+     *     (eb) =>
+     *       eb.fn
+     *         .count<number>('id')
+     *         .filterWhere('gender', '=', 'other')
+     *         .as('other_count'),
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select
+     *   count("id") filter(where "gender" = $1) as "female_count",
+     *   count("id") filter(where "gender" = $2) as "male_count",
+     *   count("id") filter(where "gender" = $3) as "other_count"
+     * from "person"
+     * ```
+     */
+    filterWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): AggregateFunctionBuilder<DB, TB, O>;
+    filterWhere(grouper: WhereGrouper<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    filterWhere(expression: Expression<any>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds a `filter` clause with a nested `where exists` clause after the function.
+     *
+     * Similar to {@link WhereInterface}'s `whereExists` method.
+     *
+     * ### Examples
+     *
+     * Count pet owners versus general public:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select([
+     *     (eb) =>
+     *       eb.fn
+     *         .count<number>('person.id')
+     *         .filterWhereExists((qb) =>
+     *           qb
+     *             .selectFrom('pet')
+     *             .select('pet.id')
+     *             .whereRef('pet.owner_id', '=', 'person.id')
+     *         )
+     *         .as('pet_owner_count'),
+     *     (eb) => eb.fn.count<number>('person.id').as('total_count'),
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select count("person"."id") filter(where exists (
+     *   select "pet"."id"
+     *   from "pet"
+     *   where "pet"."owner_id" = "person"."id"
+     * )) as "pet_ower_count",
+     *   count("person"."id") as "total_count"
+     * from "person"
+     * ```
+     */
+    filterWhereExists(arg: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Just like {@link filterWhereExists} but creates a `not exists` clause inside
+     * the `filter` clause.
+     */
+    filterWhereNotExists(arg: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds a `filter` clause with a nested `where` clause after the function, where
+     * both sides of the operator are references to columns.
+     *
+     * Similar to {@link WhereInterface}'s `whereRef` method.
+     *
+     * ### Examples
+     *
+     * Count people with same first and last names versus general public:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select([
+     *     (eb) =>
+     *       eb.fn
+     *         .count<number>('id')
+     *         .filterWhereRef('first_name', '=', 'last_name')
+     *         .as('repeat_name_count'),
+     *     (eb) => eb.fn.count<number>('id').as('total_count'),
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select
+     *   count("id") filter(where "first_name" = "last_name") as "repeat_name_count",
+     *   count("id") as "total_count"
+     * from "person"
+     * ```
+     */
+    filterWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds a `filter` clause with a nested `or where` clause after the function.
+     * Otherwise works just like {@link filterWhere}.
+     *
+     * Similar to {@link WhereInterface}'s `orWhere` method.
+     *
+     * ### Examples
+     *
+     * For some reason you're tasked with counting adults (18+) or people called
+     * "Bob" versus general public:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select([
+     *     (eb) =>
+     *       eb.fn
+     *         .count<number>('id')
+     *         .filterWhere('age', '>=', '18')
+     *         .orFilterWhere('first_name', '=', 'Bob')
+     *         .as('adult_or_bob_count'),
+     *     (eb) => eb.fn.count<number>('id').as('total_count'),
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select
+     *   count("id") filter(where "age" >= $1 or "first_name" = $2) as "adult_or_bob_count",
+     *   count("id") as "total_count"
+     * from "person"
+     * ```
+     */
+    orFilterWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): AggregateFunctionBuilder<DB, TB, O>;
+    orFilterWhere(grouper: WhereGrouper<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    orFilterWhere(expression: Expression<any>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Just like {@link filterWhereExists} but creates an `or exists` clause inside
+     * the `filter` clause.
+     *
+     * Similar to {@link WhereInterface}'s `orWhereExists` method.
+     */
+    orFilterWhereExists(arg: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Just like {@link filterWhereExists} but creates an `or not exists` clause inside
+     * the `filter` clause.
+     *
+     * Similar to {@link WhereInterface}'s `orWhereNotExists` method.
+     */
+    orFilterWhereNotExists(arg: ExistsExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds an `or where` clause inside the `filter` clause. Otherwise works just
+     * like {@link filterWhereRef}.
+     *
+     * Also see {@link orFilterWhere} and {@link filterWhere}.
+     *
+     * Similar to {@link WhereInterface}'s `orWhereRef` method.
+     */
+    orFilterWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds an `over` clause (window functions) after the function.
+     *
+     * ### Examples
      *
      * ```ts
      * const result = await db
@@ -92,23 +305,41 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * ```
      */
     over(over?: OverBuilderCallback<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     *
+     * If you are creating a custom expression, it's often easiest to use the {@link sql}
+     * template tag to build the node:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
+     * }
+     * ```
+     */
     toOperationNode(): AggregateFunctionNode;
 }
 /**
  * {@link AggregateFunctionBuilder} with an alias. The result of calling {@link AggregateFunctionBuilder.as}.
  */
-export declare class AliasedAggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown, A extends string = never> implements OperationNodeSource {
+export declare class AliasedAggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown, A extends string = never> implements AliasedExpression<O, A> {
     #private;
     constructor(aggregateFunctionBuilder: AggregateFunctionBuilder<DB, TB, O>, alias: A);
+    /** @private */
     /**
-     * @private
-     *
-     * This needs to be here just so that the typings work. Without this
-     * the generated .d.ts file contains no reference to the type param A
-     * which causes this type to be equal to AliasedAggregateFunctionBuilder with any A
-     * as long as O is the same.
+     * Returns the aliased expression.
+     */
+    get expression(): Expression<O>;
+    /** @private */
+    /**
+     * Returns the alias.
+     */
+    get alias(): A;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
      */
-    protected get alias(): A;
     toOperationNode(): AliasNode;
 }
 export interface AggregateFunctionBuilderProps {