drizzle-orm 0.27.3-e080bed → 0.28.0-5dd9190

package/{db.d-2e828d8c.d.ts → select.types.d-570dd25a.d.ts}

@@ -1,329 +1,114 @@
-import { a as SQL, e as entityKind, ap as TableConfig$1, T as Table, aq as UpdateTableConfig, v as BuildColumns, o as ColumnBuilderHKTBase, aD as Assume, l as ColumnBuilderBaseConfig, c as ColumnHKTBase, C as ColumnBaseConfig, s as ColumnBuilder, aA as Update, f as ColumnHKT, g as Column, r as ColumnBuilderRuntimeConfig, aQ as ColumnsSelection, am as Subquery, an as WithSubquery, aG as ValueOrArray, ai as Placeholder, S as Simplify, Q as Query, V as View, K as SelectedFieldsFlat$1, X as SelectedFields$1, Y as SelectedFieldsOrdered$1, a1 as SQLWrapper, I as InferModel, ay as UpdateSet, G as GetColumnData, ae as Param, aN as KnownKeysOnly, aF as DrizzleTypeError } from './column.d-9d74a4f3.js';
-import { A as AddAliasToSelection, G as GetSelectTableName, a as GetSelectTableSelection, S as SelectMode, J as JoinNullability, T as TypedQueryBuilder, B as BuildSubquerySelection, b as SelectResult, c as JoinType, M as MapColumnsToTableAlias, d as AppendToResult, e as AppendToNullabilityMap, f as SelectResultFields } from './select.types.d-1ea8ee3b.js';
-import { T as TablesRelationalConfig, K as TableRelationalConfig, J as DBQueryConfig, a as Relation, a2 as BuildRelationalQueryResult, U as BuildQueryResult, Q as QueryPromise, L as ExtractTablesWithRelations, R as RelationalSchemaConfig } from './query-promise.d-fd15f63a.js';
+import { e as entityKind, aM as AnySQLiteTable, aF as KnownKeysOnly, aJ as ColumnsSelection, ah as Subquery, ai as WithSubquery, ax as DrizzleTypeError, X as SQLWrapper, Q as Query, a as SQL, aq as UpdateSet, aS as SQLiteTable, aL as SQLiteColumn, I as InferModel, G as GetColumnData, a9 as Param, S as Simplify, ad as Placeholder, b0 as IndexColumn, ay as ValueOrArray, aK as SQLiteColumnBuilder, o as BuildColumns, V as View, T as Table, b9 as SQLiteTableWithColumns, al as UpdateTableConfig, av as Assume, y as SelectedFieldsFlat$1, E as SelectedFields$1, F as SelectedFieldsOrdered$1 } from './column.d-9d2f4045.js';
+import { A as AddAliasToSelection, T as TypedQueryBuilder, f as SelectResultFields, G as GetSelectTableName, a as GetSelectTableSelection, S as SelectMode, J as JoinNullability, B as BuildSubquerySelection, b as SelectResult, c as JoinType, M as MapColumnsToTableAlias, d as AppendToResult, e as AppendToNullabilityMap } from './select.types.d-a3c4c974.js';
 import { MigrationMeta } from './migrator.js';
+import { T as TablesRelationalConfig, L as TableRelationalConfig, K as DBQueryConfig, V as BuildQueryResult, Q as QueryPromise, N as ExtractTablesWithRelations, R as RelationalSchemaConfig, a as Relation, a3 as BuildRelationalQueryResult } from './query-promise.d-bc96befc.js';
 
-declare class CheckBuilder {
-    name: string;
-    value: SQL;
-    static readonly [entityKind]: string;
-    protected brand: 'SQLiteConstraintBuilder';
-    constructor(name: string, value: SQL);
-    build(table: AnySQLiteTable): Check;
-}
-declare class Check {
-    table: AnySQLiteTable;
-    static readonly [entityKind]: string;
-    _: {
-        brand: 'SQLiteCheck';
-    };
-    readonly name: string;
-    readonly value: SQL;
-    constructor(table: AnySQLiteTable, builder: CheckBuilder);
-}
-declare function check(name: string, value: SQL): CheckBuilder;
-
-interface IndexConfig {
-    name: string;
-    columns: IndexColumn[];
-    unique: boolean;
-    where: SQL | undefined;
-}
-type IndexColumn = AnySQLiteColumn | SQL;
-declare class IndexBuilderOn {
-    private name;
-    private unique;
-    static readonly [entityKind]: string;
-    constructor(name: string, unique: boolean);
-    on(...columns: [IndexColumn, ...IndexColumn[]]): IndexBuilder;
-}
-declare class IndexBuilder {
+declare class AsyncRelationalQueryBuilder<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig> {
+    private fullSchema;
+    private schema;
+    private tableNamesMap;
+    private table;
+    private tableConfig;
+    private dialect;
+    private session;
     static readonly [entityKind]: string;
-    _: {
-        brand: 'SQLiteIndexBuilder';
-    };
-    constructor(name: string, columns: IndexColumn[], unique: boolean);
-    /**
-     * Condition for partial index.
-     */
-    where(condition: SQL): this;
+    constructor(fullSchema: Record<string, unknown>, schema: TSchema, tableNamesMap: Record<string, string>, table: AnySQLiteTable, tableConfig: TableRelationalConfig, dialect: SQLiteDialect, session: SQLiteSession<'async', unknown, TFullSchema, TSchema>);
+    findMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>): SQLiteAsyncRelationalQuery<BuildQueryResult<TSchema, TFields, TConfig>[]>;
+    findFirst<TSelection extends Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>): SQLiteAsyncRelationalQuery<BuildQueryResult<TSchema, TFields, TSelection> | undefined>;
 }
