noormme 1.0.0

package/dist/cjs/plugin/with-schema/with-schema-plugin.d.ts

@@ -0,0 +1,66 @@
+import { QueryResult } from '../../driver/database-connection.js';
+import { RootOperationNode } from '../../query-compiler/query-compiler.js';
+import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+import { UnknownRow } from '../../util/type-utils.js';
+export declare class WithSchemaPlugin implements KyselyPlugin {
+    #private;
+    constructor(schema: string);
+    /**
+     * This is called for each query before it is executed. You can modify the query by
+     * transforming its {@link OperationNode} tree provided in {@link PluginTransformQueryArgs.node | args.node}
+     * and returning the transformed tree. You'd usually want to use an {@link OperationNodeTransformer}
+     * for this.
+     *
+     * If you need to pass some query-related data between this method and `transformResult` you
+     * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
+     *
+     * ```ts
+     * import type {
+     *   KyselyPlugin,
+     *   QueryResult,
+     *   RootOperationNode,
+     *   UnknownRow
+     * } from 'kysely'
+     *
+     * interface MyData {
+     *   // ...
+     * }
+     * const data = new WeakMap<any, MyData>()
+     *
+     * const plugin = {
+     *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
+     *     const something: MyData = {}
+     *
+     *     // ...
+     *
+     *     data.set(args.queryId, something)
+     *
+     *     // ...
+     *
+     *     return args.node
+     *   },
+     *
+     *   async transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
+     *     // ...
+     *
+     *     const something = data.get(args.queryId)
+     *
+     *     // ...
+     *
+     *     return args.result
+     *   }
+     * } satisfies KyselyPlugin
+     * ```
+     *
+     * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`
+     * is not always matched by a call to `transformResult` which would leave orphaned items in the map
+     * and cause a memory leak.
+     */
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    /**
+     * This method is called for each query after it has been executed. The result
+     * of the query can be accessed through {@link PluginTransformResultArgs.result | args.result}.
+     * You can modify the result and return the modifier result.
+     */
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+}

package/dist/cjs/plugin/with-schema/with-schema-plugin.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithSchemaPlugin = void 0;
+const with_schema_transformer_js_1 = require("./with-schema-transformer.js");
+class WithSchemaPlugin {
+    #transformer;
+    constructor(schema) {
+        this.#transformer = new with_schema_transformer_js_1.WithSchemaTransformer(schema);
+    }
+    transformQuery(args) {
+        return this.#transformer.transformNode(args.node, args.queryId);
+    }
+    async transformResult(args) {
+        return args.result;
+    }
+}
+exports.WithSchemaPlugin = WithSchemaPlugin;

package/dist/cjs/plugin/with-schema/with-schema-transformer.d.ts

@@ -0,0 +1,16 @@
+import { AggregateFunctionNode } from '../../operation-node/aggregate-function-node.js';
+import { FunctionNode } from '../../operation-node/function-node.js';
+import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
+import { OperationNode } from '../../operation-node/operation-node.js';
+import { ReferencesNode } from '../../operation-node/references-node.js';
+import { SchemableIdentifierNode } from '../../operation-node/schemable-identifier-node.js';
+import { QueryId } from '../../util/query-id.js';
+export declare class WithSchemaTransformer extends OperationNodeTransformer {
+    #private;
+    constructor(schema: string);
+    protected transformNodeImpl<T extends OperationNode>(node: T, queryId: QueryId): T;
+    protected transformSchemableIdentifier(node: SchemableIdentifierNode, queryId: QueryId): SchemableIdentifierNode;
+    protected transformReferences(node: ReferencesNode, queryId: QueryId): ReferencesNode;
+    protected transformAggregateFunction(node: AggregateFunctionNode, queryId: QueryId): AggregateFunctionNode;
+    protected transformFunction(node: FunctionNode, queryId: QueryId): FunctionNode;
+}

