kysely 0.28.17 → 0.29.0

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

@@ -1,379 +0,0 @@
-import { AggregateFunctionNode } from '../operation-node/aggregate-function-node.js';
-import { AliasNode } from '../operation-node/alias-node.js';
-import type { OverBuilder } from './over-builder.js';
-import type { AliasableExpression, AliasedExpression, Expression } from '../expression/expression.js';
-import type { ReferenceExpression } from '../parser/reference-parser.js';
-import { type ComparisonOperatorExpression, type OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
-import type { SqlBool } from '../util/type-utils.js';
-import type { ExpressionOrFactory } from '../parser/expression-parser.js';
-import { type DirectedOrderByStringReference, type OrderByExpression, type OrderByModifiers } from '../parser/order-by-parser.js';
-import type { 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>;

package/dist/esm/query-builder/case-builder.d.ts

@@ -1,128 +0,0 @@
-import type { Expression } from '../expression/expression.js';
-import { ExpressionWrapper } from '../expression/expression-wrapper.js';
-import type { ReferenceExpression } from '../parser/reference-parser.js';
-import { CaseNode } from '../operation-node/case-node.js';
-import { type ComparisonOperatorExpression, type OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
-import { type ExtractTypeFromValueExpression } from '../parser/value-parser.js';
-import type { KyselyTypeError } from '../util/type-error.js';
-export declare class CaseBuilder<DB, TB extends keyof DB, W = unknown, O = never> implements Whenable<DB, TB, W, O> {
-    #private;
-    constructor(props: CaseBuilderProps);
-    /**
-     * Adds a `when` clause to the case statement.
-     *
-     * A `when` call must be followed by a {@link CaseThenBuilder.then} call.
-     */
-    when<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: VE): CaseThenBuilder<DB, TB, W, O>;
-    when(expression: Expression<W>): CaseThenBuilder<DB, TB, W, O>;
-    when(value: unknown extends W ? KyselyTypeError<'when(value) is only supported when using case(value)'> : W): CaseThenBuilder<DB, TB, W, O>;
-}
-interface CaseBuilderProps {
-    readonly node: CaseNode;
-}
-export declare class CaseThenBuilder<DB, TB extends keyof DB, W, O> {
-    #private;
-    constructor(props: CaseBuilderProps);
-    /**
-     * Adds a `then` clause to the `case` statement.
-     *
-     * A `then` call can be followed by {@link Whenable.when}, {@link CaseWhenBuilder.else},
-     * {@link CaseWhenBuilder.end} or {@link CaseWhenBuilder.endCase} call.
-     *
-     * **Note:** Numbers, booleans, and `null` values are inlined directly into the
-     * SQL query string (e.g. `then 1`, `then true`, `then null`) instead of being
-     * added as parameterized values (e.g. `then $1`). This allows the database
-     * engine to correctly infer the data type of the `case` expression result.
-     * Without this behavior, all results would be returned as strings.
-     *
-     * String values are always parameterized as usual.
-     */
-    then<E extends Expression<unknown>>(expression: E): CaseWhenBuilder<DB, TB, W, O | ExtractTypeFromValueExpression<E>>;
-    then<V>(value: V): CaseWhenBuilder<DB, TB, W, O | V>;
-}
-export declare class CaseWhenBuilder<DB, TB extends keyof DB, W, O> implements Whenable<DB, TB, W, O>, Endable<DB, TB, O | null> {
-    #private;
-    constructor(props: CaseBuilderProps);
-    /**
-     * Adds a `when` clause to the case statement.
-     *
-     * A `when` call must be followed by a {@link CaseThenBuilder.then} call.
-     */
-    when<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: VE): CaseThenBuilder<DB, TB, W, O>;
-    when(expression: Expression<W>): CaseThenBuilder<DB, TB, W, O>;
-    when(value: unknown extends W ? KyselyTypeError<'when(value) is only supported when using case(value)'> : W): CaseThenBuilder<DB, TB, W, O>;
-    /**
-     * Adds an `else` clause to the `case` statement.
-     *
-     * An `else` call must be followed by an {@link Endable.end} or {@link Endable.endCase} call.
-     *
-     * **Note:** Numbers, booleans, and `null` values are inlined directly into the
-     * SQL query string (e.g. `else 0`, `else false`, `else null`) instead of being
-     * added as parameterized values (e.g. `else $1`). This allows the database
-     * engine to correctly infer the data type of the `case` expression result.
-     * Without this behavior, all results would be returned as strings.
-     *
-     * String values are always parameterized as usual.
-     */
-    else<E extends Expression<unknown>>(expression: E): CaseEndBuilder<DB, TB, O | ExtractTypeFromValueExpression<E>>;
-    else<V>(value: V): CaseEndBuilder<DB, TB, O | V>;
-    /**
-     * Adds an `end` keyword to the case operator.
-     *
-     * `case` operators can only be used as part of a query.
-     * For a `case` statement used as part of a stored program, use {@link endCase} instead.
-     */
-    end(): ExpressionWrapper<DB, TB, O | null>;
-    /**
-     * Adds `end case` keywords to the case statement.
-     *
-     * `case` statements can only be used for flow control in stored programs.
-     * For a `case` operator used as part of a query, use {@link end} instead.
-     */
-    endCase(): ExpressionWrapper<DB, TB, O | null>;
-}
-export declare class CaseEndBuilder<DB, TB extends keyof DB, O> implements Endable<DB, TB, O> {
-    #private;
-    constructor(props: CaseBuilderProps);
-    /**
-     * Adds an `end` keyword to the case operator.
-     *
-     * `case` operators can only be used as part of a query.
-     * For a `case` statement used as part of a stored program, use {@link endCase} instead.
-     */
-    end(): ExpressionWrapper<DB, TB, O>;
-    /**
-     * Adds `end case` keywords to the case statement.
-     *
-     * `case` statements can only be used for flow control in stored programs.
-     * For a `case` operator used as part of a query, use {@link end} instead.
-     */
-    endCase(): ExpressionWrapper<DB, TB, O>;
-}
-interface Whenable<DB, TB extends keyof DB, W, O> {
-    /**
-     * Adds a `when` clause to the case statement.
-     *
-     * A `when` call must be followed by a {@link CaseThenBuilder.then} call.
-     */
-    when<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: unknown extends W ? RE : KyselyTypeError<'when(lhs, op, rhs) is not supported when using case(value)'>, op: ComparisonOperatorExpression, rhs: VE): CaseThenBuilder<DB, TB, W, O>;
-    when(expression: Expression<W>): CaseThenBuilder<DB, TB, W, O>;
-    when(value: unknown extends W ? KyselyTypeError<'when(value) is only supported when using case(value)'> : W): CaseThenBuilder<DB, TB, W, O>;
-}
-interface Endable<DB, TB extends keyof DB, O> {
-    /**
-     * Adds an `end` keyword to the case operator.
-     *
-     * `case` operators can only be used as part of a query.
-     * For a `case` statement used as part of a stored program, use {@link endCase} instead.
-     */
-    end(): ExpressionWrapper<DB, TB, O>;
-    /**
-     * Adds `end case` keywords to the case statement.
-     *
-     * `case` statements can only be used for flow control in stored programs.
-     * For a `case` operator used as part of a query, use {@link end} instead.
-     */
-    endCase(): ExpressionWrapper<DB, TB, O>;
-}
-export {};