-declare class Index {
+declare class SyncRelationalQueryBuilder<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig> {
+    private fullSchema;
+    private schema;
+    private tableNamesMap;
+    private table;
+    private tableConfig;
+    private dialect;
+    private session;
     static readonly [entityKind]: string;
-    _: {
-        brand: 'SQLiteIndex';
-    };
-    readonly config: IndexConfig & {
-        table: AnySQLiteTable;
+    constructor(fullSchema: Record<string, unknown>, schema: TSchema, tableNamesMap: Record<string, string>, table: AnySQLiteTable, tableConfig: TableRelationalConfig, dialect: SQLiteDialect, session: SQLiteSession<'sync', unknown, TFullSchema, TSchema>);
+    prepareFindMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>): {
+        execute: PreparedQuery<PreparedQueryConfig & {
+            type: 'sync';
+            all: BuildQueryResult<TSchema, TFields, TConfig>[];
+        }>['all'];
     };
-    constructor(config: IndexConfig, table: AnySQLiteTable);
-}
-declare function index(name: string): IndexBuilderOn;
-declare function uniqueIndex(name: string): IndexBuilderOn;
-
-declare function primaryKey<TTableName extends string, TColumns extends AnySQLiteColumn<{
-    tableName: TTableName;
-}>[]>(...columns: TColumns): PrimaryKeyBuilder;
-declare class PrimaryKeyBuilder {
-    static readonly [entityKind]: string;
-    _: {
-        brand: 'SQLitePrimaryKeyBuilder';
+    findMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>): BuildQueryResult<TSchema, TFields, TConfig>[];
+    prepareFindFirst<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>): {
+        execute: PreparedQuery<PreparedQueryConfig & {
+            type: 'sync';
+            get: BuildQueryResult<TSchema, TFields, TConfig> | undefined;
+        }>['get'];
     };
-    constructor(columns: AnySQLiteColumn[]);
-}
-declare class PrimaryKey {
-    readonly table: AnySQLiteTable;
-    static readonly [entityKind]: string;
-    readonly columns: AnySQLiteColumn<{}>[];
-    constructor(table: AnySQLiteTable, columns: AnySQLiteColumn<{}>[]);
-    getName(): string;
-}
-
-declare function uniqueKeyName(table: AnySQLiteTable, columns: string[]): string;
-declare function unique(name?: string): UniqueOnConstraintBuilder;
-declare class UniqueConstraintBuilder {
-    private name?;
-    static readonly [entityKind]: string;
-    constructor(columns: AnySQLiteColumn[], name?: string | undefined);
-}
-declare class UniqueOnConstraintBuilder {
-    static readonly [entityKind]: string;
-    constructor(name?: string);
-    on(...columns: [AnySQLiteColumn, ...AnySQLiteColumn[]]): UniqueConstraintBuilder;
-}
-declare class UniqueConstraint {
-    readonly table: AnySQLiteTable;
-    static readonly [entityKind]: string;
-    readonly columns: AnySQLiteColumn<{}>[];
-    readonly name?: string;
-    constructor(table: AnySQLiteTable, columns: AnySQLiteColumn<{}>[], name?: string);
-    getName(): string | undefined;
-}
-
-type SQLiteTableExtraConfig = Record<string, IndexBuilder | CheckBuilder | ForeignKeyBuilder | PrimaryKeyBuilder | UniqueConstraintBuilder>;
-type TableConfig = TableConfig$1<AnySQLiteColumn>;
-declare class SQLiteTable<T extends TableConfig> extends Table<T> {
-    static readonly [entityKind]: string;
-}
-type AnySQLiteTable<TPartial extends Partial<TableConfig> = {}> = SQLiteTable<UpdateTableConfig<TableConfig, TPartial>>;
-type SQLiteTableWithColumns<T extends TableConfig> = SQLiteTable<T> & {
-    [Key in keyof T['columns']]: T['columns'][Key];
-};
-interface SQLiteTableFn<TSchema extends string | undefined = undefined> {
-    <TTableName extends string, TColumnsMap extends Record<string, AnySQLiteColumnBuilder>>(name: TTableName, columns: TColumnsMap, extraConfig?: (self: BuildColumns<TTableName, TColumnsMap>) => SQLiteTableExtraConfig): SQLiteTableWithColumns<{
-        name: TTableName;
-        schema: TSchema;
-        columns: BuildColumns<TTableName, TColumnsMap>;
-    }>;
+    findFirst<TSelection extends Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>): BuildQueryResult<TSchema, TFields, TSelection> | undefined;
 }