package/dist/cjs/plugin/with-schema/with-schema-transformer.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithSchemaTransformer = void 0;
+const alias_node_js_1 = require("../../operation-node/alias-node.js");
+const identifier_node_js_1 = require("../../operation-node/identifier-node.js");
+const join_node_js_1 = require("../../operation-node/join-node.js");
+const list_node_js_1 = require("../../operation-node/list-node.js");
+const operation_node_transformer_js_1 = require("../../operation-node/operation-node-transformer.js");
+const schemable_identifier_node_js_1 = require("../../operation-node/schemable-identifier-node.js");
+const table_node_js_1 = require("../../operation-node/table-node.js");
+const object_utils_js_1 = require("../../util/object-utils.js");
+// This object exist only so that we get a type error when a new RootOperationNode
+// is added. If you get a type error here, make sure to add the new root node and
+// handle it correctly in the transformer.
+//
+// DO NOT REFACTOR THIS EVEN IF IT SEEMS USELESS TO YOU!
+const ROOT_OPERATION_NODES = (0, object_utils_js_1.freeze)({
+    AlterTableNode: true,
+    CreateIndexNode: true,
+    CreateSchemaNode: true,
+    CreateTableNode: true,
+    CreateTypeNode: true,
+    CreateViewNode: true,
+    RefreshMaterializedViewNode: true,
+    DeleteQueryNode: true,
+    DropIndexNode: true,
+    DropSchemaNode: true,
+    DropTableNode: true,
+    DropTypeNode: true,
+    DropViewNode: true,
+    InsertQueryNode: true,
+    RawNode: true,
+    SelectQueryNode: true,
+    UpdateQueryNode: true,
+    MergeQueryNode: true,
+});
+const SCHEMALESS_FUNCTIONS = {
+    json_agg: true,
+    to_json: true,
+};
+class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNodeTransformer {
+    #schema;
+    #schemableIds = new Set();
+    #ctes = new Set();
+    constructor(schema) {
+        super();
+        this.#schema = schema;
+    }
+    transformNodeImpl(node, queryId) {
+        if (!this.#isRootOperationNode(node)) {
+            return super.transformNodeImpl(node, queryId);
+        }
+        const ctes = this.#collectCTEs(node);
+        for (const cte of ctes) {
+            this.#ctes.add(cte);
+        }
+        const tables = this.#collectSchemableIds(node);
+        for (const table of tables) {
+            this.#schemableIds.add(table);
+        }
+        const transformed = super.transformNodeImpl(node, queryId);
+        for (const table of tables) {
+            this.#schemableIds.delete(table);
+        }
+        for (const cte of ctes) {
+            this.#ctes.delete(cte);
+        }
+        return transformed;
+    }
+    transformSchemableIdentifier(node, queryId) {
+        const transformed = super.transformSchemableIdentifier(node, queryId);
+        if (transformed.schema || !this.#schemableIds.has(node.identifier.name)) {
+            return transformed;
+        }
+        return {
+            ...transformed,
+            schema: identifier_node_js_1.IdentifierNode.create(this.#schema),
+        };
+    }
+    transformReferences(node, queryId) {
+        const transformed = super.transformReferences(node, queryId);
+        if (transformed.table.table.schema) {
+            return transformed;
+        }
+        return {
+            ...transformed,
+            table: table_node_js_1.TableNode.createWithSchema(this.#schema, transformed.table.table.identifier.name),
+        };
+    }
+    transformAggregateFunction(node, queryId) {
+        return {
+            ...super.transformAggregateFunction({ ...node, aggregated: [] }, queryId),
+            aggregated: this.#transformTableArgsWithoutSchemas(node, queryId, 'aggregated'),
+        };
+    }
+    transformFunction(node, queryId) {
+        return {
+            ...super.transformFunction({ ...node, arguments: [] }, queryId),
+            arguments: this.#transformTableArgsWithoutSchemas(node, queryId, 'arguments'),
+        };
+    }
+    #transformTableArgsWithoutSchemas(node, queryId, argsKey) {
+        return SCHEMALESS_FUNCTIONS[node.func]
+            ? node[argsKey].map((arg) => !table_node_js_1.TableNode.is(arg) || arg.table.schema
+                ? this.transformNode(arg, queryId)
+                : {
+                    ...arg,
+                    table: this.transformIdentifier(arg.table.identifier, queryId),
+                })
+            : this.transformNodeList(node[argsKey], queryId);
+    }
+    #isRootOperationNode(node) {
+        return node.kind in ROOT_OPERATION_NODES;
+    }
+    #collectSchemableIds(node) {
+        const schemableIds = new Set();
+        if ('name' in node && node.name && schemable_identifier_node_js_1.SchemableIdentifierNode.is(node.name)) {
+            this.#collectSchemableId(node.name, schemableIds);
+        }
+        if ('from' in node && node.from) {
+            for (const from of node.from.froms) {
+                this.#collectSchemableIdsFromTableExpr(from, schemableIds);
+            }
+        }
+        if ('into' in node && node.into) {
+            this.#collectSchemableIdsFromTableExpr(node.into, schemableIds);
+        }
+        if ('table' in node && node.table) {
+            this.#collectSchemableIdsFromTableExpr(node.table, schemableIds);
+        }
+        if ('joins' in node && node.joins) {
+            for (const join of node.joins) {
+                this.#collectSchemableIdsFromTableExpr(join.table, schemableIds);
+            }
+        }
+        if ('using' in node && node.using) {
+            if (join_node_js_1.JoinNode.is(node.using)) {
+                this.#collectSchemableIdsFromTableExpr(node.using.table, schemableIds);
+            }
+            else {
+                this.#collectSchemableIdsFromTableExpr(node.using, schemableIds);
+            }
+        }
+        return schemableIds;
+    }
+    #collectCTEs(node) {
+        const ctes = new Set();
+        if ('with' in node && node.with) {
+            this.#collectCTEIds(node.with, ctes);
+        }
+        return ctes;
+    }
+    #collectSchemableIdsFromTableExpr(node, schemableIds) {
+        if (table_node_js_1.TableNode.is(node)) {
+            this.#collectSchemableId(node.table, schemableIds);
+        }
+        else if (alias_node_js_1.AliasNode.is(node) && table_node_js_1.TableNode.is(node.node)) {
+            this.#collectSchemableId(node.node.table, schemableIds);
+        }
+        else if (list_node_js_1.ListNode.is(node)) {
+            for (const table of node.items) {
+                this.#collectSchemableIdsFromTableExpr(table, schemableIds);
+            }
+        }
+    }
+    #collectSchemableId(node, schemableIds) {
+        const id = node.identifier.name;
+        if (!this.#schemableIds.has(id) && !this.#ctes.has(id)) {
+            schemableIds.add(id);
+        }
+    }
+    #collectCTEIds(node, ctes) {
+        for (const expr of node.expressions) {
+            const cteId = expr.name.table.table.identifier.name;
+            if (!this.#ctes.has(cteId)) {
+                ctes.add(cteId);
+            }
+        }
+    }
+}
+exports.WithSchemaTransformer = WithSchemaTransformer;

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