package/dist/esm/query-builder/case-builder.js

@@ -1,73 +0,0 @@
-/// <reference types="./case-builder.d.ts" />
-import { ExpressionWrapper } from '../expression/expression-wrapper.js';
-import { freeze } from '../util/object-utils.js';
-import { CaseNode } from '../operation-node/case-node.js';
-import { WhenNode } from '../operation-node/when-node.js';
-import { parseValueBinaryOperationOrExpression, } from '../parser/binary-operation-parser.js';
-import { isSafeImmediateValue, parseSafeImmediateValue, parseValueExpression, } from '../parser/value-parser.js';
-export class CaseBuilder {
-    #props;
-    constructor(props) {
-        this.#props = freeze(props);
-    }
-    when(...args) {
-        return new CaseThenBuilder({
-            ...this.#props,
-            node: CaseNode.cloneWithWhen(this.#props.node, WhenNode.create(parseValueBinaryOperationOrExpression(args))),
-        });
-    }
-}
-export class CaseThenBuilder {
-    #props;
-    constructor(props) {
-        this.#props = freeze(props);
-    }
-    then(valueExpression) {
-        return new CaseWhenBuilder({
-            ...this.#props,
-            node: CaseNode.cloneWithThen(this.#props.node, isSafeImmediateValue(valueExpression)
-                ? parseSafeImmediateValue(valueExpression)
-                : parseValueExpression(valueExpression)),
-        });
-    }
-}
-export class CaseWhenBuilder {
-    #props;
-    constructor(props) {
-        this.#props = freeze(props);
-    }
-    when(...args) {
-        return new CaseThenBuilder({
-            ...this.#props,
-            node: CaseNode.cloneWithWhen(this.#props.node, WhenNode.create(parseValueBinaryOperationOrExpression(args))),
-        });
-    }
-    else(valueExpression) {
-        return new CaseEndBuilder({
-            ...this.#props,
-            node: CaseNode.cloneWith(this.#props.node, {
-                else: isSafeImmediateValue(valueExpression)
-                    ? parseSafeImmediateValue(valueExpression)
-                    : parseValueExpression(valueExpression),
-            }),
-        });
-    }
-    end() {
-        return new ExpressionWrapper(CaseNode.cloneWith(this.#props.node, { isStatement: false }));
-    }
-    endCase() {
-        return new ExpressionWrapper(CaseNode.cloneWith(this.#props.node, { isStatement: true }));
-    }
-}
-export class CaseEndBuilder {
-    #props;
-    constructor(props) {
-        this.#props = freeze(props);
-    }
-    end() {
-        return new ExpressionWrapper(CaseNode.cloneWith(this.#props.node, { isStatement: false }));
-    }
-    endCase() {
-        return new ExpressionWrapper(CaseNode.cloneWith(this.#props.node, { isStatement: true }));
-    }
-}

package/dist/esm/query-builder/cte-builder.d.ts

@@ -1,20 +0,0 @@
-import type { OperationNodeSource } from '../operation-node/operation-node-source.js';
-import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
-export declare class CTEBuilder<N extends string> implements OperationNodeSource {
-    #private;
-    constructor(props: CTEBuilderProps);
-    /**
-     * Makes the common table expression materialized.
-     */
-    materialized(): CTEBuilder<N>;
-    /**
-     * Makes the common table expression not materialized.
-     */
-    notMaterialized(): CTEBuilder<N>;
-    toOperationNode(): CommonTableExpressionNode;
-}
-interface CTEBuilderProps {
-    readonly node: CommonTableExpressionNode;
-}
-export type CTEBuilderCallback<N extends string> = (cte: <N2 extends string>(name: N2) => CTEBuilder<N2>) => CTEBuilder<N>;
-export {};