-declare const sqliteTable: SQLiteTableFn;
-declare function sqliteTableCreator(customizeTableName: (name: string) => string): SQLiteTableFn;
-
-type UpdateDeleteAction = 'cascade' | 'restrict' | 'no action' | 'set null' | 'set default';
-type Reference = () => {
-    readonly columns: AnySQLiteColumn[];
-    readonly foreignTable: AnySQLiteTable;
-    readonly foreignColumns: AnySQLiteColumn[];
-};
-declare class ForeignKeyBuilder {
-    static readonly [entityKind]: string;
-    _: {
-        brand: 'SQLiteForeignKeyBuilder';
-        foreignTableName: 'TForeignTableName';
-    };
-    constructor(config: () => {
-        columns: AnySQLiteColumn[];
-        foreignColumns: AnySQLiteColumn[];
-    }, actions?: {
-        onUpdate?: UpdateDeleteAction;
-        onDelete?: UpdateDeleteAction;
-    } | undefined);
-    onUpdate(action: UpdateDeleteAction): this;
-    onDelete(action: UpdateDeleteAction): this;
-}
-declare class ForeignKey {
-    readonly table: AnySQLiteTable;
+declare class SQLiteRelationalQuery<TResultKind extends 'sync' | 'async', TResult> {
+    private fullSchema;
+    private schema;
+    private tableNamesMap;
+    private table;
+    private tableConfig;
+    private dialect;
+    private session;
+    private config;
+    private mode;
     static readonly [entityKind]: string;
-    readonly reference: Reference;
-    readonly onUpdate: UpdateDeleteAction | undefined;
-    readonly onDelete: UpdateDeleteAction | undefined;
-    constructor(table: AnySQLiteTable, builder: ForeignKeyBuilder);
-    getName(): string;
-}
-type ColumnsWithTable<TTableName extends string, TColumns extends AnySQLiteColumn[]> = {
-    [Key in keyof TColumns]: AnySQLiteColumn<{
-        tableName: TTableName;
+    protected $brand: 'SQLiteRelationalQuery';
+    constructor(fullSchema: Record<string, unknown>, schema: TablesRelationalConfig, tableNamesMap: Record<string, string>, table: AnySQLiteTable, tableConfig: TableRelationalConfig, dialect: SQLiteDialect, session: SQLiteSession<TResultKind, unknown, Record<string, unknown>, TablesRelationalConfig>, config: DBQueryConfig<'many', true> | true, mode: 'many' | 'first');
+    prepare(): PreparedQuery<PreparedQueryConfig & {
+        type: TResultKind;
+        all: TResult;
+        get: TResult;
     }>;
-};
-declare function foreignKey<TTableName extends string, TForeignTableName extends string, TColumns extends [AnySQLiteColumn<{
-    tableName: TTableName;
-}>, ...AnySQLiteColumn<{
-    tableName: TTableName;
-}>[]]>(config: () => {
-    columns: TColumns;
-    foreignColumns: ColumnsWithTable<TForeignTableName, TColumns>;
-}): ForeignKeyBuilder;
-
-interface ReferenceConfig {
-    ref: () => AnySQLiteColumn;
-    actions: {
-        onUpdate?: UpdateDeleteAction;
-        onDelete?: UpdateDeleteAction;
-    };
-}
-interface SQLiteColumnBuilderHKT extends ColumnBuilderHKTBase {
-    _type: SQLiteColumnBuilder<SQLiteColumnBuilderHKT, Assume<this['config'], ColumnBuilderBaseConfig>>;
-    _columnHKT: SQLiteColumnHKT;
-}
-interface SQLiteColumnHKT extends ColumnHKTBase {
-    _type: SQLiteColumn<SQLiteColumnHKT, Assume<this['config'], ColumnBaseConfig>>;
-}
-declare abstract class SQLiteColumnBuilder<THKT extends ColumnBuilderHKTBase, T extends ColumnBuilderBaseConfig, TRuntimeConfig extends object = {}, TTypeConfig extends object = {}> extends ColumnBuilder<THKT, T, TRuntimeConfig, TTypeConfig & {
-    sqliteBrand: 'SQLiteColumnBuilder';
-}> {
-    static readonly [entityKind]: string;
-    private foreignKeyConfigs;
-    references(ref: ReferenceConfig['ref'], actions?: ReferenceConfig['actions']): this;
-    unique(name?: string): this;
+    execute(): Result<TResultKind, TResult>;
 }
-type AnySQLiteColumnBuilder<TPartial extends Partial<ColumnBuilderBaseConfig> = {}> = SQLiteColumnBuilder<SQLiteColumnBuilderHKT, Required<Update<ColumnBuilderBaseConfig, TPartial>>>;
-declare abstract class SQLiteColumn<THKT extends ColumnHKT, T extends ColumnBaseConfig, TRuntimeConfig extends object = {}> extends Column<THKT, T, TRuntimeConfig, {
-    sqliteBrand: 'SQLiteColumn';
-}> {
-    readonly table: AnySQLiteTable;
-    static readonly [entityKind]: string;
-    constructor(table: AnySQLiteTable, config: ColumnBuilderRuntimeConfig<T['data']> & TRuntimeConfig);
+interface SQLiteAsyncRelationalQuery<TResult> extends SQLiteRelationalQuery<'async', TResult>, QueryPromise<TResult> {
 }
-type AnySQLiteColumn<TPartial extends Partial<ColumnBaseConfig> = {}> = SQLiteColumn<SQLiteColumnHKT, Required<Update<ColumnBaseConfig, TPartial>>>;
 
-type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = Subquery<TAlias, AddAliasToSelection<TSelection, TAlias>> & AddAliasToSelection<TSelection, TAlias>;
-type WithSubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias>> & AddAliasToSelection<TSelection, TAlias>;
+type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'sqlite'>> & AddAliasToSelection<TSelection, TAlias, 'sqlite'>;
+type WithSubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'sqlite'>> & AddAliasToSelection<TSelection, TAlias, 'sqlite'>;
 
-type CreateSQLiteSelectFromBuilderMode<TBuilderMode extends 'db' | 'qb', TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection extends ColumnsSelection, TSelectMode extends SelectMode> = TBuilderMode extends 'db' ? SQLiteSelect<TTableName, TResultType, TRunResult, TSelection, TSelectMode> : SQLiteSelectQueryBuilder<SQLiteSelectQueryBuilderHKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode>;
-declare class SQLiteSelectBuilder<TSelection extends SelectedFields | undefined, TResultType extends 'sync' | 'async', TRunResult, TBuilderMode extends 'db' | 'qb' = 'db'> {
-    static readonly [entityKind]: string;
-    private fields;
-    private session;
-    private dialect;
-    private withList;
-    private distinct;
-    constructor(config: {
-        fields: TSelection;
-        session: SQLiteSession<any, any, any, any> | undefined;
-        dialect: SQLiteDialect;
-        withList?: Subquery[];
-        distinct?: boolean;
-    });
-    from<TFrom extends AnySQLiteTable | Subquery | SQLiteViewBase | SQL>(source: TFrom): CreateSQLiteSelectFromBuilderMode<TBuilderMode, GetSelectTableName<TFrom>, TResultType, TRunResult, TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection, TSelection extends undefined ? 'single' : 'partial'>;
-}
-declare abstract class SQLiteSelectQueryBuilder<THKT extends SQLiteSelectHKTBase, TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection extends ColumnsSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends TypedQueryBuilder<BuildSubquerySelection<TSelection, TNullabilityMap>, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]> {
+declare class BaseSQLiteDatabase<TResultKind extends 'sync' | 'async', TRunResult, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
     static readonly [entityKind]: string;
     readonly _: {
-        readonly selectMode: TSelectMode;
-        readonly selection: TSelection;
-        readonly result: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
-        readonly selectedFields: BuildSubquerySelection<TSelection, TNullabilityMap>;
+        readonly schema: TSchema | undefined;
+        readonly tableNamesMap: Record<string, string>;
     };
-    protected config: SQLiteSelectConfig;
-    protected joinsNotNullableMap: Record<string, boolean>;
-    private tableName;
-    private isPartialSelect;
-    protected session: SQLiteSession<any, any, any, any> | undefined;
-    protected dialect: SQLiteDialect;
-    constructor({ table, fields, isPartialSelect, session, dialect, withList, distinct }: {
-        table: SQLiteSelectConfig['table'];
-        fields: SQLiteSelectConfig['fields'];
-        isPartialSelect: boolean;
-        session: SQLiteSession<any, any, any, any> | undefined;
-        dialect: SQLiteDialect;
-        withList: Subquery[] | undefined;
-        distinct: boolean | undefined;
-    });
-    private createJoin;
-    leftJoin: JoinFn<THKT, TTableName, TResultType, TRunResult, TSelectMode, "left", TSelection, TNullabilityMap>;
-    rightJoin: JoinFn<THKT, TTableName, TResultType, TRunResult, TSelectMode, "right", TSelection, TNullabilityMap>;
-    innerJoin: JoinFn<THKT, TTableName, TResultType, TRunResult, TSelectMode, "inner", TSelection, TNullabilityMap>;
-    fullJoin: JoinFn<THKT, TTableName, TResultType, TRunResult, TSelectMode, "full", TSelection, TNullabilityMap>;
-    where(where: ((aliases: TSelection) => SQL | undefined) | SQL | undefined): this;
-    having(having: ((aliases: TSelection) => SQL | undefined) | SQL | undefined): this;
-    groupBy(builder: (aliases: TSelection) => ValueOrArray<AnySQLiteColumn | SQL | SQL.Aliased>): this;
-    groupBy(...columns: (AnySQLiteColumn | SQL)[]): this;
-    orderBy(builder: (aliases: TSelection) => ValueOrArray<AnySQLiteColumn | SQL | SQL.Aliased>): this;
-    orderBy(...columns: (AnySQLiteColumn | SQL)[]): this;
-    limit(limit: number | Placeholder): this;
-    offset(offset: number | Placeholder): this;
-    toSQL(): Simplify<Omit<Query, 'typings'>>;
-    as<TAlias extends string>(alias: TAlias): SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias>;
-    getSelectedFields(): BuildSubquerySelection<TSelection, TNullabilityMap>;
-}
-interface SQLiteSelect<TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection extends ColumnsSelection, TSelectMode extends SelectMode = 'single', TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends SQLiteSelectQueryBuilder<SQLiteSelectHKT, TTableName | undefined, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
-}
-declare class SQLiteSelect<TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection, TSelectMode extends SelectMode = 'single', TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends SQLiteSelectQueryBuilder<SQLiteSelectHKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
-    static readonly [entityKind]: string;
-    prepare(isOneTimeQuery?: boolean): PreparedQuery<{
-        type: TResultType;
-        run: TRunResult;
-        all: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
-        get: SelectResult<TSelection, TSelectMode, TNullabilityMap>;
-        values: any[][];
-    }>;
-    run: ReturnType<this['prepare']>['run'];
-    all: ReturnType<this['prepare']>['all'];
-    get: ReturnType<this['prepare']>['get'];
-    values: ReturnType<this['prepare']>['values'];
-}
-
-interface Join {
-    on: SQL | undefined;
-    table: AnySQLiteTable | Subquery | SQLiteViewBase | SQL;
-    alias: string | undefined;
-    joinType: JoinType;
-}
-type AnySQLiteSelect = SQLiteSelect<any, any, any, any, any, any>;
-type BuildAliasTable<TTable extends Table | View, TAlias extends string> = TTable extends Table ? SQLiteTableWithColumns<Assume<UpdateTableConfig<TTable['_']['config'], {
-    name: TAlias;
-    columns: MapColumnsToTableAlias<TTable['_']['columns'], TAlias>;
-}>, TableConfig>> : TTable extends View ? SQLiteViewWithSelection<TAlias, TTable['_']['existing'], MapColumnsToTableAlias<TTable['_']['selectedFields'], TAlias>> : never;
-interface SQLiteSelectConfig {
-    withList?: Subquery[];
-    fields: Record<string, unknown>;
-    fieldsFlat?: SelectedFieldsOrdered;
-    where?: SQL;
-    having?: SQL;
-    table: AnySQLiteTable | Subquery | SQLiteViewBase | SQL;
-    limit?: number | Placeholder;
-    offset?: number | Placeholder;
-    joins?: Join[];
-    orderBy?: (AnySQLiteColumn | SQL | SQL.Aliased)[];
-    groupBy?: (AnySQLiteColumn | SQL | SQL.Aliased)[];
-    distinct?: boolean;
-}
-type JoinFn<THKT extends SQLiteSelectHKTBase, TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelectMode extends SelectMode, TJoinType extends JoinType, TSelection, TNullabilityMap extends Record<string, JoinNullability>> = <TJoinedTable extends AnySQLiteTable | Subquery | SQLiteViewBase | SQL, TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>>(table: TJoinedTable, on: ((aliases: TSelection) => SQL | undefined) | SQL | undefined) => SQLiteSelectKind<THKT, TTableName, TResultType, TRunResult, AppendToResult<TTableName, TSelection, TJoinedName, TJoinedTable extends AnySQLiteTable ? TJoinedTable['_']['columns'] : TJoinedTable extends Subquery | View ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields> : never, TSelectMode>, TSelectMode extends 'partial' ? TSelectMode : 'multiple', AppendToNullabilityMap<TNullabilityMap, TJoinedName, TJoinType>>;
-type SelectedFieldsFlat = SelectedFieldsFlat$1<AnySQLiteColumn>;
-type SelectedFields = SelectedFields$1<AnySQLiteColumn, AnySQLiteTable>;
-type SelectedFieldsOrdered = SelectedFieldsOrdered$1<AnySQLiteColumn>;
-interface SQLiteSelectHKTBase {
-    tableName: string | undefined;
-    resultType: 'sync' | 'async';
-    runResult: unknown;
-    selection: unknown;
-    selectMode: SelectMode;
-    nullabilityMap: unknown;
-    _type: unknown;
-}
-type SQLiteSelectKind<T extends SQLiteSelectHKTBase, TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability>> = (T & {
-    tableName: TTableName;
-    resultType: TResultType;
-    runResult: TRunResult;
-    selection: TSelection;
-    selectMode: TSelectMode;
-    nullabilityMap: TNullabilityMap;
-})['_type'];
-interface SQLiteSelectQueryBuilderHKT extends SQLiteSelectHKTBase {
-    _type: SQLiteSelectQueryBuilder<this, this['tableName'], this['resultType'], this['runResult'], Assume<this['selection'], ColumnsSelection>, this['selectMode'], Assume<this['nullabilityMap'], Record<string, JoinNullability>>>;
-}
-interface SQLiteSelectHKT extends SQLiteSelectHKTBase {
-    _type: SQLiteSelect<this['tableName'], this['resultType'], this['runResult'], Assume<this['selection'], ColumnsSelection>, this['selectMode'], Assume<this['nullabilityMap'], Record<string, JoinNullability>>>;
+    query: TFullSchema extends Record<string, never> ? DrizzleTypeError<'Seems like the schema generic is missing - did you forget to add it to your DB type?'> : {
+        [K in keyof TSchema]: TResultKind extends 'async' ? AsyncRelationalQueryBuilder<TFullSchema, TSchema, TSchema[K]> : SyncRelationalQueryBuilder<TFullSchema, TSchema, TSchema[K]>;
+    };
+    constructor(resultKind: TResultKind, 
+    /** @internal */
+    dialect: {
+        sync: SQLiteSyncDialect;
+        async: SQLiteAsyncDialect;
+    }[TResultKind], 
+    /** @internal */
+    session: SQLiteSession<TResultKind, TRunResult, TFullSchema, TSchema>, schema: RelationalSchemaConfig<TSchema> | undefined);
+    $with<TAlias extends string>(alias: TAlias): {
+        as<TSelection extends ColumnsSelection>(qb: TypedQueryBuilder<TSelection, unknown> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection, unknown>)): WithSubqueryWithSelection<TSelection, TAlias>;
+    };
+    with(...queries: WithSubquery[]): {
+        select: {
+            (): SQLiteSelectBuilder<undefined, TResultKind, TRunResult>;
+            <TSelection extends SelectedFields>(fields: TSelection): SQLiteSelectBuilder<TSelection, TResultKind, TRunResult, "db">;
+        };
+        selectDistinct: {
+            (): SQLiteSelectBuilder<undefined, TResultKind, TRunResult>;
+            <TSelection_1 extends SelectedFields>(fields: TSelection_1): SQLiteSelectBuilder<TSelection_1, TResultKind, TRunResult, "db">;
+        };
+    };
+    select(): SQLiteSelectBuilder<undefined, TResultKind, TRunResult>;
+    select<TSelection extends SelectedFields>(fields: TSelection): SQLiteSelectBuilder<TSelection, TResultKind, TRunResult>;
+    selectDistinct(): SQLiteSelectBuilder<undefined, TResultKind, TRunResult>;
+    selectDistinct<TSelection extends SelectedFields>(fields: TSelection): SQLiteSelectBuilder<TSelection, TResultKind, TRunResult>;
+    update<TTable extends AnySQLiteTable>(table: TTable): SQLiteUpdateBuilder<TTable, TResultKind, TRunResult>;
+    insert<TTable extends AnySQLiteTable>(into: TTable): SQLiteInsertBuilder<TTable, TResultKind, TRunResult>;
+    delete<TTable extends AnySQLiteTable>(from: TTable): SQLiteDelete<TTable, TResultKind, TRunResult>;
+    run(query: SQLWrapper): Result<TResultKind, TRunResult>;
+    all<T = unknown>(query: SQLWrapper): Result<TResultKind, T[]>;
+    get<T = unknown>(query: SQLWrapper): Result<TResultKind, T>;
+    values<T extends unknown[] = unknown[]>(query: SQLWrapper): Result<TResultKind, T[]>;
+    transaction<T>(transaction: (tx: SQLiteTransaction<TResultKind, TRunResult, TFullSchema, TSchema>) => Result<TResultKind, T>, config?: SQLiteTransactionConfig): Result<TResultKind, T>;
 }
 
 interface PreparedQueryConfig {
@@ -396,14 +181,58 @@ declare abstract class SQLiteTransaction<TResultType extends 'sync' | 'async', T
     rollback(): never;
 }
 