@@ -0,0 +1,379 @@
+import { AggregateFunctionNode } from '../operation-node/aggregate-function-node.js';
+import { AliasNode } from '../operation-node/alias-node.js';
+import { OverBuilder } from './over-builder.js';
+import { AliasableExpression, AliasedExpression, Expression } from '../expression/expression.js';
+import { ReferenceExpression } from '../parser/reference-parser.js';
+import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
+import { SqlBool } from '../util/type-utils.js';
+import { ExpressionOrFactory } from '../parser/expression-parser.js';
+import { DirectedOrderByStringReference, OrderByExpression, OrderByModifiers } from '../parser/order-by-parser.js';
+import { OrderByInterface } from './order-by-interface.js';
+export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown> implements OrderByInterface<DB, TB, {}>, AliasableExpression<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:
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { type Expression, type OperationNode, sql } from 'kysely'
+     *
+     * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     *
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
+     * }
+     * ```
+     *
+     * 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.
+     *
+     * In addition to slapping `as "the_alias"` to the end of the SQL,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     (eb) => eb.fn.count<number>('id').as('person_count')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `person_count: number` field exists in the result type.
+     * console.log(result.person_count)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select count("id") as "person_count"
+     * from "person"
+     * ```
+     */
+    as<A extends string>(alias: A): AliasedAggregateFunctionBuilder<DB, TB, O, A>;
+    /**
+     * 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')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select count(distinct "first_name") as "first_name_count"
+     * from "person"
+     * ```
+     */
+    distinct(): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds an `order by` clause inside the aggregate function.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *   .select((eb) =>
+     *     eb.fn.jsonAgg('pet').orderBy('pet.name').as('person_pets')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select json_agg("pet" order by "pet"."name") as "person_pets"
+     * from "person"
+     * inner join "pet" ON "pet"."owner_id" = "person"."id"
+     * ```
+     */
+    orderBy<OE extends OrderByExpression<DB, TB, {}>>(expr: OE, modifiers?: OrderByModifiers): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * @deprecated It does ~2-2.6x more compile-time instantiations compared to multiple chained `orderBy(expr, modifiers?)` calls (in `order by` clauses with reasonable item counts), and has broken autocompletion.
+     */
+    orderBy<OE extends OrderByExpression<DB, TB, {}> | DirectedOrderByStringReference<DB, TB, {}>>(exprs: ReadonlyArray<OE>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * @deprecated It does ~2.9x more compile-time instantiations compared to a `orderBy(expr, direction)` call.
+     */
+    orderBy<OE extends DirectedOrderByStringReference<DB, TB, {}>>(expr: OE): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * @deprecated Use `orderBy(expr, (ob) => ...)` instead.
+     */
+    orderBy<OE extends OrderByExpression<DB, TB, {}>>(expr: OE, modifiers: Expression<any>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Clears the `order by` clause from the query.
+     *
+     * See {@link orderBy} for adding an `order by` clause or item to a query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const query = db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .orderBy('id', 'desc')
+     *
+     * const results = await query
+     *   .clearOrderBy()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearOrderBy(): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds a `withing group` clause with a nested `order by` clause after the function.
+     *
+     * This is only supported by some dialects like PostgreSQL or MS SQL Server.
+     *
+     * ### Examples
+     *
+     * Most frequent person name:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select((eb) => [
+     *     eb.fn
+     *       .agg<string>('mode')
+     *       .withinGroupOrderBy('person.first_name')
+     *       .as('most_frequent_name')
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select mode() within group (order by "person"."first_name") as "most_frequent_name"
+     * from "person"
+     * ```
+     */
+    withinGroupOrderBy<OE extends OrderByExpression<DB, TB, {}>>(expr: OE, modifiers?: OrderByModifiers): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * @deprecated It does ~2-2.6x more compile-time instantiations compared to multiple chained `withinGroupOrderBy(expr, modifiers?)` calls (in `order by` clauses with reasonable item counts), and has broken autocompletion.
+     */
+    withinGroupOrderBy<OE extends OrderByExpression<DB, TB, {}> | DirectedOrderByStringReference<DB, TB, {}>>(exprs: ReadonlyArray<OE>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * @deprecated It does ~2.9x more compile-time instantiations compared to a `withinGroupOrderBy(expr, direction)` call.
+     */
+    withinGroupOrderBy<OE extends DirectedOrderByStringReference<DB, TB, {}>>(expr: OE): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * @deprecated Use `withinGroupOrderBy(expr, (ob) => ...)` instead.
+     */
+    withinGroupOrderBy<OE extends OrderByExpression<DB, TB, {}>>(expr: OE, modifiers: Expression<any>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds a `filter` clause with a nested `where` clause after the function.
+     *
+     * Similar to {@link WhereInterface}'s `where` method.
+     *
+     * Also see {@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.fn
+     *       .count<number>('id')
+     *       .filterWhere('gender', '=', 'male')
+     *       .as('male_count'),
+     *     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>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): AggregateFunctionBuilder<DB, TB, O>;
+    filterWhere<E extends ExpressionOrFactory<DB, TB, SqlBool>>(expression: E): 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.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<LRE extends ReferenceExpression<DB, TB>, RRE extends ReferenceExpression<DB, TB>>(lhs: LRE, op: ComparisonOperatorExpression, rhs: RRE): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds an `over` clause (window functions) after the function.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     (eb) => eb.fn.avg<number>('age').over().as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over() as "average_age"
+     * from "person"
+     * ```
+     *
+     * Also supports passing a callback that returns an over builder,
+     * allowing to add partition by and sort by clauses inside over.
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     (eb) => eb.fn.avg<number>('age').over(
+     *       ob => ob.partitionBy('last_name').orderBy('first_name', 'asc')
+     *     ).as('average_age')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select avg("age") over(partition by "last_name" order by "first_name" asc) as "average_age"
+     * from "person"
+     * ```
+     */
+    over(over?: OverBuilderCallback<DB, TB>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
+    /**
+     * Casts the expression to the given type.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `AggregateFunctionBuilder` with a new output type.
+     */
+    $castTo<C>(): AggregateFunctionBuilder<DB, TB, C>;
+    /**
+     * Omit null from the expression's type.
+     *
+     * This function can be useful in cases where you know an expression can't be
+     * null, but Kysely is unable to infer it.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of `this` with a new output type.
+     */
+    $notNull(): AggregateFunctionBuilder<DB, TB, Exclude<O, null>>;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     *
+     * ### Examples
+     *
+     * If you are creating a custom expression, it's often easiest to use the {@link sql}
+     * template tag to build the node:
+     *
+     * ```ts
+     * import { type Expression, type OperationNode, sql } from 'kysely'
+     *
+     * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     *
+     *   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 AliasedExpression<O, A> {
+    #private;
+    constructor(aggregateFunctionBuilder: AggregateFunctionBuilder<DB, TB, O>, alias: A);
+    /** @private */
+    /**
+     * 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.
+     */
+    toOperationNode(): AliasNode;
+}
+export interface AggregateFunctionBuilderProps {
+    aggregateFunctionNode: AggregateFunctionNode;
+}
+export type OverBuilderCallback<DB, TB extends keyof DB> = (builder: OverBuilder<DB, TB>) => OverBuilder<any, any>;