kysely 0.22.0 → 0.23.1

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 {

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

@@ -5,11 +5,17 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { createOverBuilder } from '../parser/parse-utils.js';
+import { parseReferentialFilter, parseWhere, } from '../parser/binary-operation-parser.js';
+import { parseExists, parseNotExists, } from '../parser/unary-operation-parser.js';
 export class AggregateFunctionBuilder {
     #props;
     constructor(props) {
         this.#props = freeze(props);
     }
+    /** @private */
+    get expressionType() {
+        return undefined;
+    }
     /**
      * Returns an aliased version of the function.
      *
@@ -39,13 +45,15 @@ export 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()
      * ```
@@ -63,8 +71,155 @@ export class AggregateFunctionBuilder {
             aggregateFunctionNode: AggregateFunctionNode.cloneWithDistinct(this.#props.aggregateFunctionNode),
         });
     }
+    filterWhere(...args) {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, 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: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseExists(arg)),
+        });
+    }
+    /**
+     * Just like {@link filterWhereExists} but creates a `not exists` clause inside
+     * the `filter` clause.
+     */
+    filterWhereNotExists(arg) {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, 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: AggregateFunctionNode.cloneWithFilter(this.#props.aggregateFunctionNode, parseReferentialFilter(lhs, op, rhs)),
+        });
+    }
+    orFilterWhere(...args) {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: AggregateFunctionNode.cloneWithOrFilter(this.#props.aggregateFunctionNode, 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: AggregateFunctionNode.cloneWithOrFilter(this.#props.aggregateFunctionNode, 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: AggregateFunctionNode.cloneWithOrFilter(this.#props.aggregateFunctionNode, 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: AggregateFunctionNode.cloneWithOrFilter(this.#props.aggregateFunctionNode, parseReferentialFilter(lhs, op, rhs)),
+        });
+    }
+    /**
+     * Adds an `over` clause (window functions) after the function.
+     *
+     * ### Examples
      *
      * ```ts
      * const result = await db
@@ -125,14 +280,11 @@ export 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;
     }