+declare abstract class SQLiteDialect {
+    static readonly [entityKind]: string;
+    escapeName(name: string): string;
+    escapeParam(_num: number): string;
+    escapeString(str: string): string;
+    buildDeleteQuery({ table, where, returning }: SQLiteDeleteConfig): SQL;
+    buildUpdateSet(table: AnySQLiteTable, set: UpdateSet): SQL;
+    buildUpdateQuery({ table, set, where, returning }: SQLiteUpdateConfig): SQL;
+    /**
+     * Builds selection SQL with provided fields/expressions
+     *
+     * Examples:
+     *
+     * `select <selection> from`
+     *
+     * `insert ... returning <selection>`
+     *
+     * If `isSingleTable` is true, then columns won't be prefixed with table name
+     */
+    private buildSelection;
+    buildSelectQuery({ withList, fields, fieldsFlat, where, having, table, joins, orderBy, groupBy, limit, offset, distinct }: SQLiteSelectConfig): SQL;
+    buildInsertQuery({ table, values, onConflict, returning }: SQLiteInsertConfig): SQL;
+    sqlToQuery(sql: SQL): Query;
+    buildRelationalQuery({ fullSchema, schema, tableNamesMap, table, tableConfig, queryConfig: config, tableAlias, nestedQueryRelation, joinOn, }: {
+        fullSchema: Record<string, unknown>;
+        schema: TablesRelationalConfig;
+        tableNamesMap: Record<string, string>;
+        table: AnySQLiteTable;
+        tableConfig: TableRelationalConfig;
+        queryConfig: true | DBQueryConfig<'many', true>;
+        tableAlias: string;
+        nestedQueryRelation?: Relation;
+        joinOn?: SQL;
+    }): BuildRelationalQueryResult<SQLiteTable, SQLiteColumn>;
+}
+declare class SQLiteSyncDialect extends SQLiteDialect {
+    static readonly [entityKind]: string;
+    migrate(migrations: MigrationMeta[], session: SQLiteSession<'sync', unknown, Record<string, unknown>, TablesRelationalConfig>): void;
+}
+declare class SQLiteAsyncDialect extends SQLiteDialect {
+    static readonly [entityKind]: string;
+    migrate(migrations: MigrationMeta[], session: SQLiteSession<'async', unknown, Record<string, unknown>, TablesRelationalConfig>): Promise<void>;
+}
+
 interface SQLiteDeleteConfig {
     where?: SQL | undefined;
-    table: AnySQLiteTable;
+    table: SQLiteTable;
     returning?: SelectedFieldsOrdered;
 }
