kysely 0.25.0 → 0.26.1

package/dist/cjs/query-builder/select-query-builder.d.ts

@@ -19,7 +19,6 @@ import { HavingExpressionFactory, HavingInterface } from './having-interface.js'
 import { Explainable, ExplainFormat } from '../util/explainable.js';
 import { AliasedExpression, Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
-import { ExistsExpression } from '../parser/unary-operation-parser.js';
 import { KyselyTypeError } from '../util/type-error.js';
 import { Selectable } from '../util/column-type.js';
 import { Streamable } from '../util/streamable.js';
@@ -53,6 +52,10 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *
      * ### Examples
      *
+     * <!-- siteExample("where", "Simple where clause", 10) -->
+     *
+     * `where` method calls are combined with `AND`:
+     *
      * ```ts
      * const person = await db
      *   .selectFrom('person')
@@ -75,9 +78,71 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * sql`your operator`
      * ```
      *
+     * <!-- siteExample("where", "Where in", 20) -->
+     *
+     * Find multiple items using a list of identifiers:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .where('id', 'in', ['1', '2', '3'])
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person" where "id" in ($1, $2, $3)
+     * ```
+     *
+     * <!-- siteExample("where", "OR where", 30) -->
+     *
+     * To combine conditions using `OR`, you can use the expression builder.
+     * There are two ways to create `OR` expressions. Both are shown in this
+     * example:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   // 1. Using the `or` method on the expression builder:
+     *   .where((eb) => eb.or([
+     *     eb('first_name', '=', 'Jennifer'),
+     *     eb('first_name', '=', 'Sylvester')
+     *   ]))
+     *   // 2. Chaining expressions using the `or` method on the
+     *   // created expressions:
+     *   .where((eb) =>
+     *     eb('last_name', '=', 'Aniston').or('last_name', '=', 'Stallone')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * where (
+     *   ("first_name" = $1 or "first_name" = $2)
+     *   and
+     *   ("last_name" = $3 or "last_name" = $4)
+     * )
+     * ```
+     *
+     * <!-- siteExample("where", "Conditional where calls", 40) -->
+     *
      * You can add expressions conditionally like this:
      *
      * ```ts
+     * import { Expression, SqlBool } from 'kysely'
+     *
+     * const firstName: string | undefined = 'Jennifer'
+     * const lastName: string | undefined = 'Aniston'
+     * const under18 = true
+     * const over60 = true
+     *
      * let query = db
      *   .selectFrom('person')
      *   .selectAll()
@@ -92,6 +157,23 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   query = query.where('last_name', '=', lastName)
      * }
      *
+     * if (under18 || over60) {
+     *   // Conditional OR expressions can be added like this.
+     *   query = query.where((eb) => {
+     *     const ors: Expression<SqlBool>[] = []
+     *
+     *     if (under18) {
+     *       ors.push(eb('age', '<', 18))
+     *     }
+     *
+     *     if (over60) {
+     *       ors.push(eb('age', '>', 60))
+     *     }
+     *
+     *     return eb.or(ors)
+     *   })
+     * }
+     *
      * const persons = await query.execute()
      * ```
      *
@@ -144,22 +226,30 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
+     * <!-- siteExample("where", "Complex where clause", 50) -->
+     *
      * For complex `where` expressions you can pass in a single callback and
-     * use the {@link ExpressionBuilder} to build your expression:
+     * use the `ExpressionBuilder` to build your expression:
      *
      * ```ts
+     * const firstName = 'Jennifer'
+     * const maxAge = 60
+     *
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll('person')
-     *   .where(({ cmpr, or, and, not, exists, selectFrom, val }) => and([
+     *   .where(({ eb, or, and, not, exists, selectFrom }) => and([
      *     or([
-     *       cmpr('first_name', '=', firstName),
-     *       cmpr('age', '<', maxAge)
+     *       eb('first_name', '=', firstName),
+     *       eb('age', '<', maxAge)
      *     ]),
      *     not(exists(
-     *       selectFrom('pet').select('pet.id').whereRef('pet.owner_id', '=', 'person.id')
+     *       selectFrom('pet')
+     *         .select('pet.id')
+     *         .whereRef('pet.owner_id', '=', 'person.id')
      *     ))
      *   ]))
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
@@ -280,32 +370,6 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * from "person"
      */
     whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): SelectQueryBuilder<DB, TB, O>;
-    orWhere(factory: WhereExpressionFactory<DB, TB>): SelectQueryBuilder<DB, TB, O>;
-    orWhere(expression: Expression<any>): SelectQueryBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    whereExists(arg: ExistsExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    whereNotExists(arg: ExistsExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orWhereExists(arg: ExistsExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orWhereNotExists(arg: ExistsExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Just like {@link WhereInterface.where | where} but adds a `having` statement
      * instead of a `where` statement.
@@ -318,36 +382,6 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * instead of a `where` statement.
      */
     havingRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orHaving<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): SelectQueryBuilder<DB, TB, O>;
-    orHaving(factory: HavingExpressionFactory<DB, TB>): SelectQueryBuilder<DB, TB, O>;
-    orHaving(expression: Expression<any>): SelectQueryBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orHavingRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    havingExists(arg: ExistsExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
-    /**
-     * @deprecated Use {@link havingNotExists} instead.
-     */
-    havingNotExist(arg: ExistsExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    havingNotExists(arg: ExistsExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orHavingExists(arg: ExistsExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
-    /**
-     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
-     */
-    orHavingNotExists(arg: ExistsExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds a select statement to the query.
      *
@@ -372,6 +406,8 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *
      * ### Examples
      *
+     * <!-- siteExample("select", "A single column", 10) -->
+     *
      * Select a single column:
      *
      * ```ts
@@ -380,8 +416,6 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .select('id')
      *   .where('first_name', '=', 'Arnold')
      *   .execute()
-     *
-     * persons[0].id
      * ```
      *
      * The generated SQL (PostgreSQL):
@@ -390,6 +424,8 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select "id" from "person" where "first_name" = $1
      * ```
      *
+     * <!-- siteExample("select", "Column with a table", 20) -->
+     *
      * Select a single column and specify a table:
      *
      * ```ts
@@ -397,8 +433,6 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .selectFrom(['person', 'pet'])
      *   .select('person.id')
      *   .execute()
-     *
-     * persons[0].id
      * ```
      *
      * The generated SQL (PostgreSQL):
@@ -407,6 +441,8 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select "person"."id" from "person", "pet"
      * ```
      *
+     * <!-- siteExample("select", "Multiple columns", 30) -->
+     *
      * Select multiple columns:
      *
      * ```ts
@@ -414,9 +450,6 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .selectFrom('person')
      *   .select(['person.id', 'first_name'])
      *   .execute()
-     *
-     * persons[0].id
-     * persons[0].first_name
      * ```
      *
      * The generated SQL (PostgreSQL):
@@ -425,38 +458,39 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select "person"."id", "first_name" from "person"
      * ```
      *
-     * Aliased selections:
+     * <!-- siteExample("select", "Aliases", 40) -->
+     *
+     * You can provide an alias for the selections by appending `as the_alias` to the selection.
      *
      * ```ts
      * const persons = await db
      *   .selectFrom('person')
      *   .select([
-     *     'person.first_name as fn',
+     *     'first_name as fn',
      *     'person.last_name as ln'
      *   ])
      *   .execute()
-     *
-     * persons[0].fn
-     * persons[0].ln
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
      * select
-     *   "person"."first_name" as "fn",
+     *   "first_name" as "fn",
      *   "person"."last_name" as "ln"
      * from "person"
      * ```
      *
-     * You can also select arbitrary expression including subqueries and raw sql snippets.
-     * When you do that, you need to give a name for the selections using the {@link as} method:
+     * <!-- siteExample("select", "Complex selections", 50) -->
+     *
+     * You can select arbitrary expression including subqueries and raw sql snippets.
+     * When you do that, you need to give a name for the selections using the `as` method:
      *
      * ```ts
-     * import { sql } from 'kysely'
+     * import { sql } from 'kysely'
      *
      * const persons = await db.selectFrom('person')
-     *   .select(({ selectFrom, or, cmpr }) => [
+     *   .select(({ eb, selectFrom, or }) => [
      *     // Select a correlated subquery
      *     selectFrom('pet')
      *       .whereRef('person.id', '=', 'pet.owner_id')
@@ -465,20 +499,17 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *       .limit(1)
      *       .as('first_pet_name'),
      *
-     *     // Build and select an expression using the expression builder
+     *     // Build and select an expression using
+     *     // the expression builder
      *     or([
-     *       cmpr('first_name', '=', 'Jennifer'),
-     *       cmpr('first_name', '=', 'Arnold')
+     *       eb('first_name', '=', 'Jennifer'),
+     *       eb('first_name', '=', 'Arnold')
      *     ]).as('is_jennifer_or_arnold'),
      *
      *     // Select a raw sql expression
      *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
      *   ])
      *   .execute()
-     *
-     * persons[0].first_pet_name
-     * persons[0].is_jennifer_or_arnold
-     * persons[0].full_name
      * ```
      *
      * The generated SQL (PostgreSQL):
@@ -543,8 +574,10 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *
      * ### Examples
      *
+     * <!-- siteExample("select", "Distinct on", 80) -->
+     *
      * ```ts
-     * await db.selectFrom('person')
+     * const persons = await db.selectFrom('person')
      *   .innerJoin('pet', 'pet.owner_id', 'person.id')
      *   .where('pet.name', '=', 'Doggo')
      *   .distinctOn('person.id')
@@ -610,10 +643,12 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
     /**
      * Makes the selection distinct.
      *
+     * <!-- siteExample("select", "Distinct", 70) -->
+     *
      * ### Examples
      *
      * ```ts
-     * await db.selectFrom('person')
+     * const persons = await db.selectFrom('person')
      *   .select('first_name')
      *   .distinct()
      *   .execute()
@@ -655,6 +690,10 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *
      * ### Examples
      *
+     * <!-- siteExample("select", "All columns", 90) -->
+     *
+     * The `selectAll` method generates `SELECT *`:
+     *
      * ```ts
      * const persons = await db
      *   .selectFrom('person')
@@ -668,6 +707,8 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person"
      * ```
      *
+     * <!-- siteExample("select", "All columns of a table", 100) -->
+     *
      * Select all columns of a table:
      *
      * ```ts
@@ -699,14 +740,16 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      */
     selectAll<T extends TB>(table: ReadonlyArray<T>): SelectQueryBuilder<DB, TB, O & AllSelection<DB, T>>;
-    selectAll<T extends TB>(table: T): SelectQueryBuilder<DB, TB, Selectable<DB[T]>>;
+    selectAll<T extends TB>(table: T): SelectQueryBuilder<DB, TB, O & Selectable<DB[T]>>;
     selectAll(): SelectQueryBuilder<DB, TB, O & AllSelection<DB, TB>>;
     /**
      * Joins another table to the query using an inner join.
      *
      * ### Examples
      *
-     * Simple usage by providing a table name and two columns to join:
+     * <!-- siteExample("join", "Simple inner join", 10) -->
+     *
+     * Simple inner joins can be done by providing a table name and two columns to join:
      *
      * ```ts
      * const result = await db
@@ -714,22 +757,21 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .innerJoin('pet', 'pet.owner_id', 'person.id')
      *   // `select` needs to come after the call to `innerJoin` so
      *   // that you can select from the joined table.
-     *   .select('person.id', 'pet.name')
+     *   .select(['person.id', 'pet.name as pet_name'])
      *   .execute()
-     *
-     * result[0].id
-     * result[0].name
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select "person"."id", "pet"."name"
+     * select "person"."id", "pet"."name" as "pet_name"
      * from "person"
      * inner join "pet"
      * on "pet"."owner_id" = "person"."id"
      * ```
      *
+     * <!-- siteExample("join", "Aliased inner join", 20) -->
+     *
      * You can give an alias for the joined table like this:
      *
      * ```ts
@@ -750,13 +792,15 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * where "p".name" = $1
      * ```
      *
+     * <!-- siteExample("join", "Complex join", 30) -->
+     *
      * You can provide a function as the second argument to get a join
      * builder for creating more complex joins. The join builder has a
      * bunch of `on*` methods for building the `on` clause of the join.
      * There's basically an equivalent for every `where` method
-     * (`on`, `onRef`, `onExists` etc.). You can do all the same things
-     * with the `on` method that you can with the corresponding `where`
-     * method. See the `where` method documentation for more examples.
+     * (`on`, `onRef` etc.). You can do all the same things with the
+     * `on` method that you can with the corresponding `where` method.
+     * See the `where` method documentation for more examples.
      *
      * ```ts
      * await db.selectFrom('person')
@@ -780,34 +824,36 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * and "pet"."name" = $1
      * ```
      *
-     * You can join a subquery by providing a select query (or a callback)
-     * as the first argument:
+     * <!-- siteExample("join", "Subquery join", 40) -->
+     *
+     * You can join a subquery by providing two callbacks:
      *
      * ```ts
-     * await db.selectFrom('person')
+     * const result = await db.selectFrom('person')
      *   .innerJoin(
-     *     db.selectFrom('pet')
-     *       .select(['owner_id', 'name'])
+     *     (eb) => eb
+     *       .selectFrom('pet')
+     *       .select(['owner_id as owner', 'name'])
      *       .where('name', '=', 'Doggo')
      *       .as('doggos'),
-     *     'doggos.owner_id',
-     *     'person.id',
+     *     (join) => join
+     *       .onRef('doggos.owner', '=', 'person.id'),
      *   )
-     *   .selectAll()
+     *   .selectAll('doggos')
      *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select *
+     * select "doggos".*
      * from "person"
      * inner join (
-     *   select "owner_id", "name"
+     *   select "owner_id" as "owner", "name"
      *   from "pet"
      *   where "name" = $1
      * ) as "doggos"
-     * on "doggos"."owner_id" = "person"."id"
+     * on "doggos"."owner" = "person"."id"
      * ```
      */
     innerJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>;
@@ -1326,10 +1372,6 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      */
     $call<T>(func: (qb: this) => T): T;
-    /**
-     * @deprecated Use `$call` instead
-     */
-    call<T>(func: (qb: this) => T): T;
     /**
      * Call `func(this)` if `condition` is true.
      *
@@ -1385,23 +1427,17 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * You can also call any other methods inside the callback:
      *
      * ```ts
-     * const { count } = db.fn
-     *
      * db.selectFrom('person')
      *   .select('person.id')
      *   .$if(filterByFirstName, (qb) => qb.where('first_name', '=', firstName))
      *   .$if(filterByPetCount, (qb) => qb
      *     .innerJoin('pet', 'pet.owner_id', 'person.id')
-     *     .having(count('pet.id'), '>', petCountLimit)
+     *     .having((eb) => eb.fn.count('pet.id'), '>', petCountLimit)
      *     .groupBy('person.id')
      *   )
      * ```
      */
-    $if<O2>(condition: boolean, func: (qb: this) => SelectQueryBuilder<DB, TB, O & O2>): SelectQueryBuilder<DB, TB, O & Partial<O2>>;
-    /**
-     * @deprecated Use `$if` instead
-     */
-    if<O2>(condition: boolean, func: (qb: this) => SelectQueryBuilder<DB, TB, O & O2>): SelectQueryBuilder<DB, TB, O & Partial<O2>>;
+    $if<O2>(condition: boolean, func: (qb: this) => SelectQueryBuilder<any, any, O & O2>): SelectQueryBuilder<DB, TB, O & Partial<O2>>;
     /**
      * Change the output type of the query.
      *
@@ -1409,10 +1445,6 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * don't support your use case.
      */
     $castTo<T>(): SelectQueryBuilder<DB, TB, T>;
-    /**
-     * @deprecated Use `$castTo` instead.
-     */
-    castTo<T>(): SelectQueryBuilder<DB, TB, T>;
     /**
      * Narrows (parts of) the output type of the query.
      *
@@ -1494,10 +1526,6 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      */
     $assertType<T extends O>(): O extends T ? SelectQueryBuilder<DB, TB, T> : KyselyTypeError<`$assertType() call failed: The type passed in is not equal to the output type of the query.`>;
-    /**
-     * @deprecated Use `$assertType` instead.
-     */
-    assertType<T extends O>(): O extends T ? SelectQueryBuilder<DB, TB, T> : KyselyTypeError<`assertType() call failed: The type passed in is not equal to the output type of the query.`>;
     /**
      * Returns a copy of this SelectQueryBuilder instance with the given plugin installed.
      */
@@ -1628,24 +1656,24 @@ export declare class AliasedSelectQueryBuilder<DB, TB extends keyof DB, O = unde
      */
     toOperationNode(): AliasNode;
 }
-export declare type SelectQueryBuilderWithInnerJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? InnerJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? SelectQueryBuilder<DB, TB | TE, O> : TE extends AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : never;
-declare type InnerJoinedBuilder<DB, TB extends keyof DB, O, A extends string, R> = A extends keyof DB ? SelectQueryBuilder<InnerJoinedDB<DB, A, R>, TB | A, O> : SelectQueryBuilder<DB & ShallowRecord<A, R>, TB | A, O>;
-declare type InnerJoinedDB<DB, A extends string, R> = DrainOuterGeneric<{
+export type SelectQueryBuilderWithInnerJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? InnerJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? SelectQueryBuilder<DB, TB | TE, O> : TE extends AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : never;
+type InnerJoinedBuilder<DB, TB extends keyof DB, O, A extends string, R> = A extends keyof DB ? SelectQueryBuilder<InnerJoinedDB<DB, A, R>, TB | A, O> : SelectQueryBuilder<DB & ShallowRecord<A, R>, TB | A, O>;
+type InnerJoinedDB<DB, A extends string, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? R : C extends keyof DB ? DB[C] : never;
 }>;
-export declare type SelectQueryBuilderWithLeftJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? LeftJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? LeftJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : never;
-declare type LeftJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = A extends keyof DB ? SelectQueryBuilder<LeftJoinedDB<DB, A, R>, TB | A, O> : SelectQueryBuilder<DB & ShallowRecord<A, Nullable<R>>, TB | A, O>;
-declare type LeftJoinedDB<DB, A extends keyof any, R> = DrainOuterGeneric<{
+export type SelectQueryBuilderWithLeftJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? LeftJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? LeftJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : never;
+type LeftJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = A extends keyof DB ? SelectQueryBuilder<LeftJoinedDB<DB, A, R>, TB | A, O> : SelectQueryBuilder<DB & ShallowRecord<A, Nullable<R>>, TB | A, O>;
+type LeftJoinedDB<DB, A extends keyof any, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? Nullable<R> : C extends keyof DB ? DB[C] : never;
 }>;
-export declare type SelectQueryBuilderWithRightJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? RightJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? RightJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : never;
-declare type RightJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = SelectQueryBuilder<RightJoinedDB<DB, TB, A, R>, TB | A, O>;
-declare type RightJoinedDB<DB, TB extends keyof DB, A extends keyof any, R> = DrainOuterGeneric<{
+export type SelectQueryBuilderWithRightJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? RightJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? RightJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : never;
+type RightJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = SelectQueryBuilder<RightJoinedDB<DB, TB, A, R>, TB | A, O>;
+type RightJoinedDB<DB, TB extends keyof DB, A extends keyof any, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? R : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;
 }>;
-export declare type SelectQueryBuilderWithFullJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? OuterJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? OuterJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : never;
-declare type OuterJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = SelectQueryBuilder<OuterJoinedBuilderDB<DB, TB, A, R>, TB | A, O>;
-declare type OuterJoinedBuilderDB<DB, TB extends keyof DB, A extends keyof any, R> = DrainOuterGeneric<{
+export type SelectQueryBuilderWithFullJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? OuterJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? OuterJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : never;
+type OuterJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = SelectQueryBuilder<OuterJoinedBuilderDB<DB, TB, A, R>, TB | A, O>;
+type OuterJoinedBuilderDB<DB, TB extends keyof DB, A extends keyof any, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? Nullable<R> : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;
 }>;
 export {};