kysely 0.22.0 → 0.23.0

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

@@ -4,7 +4,7 @@ exports.parseTable = exports.parseAliasedTable = exports.parseTableExpression =
 const object_utils_js_1 = require("../util/object-utils.js");
 const alias_node_js_1 = require("../operation-node/alias-node.js");
 const table_node_js_1 = require("../operation-node/table-node.js");
-const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
+const expression_parser_js_1 = require("./expression-parser.js");
 const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 function parseTableExpressionOrList(table) {
     if ((0, object_utils_js_1.isReadonlyArray)(table)) {
@@ -20,7 +20,7 @@ function parseTableExpression(table) {
         return parseAliasedTable(table);
     }
     else {
-        return (0, complex_expression_parser_js_1.parseAliasedComplexExpression)(table);
+        return (0, expression_parser_js_1.parseAliasedExpression)(table);
     }
 }
 exports.parseTableExpression = parseTableExpression;

package/dist/cjs/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/cjs/parser/unary-operation-parser.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNotExists = exports.parseExists = void 0;
+const operator_node_js_1 = require("../operation-node/operator-node.js");
+const unary_operation_node_js_1 = require("../operation-node/unary-operation-node.js");
+const value_parser_js_1 = require("./value-parser.js");
+function parseExists(arg) {
+    return parseUnaryOperation('exists', arg);
+}
+exports.parseExists = parseExists;
+function parseNotExists(arg) {
+    return parseUnaryOperation('not exists', arg);
+}
+exports.parseNotExists = parseNotExists;
+function parseUnaryOperation(type, arg) {
+    return unary_operation_node_js_1.UnaryOperationNode.create(operator_node_js_1.OperatorNode.create(type), (0, value_parser_js_1.parseValueExpressionOrList)(arg));
+}

package/dist/cjs/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/cjs/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/cjs/parser/value-parser.js

@@ -5,7 +5,7 @@ const primitive_value_list_node_js_1 = require("../operation-node/primitive-valu
 const value_list_node_js_1 = require("../operation-node/value-list-node.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
-const complex_expression_parser_js_1 = require("./complex-expression-parser.js");
+const expression_parser_js_1 = require("./expression-parser.js");
 function parseValueExpressionOrList(arg) {
     if ((0, object_utils_js_1.isReadonlyArray)(arg)) {
         return parseValueExpressionList(arg);
@@ -16,14 +16,14 @@ function parseValueExpressionOrList(arg) {
 }
 exports.parseValueExpressionOrList = parseValueExpressionOrList;
 function parseValueExpression(exp) {
-    if ((0, complex_expression_parser_js_1.isComplexExpression)(exp)) {
-        return (0, complex_expression_parser_js_1.parseComplexExpression)(exp);
+    if ((0, expression_parser_js_1.isExpressionOrFactory)(exp)) {
+        return (0, expression_parser_js_1.parseExpression)(exp);
     }
     return value_node_js_1.ValueNode.create(exp);
 }
 exports.parseValueExpression = parseValueExpression;
 function parseValueExpressionList(arg) {
-    if (arg.some(complex_expression_parser_js_1.isComplexExpression)) {
+    if (arg.some(expression_parser_js_1.isExpressionOrFactory)) {
         return value_list_node_js_1.ValueListNode.create(arg.map((it) => parseValueExpression(it)));
     }
     return primitive_value_list_node_js_1.PrimitiveValueListNode.create(arg);

package/dist/cjs/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/cjs/plugin/camel-case/camel-case-plugin.js

@@ -111,5 +111,5 @@ class CamelCasePlugin {
 }
 exports.CamelCasePlugin = CamelCasePlugin;
 function canMap(obj) {
-    return (0, object_utils_js_1.isObject)(obj) && !(0, object_utils_js_1.isDate)(obj) && !(0, object_utils_js_1.isBuffer)(obj);
+    return ((0, object_utils_js_1.isObject)(obj) && !(0, object_utils_js_1.isDate)(obj) && !(0, object_utils_js_1.isBuffer)(obj) && !(0, object_utils_js_1.isArrayBufferOrView)(obj));
 }

package/dist/cjs/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 {

package/dist/cjs/query-builder/aggregate-function-builder.js

@@ -7,11 +7,17 @@ const alias_node_js_1 = require("../operation-node/alias-node.js");
 const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 const parse_utils_js_1 = require("../parser/parse-utils.js");
+const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
+const unary_operation_parser_js_1 = require("../parser/unary-operation-parser.js");
 class AggregateFunctionBuilder {
     #props;
     constructor(props) {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
+    /** @private */
+    get expressionType() {
+        return undefined;
+    }
     /**
      * Returns an aliased version of the function.
      *
@@ -41,13 +47,15 @@ class AggregateFunctionBuilder {
         return new AliasedAggregateFunctionBuilder(this, alias);
     }
     /**
-     * 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()
      * ```
@@ -65,8 +73,155 @@ class AggregateFunctionBuilder {
             aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithDistinct(this.#props.aggregateFunctionNode),
         });
     }
+    filterWhere(...args) {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, (0, binary_operation_parser_js_1.parseWhere)(args)),
+        });
+    }
+    /**
+     * 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) {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, (0, unary_operation_parser_js_1.parseExists)(arg)),
+        });
+    }
+    /**
+     * Just like {@link filterWhereExists} but creates a `not exists` clause inside
+     * the `filter` clause.
+     */
+    filterWhereNotExists(arg) {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, (0, unary_operation_parser_js_1.parseNotExists)(arg)),
+        });
+    }
+    /**
+     * 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, op, rhs) {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, (0, binary_operation_parser_js_1.parseReferentialFilter)(lhs, op, rhs)),
+        });
+    }
+    orFilterWhere(...args) {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithOrFilter(this.#props.aggregateFunctionNode, (0, binary_operation_parser_js_1.parseWhere)(args)),
+        });
+    }
     /**
-     * Adds an over clause (window functions) after the function.
+     * Just like {@link filterWhereExists} but creates an `or exists` clause inside
+     * the `filter` clause.
+     *
+     * Similar to {@link WhereInterface}'s `orWhereExists` method.
+     */
+    orFilterWhereExists(arg) {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithOrFilter(this.#props.aggregateFunctionNode, (0, unary_operation_parser_js_1.parseExists)(arg)),
+        });
+    }
+    /**
+     * Just like {@link filterWhereExists} but creates an `or not exists` clause inside
+     * the `filter` clause.
+     *
+     * Similar to {@link WhereInterface}'s `orWhereNotExists` method.
+     */
+    orFilterWhereNotExists(arg) {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithOrFilter(this.#props.aggregateFunctionNode, (0, unary_operation_parser_js_1.parseNotExists)(arg)),
+        });
+    }
+    /**
+     * 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, op, rhs) {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithOrFilter(this.#props.aggregateFunctionNode, (0, binary_operation_parser_js_1.parseReferentialFilter)(lhs, op, rhs)),
+        });
+    }
+    /**
+     * Adds an `over` clause (window functions) after the function.
+     *
+     * ### Examples
      *
      * ```ts
      * const result = await db
@@ -128,14 +283,11 @@ class AliasedAggregateFunctionBuilder {
         this.#aggregateFunctionBuilder = aggregateFunctionBuilder;
         this.#alias = alias;
     }
-    /**
-     * @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.
-     */
+    /** @private */
+    get expression() {
+        return this.#aggregateFunctionBuilder;
+    }
+    /** @private */
     get alias() {
         return this.#alias;
     }