-interface SQLiteDelete<TTable extends AnySQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> extends SQLWrapper {
+interface SQLiteDelete<TTable extends SQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> extends SQLWrapper {
 }
-declare class SQLiteDelete<TTable extends AnySQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> implements SQLWrapper {
+declare class SQLiteDelete<TTable extends SQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> implements SQLWrapper {
     private table;
     private session;
     private dialect;
@@ -433,9 +262,9 @@ interface SQLiteUpdateConfig {
     table: AnySQLiteTable;
     returning?: SelectedFieldsOrdered;
 }
-type SQLiteUpdateSetSource<TTable extends AnySQLiteTable> = Simplify<{
+type SQLiteUpdateSetSource<TTable extends AnySQLiteTable> = {
     [Key in keyof TTable['_']['columns']]?: GetColumnData<TTable['_']['columns'][Key], 'query'> | SQL;
-}>;
+} & {};
 declare class SQLiteUpdateBuilder<TTable extends AnySQLiteTable, TResultType extends 'sync' | 'async', TRunResult> {
     protected table: TTable;
     protected session: SQLiteSession<any, any, any, any>;
@@ -461,7 +290,10 @@ declare class SQLiteUpdate<TTable extends AnySQLiteTable, TResultType extends 's
     where(where: SQL | undefined): Omit<this, 'where'>;
     returning(): Omit<SQLiteUpdate<TTable, TResultType, TRunResult, InferModel<TTable>>, 'where' | 'returning'>;
     returning<TSelectedFields extends SelectedFields>(fields: TSelectedFields): Omit<SQLiteUpdate<TTable, TResultType, TRunResult, SelectResultFields<TSelectedFields>>, 'where' | 'returning'>;
-    toSQL(): Omit<Query, 'typings'>;
+    toSQL(): {
+        sql: Query['sql'];
+        params: Query['params'];
+    };
     prepare(isOneTimeQuery?: boolean): PreparedQuery<{
         type: TResultType;
         run: TRunResult;
@@ -518,7 +350,10 @@ declare class SQLiteInsert<TTable extends AnySQLiteTable, TResultType extends 's
         where?: SQL;
         set: SQLiteUpdateSetSource<TTable>;
     }): this;
-    toSQL(): Simplify<Omit<Query, 'typings'>>;
+    toSQL(): Simplify<{
+        sql: Query['sql'];
+        params: Query['params'];
+    }>;
     prepare(isOneTimeQuery?: boolean): PreparedQuery<{
         type: TResultType;
         run: TRunResult;
@@ -532,6 +367,83 @@ declare class SQLiteInsert<TTable extends AnySQLiteTable, TResultType extends 's
     values: ReturnType<this['prepare']>['values'];
 }
 
+type CreateSQLiteSelectFromBuilderMode<TBuilderMode extends 'db' | 'qb', TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection extends ColumnsSelection, TSelectMode extends SelectMode> = TBuilderMode extends 'db' ? SQLiteSelect<TTableName, TResultType, TRunResult, TSelection, TSelectMode> : SQLiteSelectQueryBuilder<SQLiteSelectQueryBuilderHKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode>;
+declare class SQLiteSelectBuilder<TSelection extends SelectedFields | undefined, TResultType extends 'sync' | 'async', TRunResult, TBuilderMode extends 'db' | 'qb' = 'db'> {
+    static readonly [entityKind]: string;
+    private fields;
+    private session;
+    private dialect;
+    private withList;
+    private distinct;
+    constructor(config: {
+        fields: TSelection;
+        session: SQLiteSession<any, any, any, any> | undefined;
+        dialect: SQLiteDialect;
+        withList?: Subquery[];
+        distinct?: boolean;
+    });
+    from<TFrom extends AnySQLiteTable | Subquery | SQLiteViewBase | SQL>(source: TFrom): CreateSQLiteSelectFromBuilderMode<TBuilderMode, GetSelectTableName<TFrom>, TResultType, TRunResult, TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection, TSelection extends undefined ? 'single' : 'partial'>;
+}
+declare abstract class SQLiteSelectQueryBuilder<THKT extends SQLiteSelectHKTBase, TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection extends ColumnsSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends TypedQueryBuilder<BuildSubquerySelection<TSelection, TNullabilityMap>, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]> {
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly selectMode: TSelectMode;
+        readonly selection: TSelection;
+        readonly result: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+        readonly selectedFields: BuildSubquerySelection<TSelection, TNullabilityMap>;
+    };
+    protected config: SQLiteSelectConfig;
+    protected joinsNotNullableMap: Record<string, boolean>;
+    private tableName;
+    private isPartialSelect;
+    protected session: SQLiteSession<any, any, any, any> | undefined;
+    protected dialect: SQLiteDialect;
+    constructor({ table, fields, isPartialSelect, session, dialect, withList, distinct }: {
+        table: SQLiteSelectConfig['table'];
+        fields: SQLiteSelectConfig['fields'];
+        isPartialSelect: boolean;
+        session: SQLiteSession<any, any, any, any> | undefined;
+        dialect: SQLiteDialect;
+        withList: Subquery[] | undefined;
+        distinct: boolean | undefined;
+    });
+    private createJoin;
+    leftJoin: JoinFn<THKT, TTableName, TResultType, TRunResult, TSelectMode, "left", TSelection, TNullabilityMap>;
+    rightJoin: JoinFn<THKT, TTableName, TResultType, TRunResult, TSelectMode, "right", TSelection, TNullabilityMap>;
+    innerJoin: JoinFn<THKT, TTableName, TResultType, TRunResult, TSelectMode, "inner", TSelection, TNullabilityMap>;
+    fullJoin: JoinFn<THKT, TTableName, TResultType, TRunResult, TSelectMode, "full", TSelection, TNullabilityMap>;
+    where(where: ((aliases: TSelection) => SQL | undefined) | SQL | undefined): this;
+    having(having: ((aliases: TSelection) => SQL | undefined) | SQL | undefined): this;
+    groupBy(builder: (aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>): this;
+    groupBy(...columns: (SQLiteColumn | SQL)[]): this;
+    orderBy(builder: (aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>): this;
+    orderBy(...columns: (SQLiteColumn | SQL)[]): this;
+    limit(limit: number | Placeholder): this;
+    offset(offset: number | Placeholder): this;
+    toSQL(): {
+        sql: Query['sql'];
+        params: Query['params'];
+    };
+    as<TAlias extends string>(alias: TAlias): SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias>;
+    getSelectedFields(): BuildSubquerySelection<TSelection, TNullabilityMap>;
+}
+interface SQLiteSelect<TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection extends ColumnsSelection, TSelectMode extends SelectMode = 'single', TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends SQLiteSelectQueryBuilder<SQLiteSelectHKT, TTableName | undefined, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
+}
+declare class SQLiteSelect<TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection, TSelectMode extends SelectMode = 'single', TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends SQLiteSelectQueryBuilder<SQLiteSelectHKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
+    static readonly [entityKind]: string;
+    prepare(isOneTimeQuery?: boolean): PreparedQuery<{
+        type: TResultType;
+        run: TRunResult;
+        all: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+        get: SelectResult<TSelection, TSelectMode, TNullabilityMap>;
+        values: any[][];
+    }>;
+    run: ReturnType<this['prepare']>['run'];
+    all: ReturnType<this['prepare']>['all'];
+    get: ReturnType<this['prepare']>['get'];
+    values: ReturnType<this['prepare']>['values'];
+}
+
 declare class QueryBuilder {
     static readonly [entityKind]: string;
     private dialect;
@@ -578,17 +490,17 @@ declare class ViewBuilder<TName extends string = string> extends ViewBuilderCore
     name: TName;
 }> {
     static readonly [entityKind]: string;
-    as<TSelection extends SelectedFields>(qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>)): SQLiteViewWithSelection<TName, false, AddAliasToSelection<TSelection, TName>>;
+    as<TSelection extends SelectedFields>(qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>)): SQLiteViewWithSelection<TName, false, AddAliasToSelection<TSelection, TName, 'sqlite'>>;
 }
-declare class ManualViewBuilder<TName extends string = string, TColumns extends Record<string, AnySQLiteColumnBuilder> = Record<string, AnySQLiteColumnBuilder>> extends ViewBuilderCore<{
+declare class ManualViewBuilder<TName extends string = string, TColumns extends Record<string, SQLiteColumnBuilder> = Record<string, SQLiteColumnBuilder>> extends ViewBuilderCore<{
     name: TName;
     columns: TColumns;
 }> {
     static readonly [entityKind]: string;
     private columns;
     constructor(name: TName, columns: TColumns);
-    existing(): SQLiteViewWithSelection<TName, true, BuildColumns<TName, TColumns>>;
-    as(query: SQL): SQLiteViewWithSelection<TName, false, BuildColumns<TName, TColumns>>;
+    existing(): SQLiteViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'sqlite'>>;
+    as(query: SQL): SQLiteViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'sqlite'>>;
 }
 declare abstract class SQLiteViewBase<TName extends string = string, TExisting extends boolean = boolean, TSelection extends ColumnsSelection = ColumnsSelection> extends View<TName, TExisting, TSelection> {
     static readonly [entityKind]: string;
@@ -611,156 +523,60 @@ declare class SQLiteView<TName extends string = string, TExisting extends boolea
 }
 type SQLiteViewWithSelection<TName extends string, TExisting extends boolean, TSelection extends ColumnsSelection> = SQLiteView<TName, TExisting, TSelection> & TSelection;
 declare function sqliteView<TName extends string>(name: TName): ViewBuilder<TName>;
-declare function sqliteView<TName extends string, TColumns extends Record<string, AnySQLiteColumnBuilder>>(name: TName, columns: TColumns): ManualViewBuilder<TName, TColumns>;
+declare function sqliteView<TName extends string, TColumns extends Record<string, SQLiteColumnBuilder>>(name: TName, columns: TColumns): ManualViewBuilder<TName, TColumns>;
 declare const view: typeof sqliteView;
 
-declare abstract class SQLiteDialect {
-    static readonly [entityKind]: string;
-    escapeName(name: string): string;
-    escapeParam(_num: number): string;
-    escapeString(str: string): string;
-    buildDeleteQuery({ table, where, returning }: SQLiteDeleteConfig): SQL;
-    buildUpdateSet(table: AnySQLiteTable, set: UpdateSet): SQL;
-    buildUpdateQuery({ table, set, where, returning }: SQLiteUpdateConfig): SQL;
-    /**
-     * Builds selection SQL with provided fields/expressions
-     *
-     * Examples:
-     *
-     * `select <selection> from`
-     *
-     * `insert ... returning <selection>`
-     *
-     * If `isSingleTable` is true, then columns won't be prefixed with table name
-     */
-    private buildSelection;
-    buildSelectQuery({ withList, fields, fieldsFlat, where, having, table, joins, orderBy, groupBy, limit, offset, distinct }: SQLiteSelectConfig): SQL;
-    buildInsertQuery({ table, values, onConflict, returning }: SQLiteInsertConfig): SQL;
-    sqlToQuery(sql: SQL): Query;
-    buildRelationalQuery({ fullSchema, schema, tableNamesMap, table, tableConfig, queryConfig: config, tableAlias, nestedQueryRelation, joinOn, }: {
-        fullSchema: Record<string, unknown>;
-        schema: TablesRelationalConfig;
-        tableNamesMap: Record<string, string>;
-        table: AnySQLiteTable;
-        tableConfig: TableRelationalConfig;
-        queryConfig: true | DBQueryConfig<'many', true>;
-        tableAlias: string;
-        nestedQueryRelation?: Relation;
-        joinOn?: SQL;
-    }): BuildRelationalQueryResult<AnySQLiteTable, AnySQLiteColumn>;
-}
-declare class SQLiteSyncDialect extends SQLiteDialect {
-    static readonly [entityKind]: string;
-    migrate(migrations: MigrationMeta[], session: SQLiteSession<'sync', unknown, Record<string, unknown>, TablesRelationalConfig>): void;
-}
-declare class SQLiteAsyncDialect extends SQLiteDialect {
-    static readonly [entityKind]: string;
-    migrate(migrations: MigrationMeta[], session: SQLiteSession<'async', unknown, Record<string, unknown>, TablesRelationalConfig>): Promise<void>;
-}
-
-declare class AsyncRelationalQueryBuilder<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig> {
-    private fullSchema;
-    private schema;
-    private tableNamesMap;
-    private table;
-    private tableConfig;
-    private dialect;
-    private session;
-    static readonly [entityKind]: string;
-    constructor(fullSchema: Record<string, unknown>, schema: TSchema, tableNamesMap: Record<string, string>, table: AnySQLiteTable, tableConfig: TableRelationalConfig, dialect: SQLiteDialect, session: SQLiteSession<'async', unknown, TFullSchema, TSchema>);
-    findMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>): SQLiteAsyncRelationalQuery<BuildQueryResult<TSchema, TFields, TConfig>[]>;
-    findFirst<TSelection extends Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>): SQLiteAsyncRelationalQuery<BuildQueryResult<TSchema, TFields, TSelection> | undefined>;
+interface Join {
+    on: SQL | undefined;
+    table: SQLiteTable | Subquery | SQLiteViewBase | SQL;
+    alias: string | undefined;
+    joinType: JoinType;
 }
-declare class SyncRelationalQueryBuilder<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig> {
-    private fullSchema;
-    private schema;
-    private tableNamesMap;
-    private table;
-    private tableConfig;
-    private dialect;
-    private session;
-    static readonly [entityKind]: string;
-    constructor(fullSchema: Record<string, unknown>, schema: TSchema, tableNamesMap: Record<string, string>, table: AnySQLiteTable, tableConfig: TableRelationalConfig, dialect: SQLiteDialect, session: SQLiteSession<'sync', unknown, TFullSchema, TSchema>);
-    prepareFindMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>): {
-        execute: PreparedQuery<PreparedQueryConfig & {
-            type: 'sync';
-            all: BuildQueryResult<TSchema, TFields, TConfig>[];
-        }>['all'];
-    };
-    findMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>): BuildQueryResult<TSchema, TFields, TConfig>[];
-    prepareFindFirst<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>): {
-        execute: PreparedQuery<PreparedQueryConfig & {
-            type: 'sync';
-            get: BuildQueryResult<TSchema, TFields, TConfig> | undefined;
-        }>['get'];
-    };
-    findFirst<TSelection extends Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>): BuildQueryResult<TSchema, TFields, TSelection> | undefined;
+type AnySQLiteSelect = SQLiteSelect<any, any, any, any, any, any>;
+type BuildAliasTable<TTable extends SQLiteTable | View, TAlias extends string> = TTable extends Table ? SQLiteTableWithColumns<UpdateTableConfig<TTable['_']['config'], {
+    name: TAlias;
+    columns: MapColumnsToTableAlias<TTable['_']['columns'], TAlias, 'sqlite'>;
+}>> : TTable extends View ? SQLiteViewWithSelection<TAlias, TTable['_']['existing'], MapColumnsToTableAlias<TTable['_']['selectedFields'], TAlias, 'sqlite'>> : never;
+interface SQLiteSelectConfig {
+    withList?: Subquery[];
+    fields: Record<string, unknown>;
+    fieldsFlat?: SelectedFieldsOrdered;
+    where?: SQL;
+    having?: SQL;
+    table: SQLiteTable | Subquery | SQLiteViewBase | SQL;
+    limit?: number | Placeholder;
+    offset?: number | Placeholder;
+    joins?: Join[];
+    orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
+    groupBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
+    distinct?: boolean;
 }
-declare class SQLiteRelationalQuery<TResultKind extends 'sync' | 'async', TResult> {
-    private fullSchema;
-    private schema;
-    private tableNamesMap;
-    private table;
-    private tableConfig;
-    private dialect;
-    private session;
-    private config;
-    private mode;
-    static readonly [entityKind]: string;
-    protected $brand: 'SQLiteRelationalQuery';
-    constructor(fullSchema: Record<string, unknown>, schema: TablesRelationalConfig, tableNamesMap: Record<string, string>, table: AnySQLiteTable, tableConfig: TableRelationalConfig, dialect: SQLiteDialect, session: SQLiteSession<TResultKind, unknown, Record<string, unknown>, TablesRelationalConfig>, config: DBQueryConfig<'many', true> | true, mode: 'many' | 'first');
-    prepare(): PreparedQuery<PreparedQueryConfig & {
-        type: TResultKind;
-        all: TResult;
-        get: TResult;
-    }>;
-    execute(): Result<TResultKind, TResult>;
+type JoinFn<THKT extends SQLiteSelectHKTBase, TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelectMode extends SelectMode, TJoinType extends JoinType, TSelection, TNullabilityMap extends Record<string, JoinNullability>> = <TJoinedTable extends SQLiteTable | Subquery | SQLiteViewBase | SQL, TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>>(table: TJoinedTable, on: ((aliases: TSelection) => SQL | undefined) | SQL | undefined) => SQLiteSelectKind<THKT, TTableName, TResultType, TRunResult, AppendToResult<TTableName, TSelection, TJoinedName, TJoinedTable extends SQLiteTable ? TJoinedTable['_']['columns'] : TJoinedTable extends Subquery | View ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields> : never, TSelectMode>, TSelectMode extends 'partial' ? TSelectMode : 'multiple', AppendToNullabilityMap<TNullabilityMap, TJoinedName, TJoinType>>;
+type SelectedFieldsFlat = SelectedFieldsFlat$1<SQLiteColumn>;
+type SelectedFields = SelectedFields$1<SQLiteColumn, SQLiteTable>;
+type SelectedFieldsOrdered = SelectedFieldsOrdered$1<SQLiteColumn>;
+interface SQLiteSelectHKTBase {
+    tableName: string | undefined;
+    resultType: 'sync' | 'async';
+    runResult: unknown;
+    selection: unknown;
+    selectMode: SelectMode;
+    nullabilityMap: unknown;
+    _type: unknown;
 }
-interface SQLiteAsyncRelationalQuery<TResult> extends SQLiteRelationalQuery<'async', TResult>, QueryPromise<TResult> {
+type SQLiteSelectKind<T extends SQLiteSelectHKTBase, TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability>> = (T & {
+    tableName: TTableName;
+    resultType: TResultType;
+    runResult: TRunResult;
+    selection: TSelection;
+    selectMode: TSelectMode;
+    nullabilityMap: TNullabilityMap;
+})['_type'];
+interface SQLiteSelectQueryBuilderHKT extends SQLiteSelectHKTBase {
+    _type: SQLiteSelectQueryBuilder<this, this['tableName'], this['resultType'], this['runResult'], Assume<this['selection'], ColumnsSelection>, this['selectMode'], Assume<this['nullabilityMap'], Record<string, JoinNullability>>>;
 }
-
-declare class BaseSQLiteDatabase<TResultKind extends 'sync' | 'async', TRunResult, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
-    static readonly [entityKind]: string;
-    readonly _: {
-        readonly schema: TSchema | undefined;
-        readonly tableNamesMap: Record<string, string>;
-    };
-    query: TFullSchema extends Record<string, never> ? DrizzleTypeError<'Seems like the schema generic is missing - did you forget to add it to your DB type?'> : {
-        [K in keyof TSchema]: TResultKind extends 'async' ? AsyncRelationalQueryBuilder<TFullSchema, TSchema, TSchema[K]> : SyncRelationalQueryBuilder<TFullSchema, TSchema, TSchema[K]>;
-    };
-    constructor(resultKind: TResultKind, 
-    /** @internal */
-    dialect: {
-        sync: SQLiteSyncDialect;
-        async: SQLiteAsyncDialect;
-    }[TResultKind], 
-    /** @internal */
-    session: SQLiteSession<TResultKind, TRunResult, TFullSchema, TSchema>, schema: RelationalSchemaConfig<TSchema> | undefined);
-    $with<TAlias extends string>(alias: TAlias): {
-        as<TSelection extends ColumnsSelection>(qb: TypedQueryBuilder<TSelection, unknown> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection, unknown>)): WithSubqueryWithSelection<TSelection, TAlias>;
-    };
-    with(...queries: WithSubquery[]): {
-        select: {
-            (): SQLiteSelectBuilder<undefined, TResultKind, TRunResult>;
-            <TSelection extends SelectedFields>(fields: TSelection): SQLiteSelectBuilder<TSelection, TResultKind, TRunResult, "db">;
-        };
-        selectDistinct: {
-            (): SQLiteSelectBuilder<undefined, TResultKind, TRunResult>;
-            <TSelection_1 extends SelectedFields>(fields: TSelection_1): SQLiteSelectBuilder<TSelection_1, TResultKind, TRunResult, "db">;
-        };
-    };
-    select(): SQLiteSelectBuilder<undefined, TResultKind, TRunResult>;
-    select<TSelection extends SelectedFields>(fields: TSelection): SQLiteSelectBuilder<TSelection, TResultKind, TRunResult>;
-    selectDistinct(): SQLiteSelectBuilder<undefined, TResultKind, TRunResult>;
-    selectDistinct<TSelection extends SelectedFields>(fields: TSelection): SQLiteSelectBuilder<TSelection, TResultKind, TRunResult>;
-    update<TTable extends AnySQLiteTable>(table: TTable): SQLiteUpdateBuilder<TTable, TResultKind, TRunResult>;
-    insert<TTable extends AnySQLiteTable>(into: TTable): SQLiteInsertBuilder<TTable, TResultKind, TRunResult>;
-    delete<TTable extends AnySQLiteTable>(from: TTable): SQLiteDelete<TTable, TResultKind, TRunResult>;
-    run(query: SQLWrapper): Result<TResultKind, TRunResult>;
-    all<T = unknown>(query: SQLWrapper): Result<TResultKind, T[]>;
-    get<T = unknown>(query: SQLWrapper): Result<TResultKind, T>;
-    values<T extends unknown[] = unknown[]>(query: SQLWrapper): Result<TResultKind, T[]>;
-    transaction<T>(transaction: (tx: SQLiteTransaction<TResultKind, TRunResult, TFullSchema, TSchema>) => Result<TResultKind, T>, config?: SQLiteTransactionConfig): Result<TResultKind, T>;
+interface SQLiteSelectHKT extends SQLiteSelectHKTBase {
+    _type: SQLiteSelect<this['tableName'], this['resultType'], this['runResult'], Assume<this['selection'], ColumnsSelection>, this['selectMode'], Assume<this['nullabilityMap'], Record<string, JoinNullability>>>;
 }
 
-export { JoinFn as $, AnySQLiteTable as A, BaseSQLiteDatabase as B, Check as C, IndexBuilder as D, index as E, ForeignKey as F, uniqueIndex as G, primaryKey as H, Index as I, PrimaryKeyBuilder as J, SQLiteDeleteConfig as K, SQLiteDelete as L, SQLiteInsertConfig as M, SQLiteInsertValue as N, SQLiteInsertBuilder as O, PreparedQuery as P, SQLiteInsert as Q, ReferenceConfig as R, SQLiteSession as S, QueryBuilder as T, UniqueConstraint as U, SQLiteSelectBuilder as V, SQLiteSelectQueryBuilder as W, SQLiteSelect as X, Join as Y, AnySQLiteSelect as Z, SQLiteSelectConfig as _, SQLiteSyncDialect as a, SelectedFieldsFlat as a0, SelectedFields as a1, SQLiteSelectHKTBase as a2, SQLiteSelectKind as a3, SQLiteSelectQueryBuilderHKT as a4, SQLiteSelectHKT as a5, SQLiteUpdateConfig as a6, SQLiteUpdateSetSource as a7, SQLiteUpdateBuilder as a8, SQLiteUpdate as a9, Result as aa, SubqueryWithSelection as ab, WithSubqueryWithSelection as ac, SQLiteTableExtraConfig as ad, TableConfig as ae, SQLiteTable as af, SQLiteTableWithColumns as ag, SQLiteTableFn as ah, sqliteTable as ai, sqliteTableCreator as aj, uniqueKeyName as ak, unique as al, UniqueConstraintBuilder as am, UniqueOnConstraintBuilder as an, ViewBuilderConfig as ao, ViewBuilderCore as ap, ViewBuilder as aq, ManualViewBuilder as ar, SQLiteViewConfig as as, SQLiteViewWithSelection as at, sqliteView as au, view as av, SelectedFieldsOrdered as b, SQLiteTransactionConfig as c, SQLiteTransaction as d, PreparedQueryConfig as e, SQLiteAsyncDialect as f, SQLiteColumnBuilder as g, SQLiteColumn as h, AnySQLiteColumn as i, PrimaryKey as j, SQLiteView as k, SQLiteViewBase as l, BuildAliasTable as m, CheckBuilder as n, check as o, SQLiteColumnBuilderHKT as p, SQLiteColumnHKT as q, AnySQLiteColumnBuilder as r, SQLiteDialect as s, UpdateDeleteAction as t, Reference as u, ForeignKeyBuilder as v, foreignKey as w, IndexConfig as x, IndexColumn as y, IndexBuilderOn as z };
+export { AnySQLiteSelect as A, BaseSQLiteDatabase as B, SQLiteSelectHKT as C, SQLiteUpdateConfig as D, SQLiteUpdateSetSource as E, SQLiteUpdateBuilder as F, SQLiteUpdate as G, SubqueryWithSelection as H, ViewBuilderCore as I, Join as J, ViewBuilder as K, SQLiteViewConfig as L, ManualViewBuilder as M, SQLiteViewWithSelection as N, sqliteView as O, PreparedQuery as P, QueryBuilder as Q, Result as R, SQLiteSession as S, view as T, ViewBuilderConfig as V, WithSubqueryWithSelection as W, SQLiteSyncDialect as a, SelectedFieldsOrdered as b, SQLiteTransactionConfig as c, SQLiteTransaction as d, PreparedQueryConfig as e, SQLiteAsyncDialect as f, SQLiteView as g, SQLiteViewBase as h, BuildAliasTable as i, SQLiteDialect as j, SQLiteDeleteConfig as k, SQLiteDelete as l, SQLiteInsertConfig as m, SQLiteInsertValue as n, SQLiteInsertBuilder as o, SQLiteInsert as p, SQLiteSelectBuilder as q, SQLiteSelectQueryBuilder as r, SQLiteSelect as s, SQLiteSelectConfig as t, JoinFn as u, SelectedFieldsFlat as v, SelectedFields as w, SQLiteSelectHKTBase as x, SQLiteSelectKind as y, SQLiteSelectQueryBuilderHKT as z };