drizzle-orm 0.39.2-8628c8a → 0.39.2-aaa57ff

package/relations.d.ts

@@ -2,70 +2,88 @@ import { type AnyTable, type InferModelFromColumns, Table } from "./table.js";
 import { type AnyColumn, Column } from "./column.js";
 import { entityKind } from "./entity.js";
 import { and, asc, between, desc, exists, ilike, inArray, isNotNull, isNull, like, not, notBetween, notExists, notIlike, notInArray, notLike, or } from "./sql/expressions/index.js";
-import { type Placeholder, SQL, sql } from "./sql/sql.js";
-import type { Assume, ColumnsWithTable, Equal, Simplify, ValueOrArray } from "./utils.js";
-export declare abstract class Relation<TTableName extends string = string> {
-    readonly sourceTable: Table;
-    readonly referencedTable: AnyTable<{
-        name: TTableName;
-    }>;
-    readonly relationName: string | undefined;
+import { type Placeholder, SQL, sql, type SQLWrapper, View } from "./sql/sql.js";
+import type { Assume, DrizzleTypeError, Equal, Simplify, ValueOrArray, Writable } from "./utils.js";
+export type FieldValue = Column | SQLWrapper | SQL.Aliased | SQL;
+export type FieldSelection = Record<string, FieldValue>;
+export declare class Relations<TSchema extends Record<string, unknown> = Record<string, unknown>, TTables extends Record<string, Table | View> = Record<string, Table | View>, TConfig extends RelationsBuilderConfig<TTables> = RelationsBuilderConfig<TTables>> {
+    readonly schema: TSchema;
+    readonly tables: TTables;
+    readonly config: TConfig;
+    static readonly [entityKind]: string;
+    readonly $brand: 'RelationsV2';
+    /** table DB name -> schema table key */
+    readonly tableNamesMap: Record<string, string>;
+    readonly tablesConfig: TablesRelationalConfig;
+    constructor(schema: TSchema, tables: TTables, config: TConfig);
+}
+export type EmptyRelations = Relations<Record<string, never>, Record<string, never>, Record<string, never>>;
+export type AnyRelations = Relations<Record<string, any>, Record<string, any>, Record<string, any>>;
+export declare abstract class Relation<TSourceTableName extends string = string, TTargetTableName extends string = string> {
+    readonly targetTable: AnyTable<{
+        name: TTargetTableName;
+    }> | View<TTargetTableName>;
     static readonly [entityKind]: string;
-    readonly $brand: 'Relation';
-    readonly referencedTableName: TTableName;
+    readonly $brand: 'RelationV2';
     fieldName: string;
-    constructor(sourceTable: Table, referencedTable: AnyTable<{
-        name: TTableName;
-    }>, relationName: string | undefined);
-    abstract withFieldName(fieldName: string): Relation<TTableName>;
+    sourceColumns: AnyColumn<{
+        tableName: TSourceTableName;
+    }>[];
+    targetColumns: AnyColumn<{
+        tableName: TTargetTableName;
+    }>[];
+    alias: string | undefined;
+    where: RelationsFilter | undefined;
+    sourceTable: AnyTable<{
+        name: TSourceTableName;
+    }> | View<TSourceTableName>;
+    through?: {
+        source: RelationsBuilderColumnBase[];
+        target: RelationsBuilderColumnBase[];
+    };
+    throughTable?: Table | View;
+    isReversed?: boolean;
+    constructor(targetTable: AnyTable<{
+        name: TTargetTableName;
+    }> | View<TTargetTableName>);
 }
-export declare class Relations<TTableName extends string = string, TConfig extends Record<string, Relation> = Record<string, Relation>> {
-    readonly table: AnyTable<{
-        name: TTableName;
-    }>;
-    readonly config: (helpers: TableRelationsHelpers<TTableName>) => TConfig;
+export declare class One<TSourceTableName extends string, TTargetTableName extends string, TOptional extends boolean = boolean> extends Relation<TSourceTableName, TTargetTableName> {
     static readonly [entityKind]: string;
-    readonly $brand: 'Relations';
-    constructor(table: AnyTable<{
-        name: TTableName;
-    }>, config: (helpers: TableRelationsHelpers<TTableName>) => TConfig);
+    protected $relationBrand: 'OneV2';
+    readonly optional: TOptional;
+    constructor(tables: Record<string, Table | View>, targetTable: AnyTable<{
+        name: TTargetTableName;
+    }> | View<TTargetTableName>, config: AnyOneConfig | undefined);
 }
-export declare class One<TTableName extends string = string, TIsNullable extends boolean = boolean> extends Relation<TTableName> {
-    readonly config: RelationConfig<TTableName, string, AnyColumn<{
-        tableName: TTableName;
-    }>[]> | undefined;
-    readonly isNullable: TIsNullable;
+export declare class Many<TSourceTableName extends string, TTargetTableName extends string> extends Relation<TSourceTableName, TTargetTableName> {
+    readonly config: AnyManyConfig | undefined;
     static readonly [entityKind]: string;
-    protected $relationBrand: 'One';
-    constructor(sourceTable: Table, referencedTable: AnyTable<{
-        name: TTableName;
-    }>, config: RelationConfig<TTableName, string, AnyColumn<{
-        tableName: TTableName;
-    }>[]> | undefined, isNullable: TIsNullable);
-    withFieldName(fieldName: string): One<TTableName>;
+    protected $relationBrand: 'ManyV2';
+    constructor(tables: Record<string, Table | View>, targetTable: AnyTable<{
+        name: TTargetTableName;
+    }> | View<TTargetTableName>, config: AnyManyConfig | undefined);
 }
-export declare class Many<TTableName extends string> extends Relation<TTableName> {
-    readonly config: {
-        relationName: string;
-    } | undefined;
+export declare abstract class AggregatedField<T = unknown> implements SQLWrapper<T> {
     static readonly [entityKind]: string;
-    protected $relationBrand: 'Many';
-    constructor(sourceTable: Table, referencedTable: AnyTable<{
-        name: TTableName;
-    }>, config: {
-        relationName: string;
-    } | undefined);
-    withFieldName(fieldName: string): Many<TTableName>;
-}
-export type TableRelationsKeysOnly<TSchema extends Record<string, unknown>, TTableName extends string, K extends keyof TSchema> = TSchema[K] extends Relations<TTableName> ? K : never;
-export type ExtractTableRelationsFromSchema<TSchema extends Record<string, unknown>, TTableName extends string> = ExtractObjectValues<{
-    [K in keyof TSchema as TableRelationsKeysOnly<TSchema, TTableName, K>]: TSchema[K] extends Relations<TTableName, infer TConfig> ? TConfig : never;
-}>;
+    readonly $brand: 'AggregatedField';
+    readonly _: {
+        readonly data: T;
+    };
+    protected table: Table | View | undefined;
+    onTable(table: Table | View): this;
+    abstract getSQL(): SQL<T>;
+}
+export declare class Count extends AggregatedField<number> {
+    static readonly [entityKind]: string;
+    protected $aggregatedFieldBrand: 'Count';
+    private query;
+    getSQL(): SQL<number>;
+}
 export type ExtractObjectValues<T> = T[keyof T];
 export type ExtractRelationsFromTableExtraConfigSchema<TConfig extends unknown[]> = ExtractObjectValues<{
     [K in keyof TConfig as TConfig[K] extends Relations<any> ? K : never]: TConfig[K] extends Relations<infer TRelationConfig> ? TRelationConfig : never;
 }>;
-export declare function getOperators(): {
+export declare const operators: {
     and: typeof and;
     between: typeof between;
     eq: import("./expressions.js").BinaryOperator;
@@ -89,127 +107,261 @@ export declare function getOperators(): {
     or: typeof or;
     sql: typeof sql;
 };
-export type Operators = ReturnType<typeof getOperators>;
+export type Operators = typeof operators;
+export declare const orderByOperators: {
+    sql: typeof sql;
+    asc: typeof asc;
+    desc: typeof desc;
+};
 export declare function getOrderByOperators(): {
     sql: typeof sql;
     asc: typeof asc;
     desc: typeof desc;
 };
 export type OrderByOperators = ReturnType<typeof getOrderByOperators>;
-export type FindTableByDBName<TSchema extends TablesRelationalConfig, TTableName extends string> = ExtractObjectValues<{
-    [K in keyof TSchema as TSchema[K]['dbName'] extends TTableName ? K : never]: TSchema[K];
+export type FindTableInRelationalConfig<TSchema extends TablesRelationalConfig, TTargetTable extends Table | View, TTableName extends string = TTargetTable['_']['name']> = ExtractObjectValues<{
+    [K in keyof TSchema as TSchema[K]['tsName'] extends TTableName ? K : never]: TSchema[K];
 }>;
-export type DBQueryConfig<TRelationType extends 'one' | 'many' = 'one' | 'many', TIsRoot extends boolean = boolean, TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig> = {
+export type SQLOperator = {
+    sql: Operators['sql'];
+};
+export type DBQueryConfig<TRelationType extends 'one' | 'many' = 'one' | 'many', TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig> = {
     columns?: {
-        [K in keyof TTableConfig['columns']]?: boolean;
+        [K in keyof TTableConfig['columns']]?: boolean | undefined;
     } | undefined;
     with?: {
-        [K in keyof TTableConfig['relations']]?: true | DBQueryConfig<TTableConfig['relations'][K] extends One ? 'one' : 'many', false, TSchema, FindTableByDBName<TSchema, TTableConfig['relations'][K]['referencedTableName']>> | undefined;
+        [K in keyof TTableConfig['relations']]?: boolean | (TTableConfig['relations'][K] extends Relation ? DBQueryConfig<TTableConfig['relations'][K] extends One<string, string> ? 'one' : 'many', TSchema, FindTableInRelationalConfig<TSchema, TTableConfig['relations'][K]['targetTable']>> : never) | undefined;
     } | undefined;
-    extras?: Record<string, SQL.Aliased> | ((fields: Simplify<[
-        TTableConfig['columns']
-    ] extends [never] ? {} : TTableConfig['columns']>, operators: {
-        sql: Operators['sql'];
-    }) => Record<string, SQL.Aliased>) | undefined;
+    extras?: Record<string, SQLWrapper> | ((table: TTableConfig['table'], operators: SQLOperator) => Record<string, SQLWrapper>) | undefined;
+    where?: RelationsFilter<TTableConfig['table']> | undefined;
+    orderBy?: {
+        [K in keyof TTableConfig['columns']]?: 'asc' | 'desc' | undefined;
+    } | ((table: TTableConfig['table'], operators: OrderByOperators) => ValueOrArray<AnyColumn | SQL>) | undefined;
+    offset?: number | Placeholder | undefined;
 } & (TRelationType extends 'many' ? {
-    where?: SQL | undefined | ((fields: Simplify<[
-        TTableConfig['columns']
-    ] extends [never] ? {} : TTableConfig['columns']>, operators: Operators) => SQL | undefined);
-    orderBy?: ValueOrArray<AnyColumn | SQL> | ((fields: Simplify<[
-        TTableConfig['columns']
-    ] extends [never] ? {} : TTableConfig['columns']>, operators: OrderByOperators) => ValueOrArray<AnyColumn | SQL>) | undefined;
     limit?: number | Placeholder | undefined;
-} & (TIsRoot extends true ? {
-    offset?: number | Placeholder | undefined;
-} : {}) : {});
+} : {});
 export interface TableRelationalConfig {
+    table: Table | View;
     tsName: string;
     dbName: string;
-    columns: Record<string, Column>;
-    relations: Record<string, Relation>;
-    primaryKey: AnyColumn[];
-    schema?: string;
+    schema: string | undefined;
+    columns: FieldSelection;
+    relations: Record<string, RelationsBuilderEntry>;
 }
 export type TablesRelationalConfig = Record<string, TableRelationalConfig>;
-export interface RelationalSchemaConfig<TSchema extends TablesRelationalConfig> {
-    fullSchema: Record<string, unknown>;
-    schema: TSchema;
+export interface RelationalSchemaConfig<TTablesConfig extends TablesRelationalConfig> {
+    tables: Record<string, Table>;
+    tablesConfig: TTablesConfig;
     tableNamesMap: Record<string, string>;
 }
-export type ExtractTablesWithRelations<TSchema extends Record<string, unknown>> = {
-    [K in keyof TSchema as TSchema[K] extends Table ? K : never]: TSchema[K] extends Table ? {
+type NonUndefinedRecord<TRecord extends Record<string, any>> = {
+    [K in keyof TRecord as K extends undefined ? never : K]: TRecord[K];
+};
+export type ExtractTablesWithRelations<TRelations extends Relations, TTables extends Record<string, Table | View> = TRelations['tables']> = {
+    [K in keyof TTables]: {
+        table: TTables[K];
         tsName: K & string;
-        dbName: TSchema[K]['_']['name'];
-        columns: TSchema[K]['_']['columns'];
-        relations: ExtractTableRelationsFromSchema<TSchema, TSchema[K]['_']['name']>;
-        primaryKey: AnyColumn[];
-    } : never;
+        dbName: TTables[K]['_']['name'];
+        columns: TTables[K] extends Table ? TTables[K]['_']['columns'] : Assume<TTables[K], View>['_']['selectedFields'];
+        relations: K extends keyof TRelations['config'] ? TRelations['config'][K] extends Record<string, any> ? NonUndefinedRecord<TRelations['config'][K]> : Record<string, never> : Record<string, never>;
+        schema: TTables[K] extends Table ? TTables[K]['_']['schema'] : string | undefined;
+    };
 };
 export type ReturnTypeOrValue<T> = T extends (...args: any[]) => infer R ? R : T;
-export type BuildRelationResult<TSchema extends TablesRelationalConfig, TInclude, TRelations extends Record<string, Relation>> = {
-    [K in NonUndefinedKeysOnly<TInclude> & keyof TRelations]: TRelations[K] extends infer TRel extends Relation ? BuildQueryResult<TSchema, FindTableByDBName<TSchema, TRel['referencedTableName']>, Assume<TInclude[K], true | Record<string, unknown>>> extends infer TResult ? TRel extends One ? TResult | (Equal<TRel['isNullable'], false> extends true ? null : never) : TResult[] : never : never;
+export type BuildRelationResult<TConfig extends TablesRelationalConfig, TInclude, TRelations extends Record<string, RelationsBuilderEntry>> = {
+    [K in TruthyKeysOnly<TInclude> & keyof TRelations]: TRelations[K] extends infer TRel extends Relation ? BuildQueryResult<TConfig, FindTableInRelationalConfig<TConfig, TRel['targetTable']>, Assume<TInclude[K], true | Record<string, unknown>>> extends infer TResult ? TRel extends One<string, string> ? TResult | (Equal<TRel['optional'], true> extends true ? null : TInclude[K] extends Record<string, unknown> ? TInclude[K]['where'] extends Record<string, any> ? null : never : never) : TResult[] : never : TRelations[K] extends AggregatedField<infer TData> ? TData : never;
 };
 export type NonUndefinedKeysOnly<T> = ExtractObjectValues<{
     [K in keyof T as T[K] extends undefined ? never : K]: K;
 }> & keyof T;
-export type BuildQueryResult<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig, TFullSelection extends true | Record<string, unknown>> = Equal<TFullSelection, true> extends true ? InferModelFromColumns<TTableConfig['columns']> : TFullSelection extends Record<string, unknown> ? Simplify<(TFullSelection['columns'] extends Record<string, unknown> ? InferModelFromColumns<{
-    [K in Equal<Exclude<TFullSelection['columns'][keyof TFullSelection['columns'] & keyof TTableConfig['columns']], undefined>, false> extends true ? Exclude<keyof TTableConfig['columns'], NonUndefinedKeysOnly<TFullSelection['columns']>> : {
-        [K in keyof TFullSelection['columns']]: Equal<TFullSelection['columns'][K], true> extends true ? K : never;
-    }[keyof TFullSelection['columns']] & keyof TTableConfig['columns']]: TTableConfig['columns'][K];
-}> : InferModelFromColumns<TTableConfig['columns']>) & (TFullSelection['extras'] extends Record<string, unknown> | ((...args: any[]) => Record<string, unknown>) ? {
-    [K in NonUndefinedKeysOnly<ReturnTypeOrValue<TFullSelection['extras']>>]: Assume<ReturnTypeOrValue<TFullSelection['extras']>[K], SQL.Aliased>['_']['type'];
-} : {}) & (TFullSelection['with'] extends Record<string, unknown> ? BuildRelationResult<TSchema, TFullSelection['with'], TTableConfig['relations']> : {})> : never;
-export interface RelationConfig<TTableName extends string, TForeignTableName extends string, TColumns extends AnyColumn<{
-    tableName: TTableName;
-}>[]> {
-    relationName?: string;
-    fields: TColumns;
-    references: ColumnsWithTable<TTableName, TForeignTableName, TColumns>;
-}
-export declare function extractTablesRelationalConfig<TTables extends TablesRelationalConfig>(schema: Record<string, unknown>, configHelpers: (table: Table) => any): {
-    tables: TTables;
-    tableNamesMap: Record<string, string>;
+export type TruthyKeysOnly<T> = ExtractObjectValues<{
+    [K in keyof T as T[K] extends undefined | false ? never : K]: K;
+}> & keyof T;
+export type ExtractSelectionColumns<TSelection extends Record<string, unknown>> = {
+    [K in keyof TSelection as TSelection[K] extends Column ? K : never]: TSelection[K];
+};
+export type ExtractSelectionNonColumns<TSelection extends Record<string, unknown>> = {
+    [K in keyof TSelection as TSelection[K] extends Column ? never : K]: TSelection[K];
 };
-export declare function relations<TTableName extends string, TRelations extends Record<string, Relation<any>>>(table: AnyTable<{
-    name: TTableName;
-}>, relations: (helpers: TableRelationsHelpers<TTableName>) => TRelations): Relations<TTableName, TRelations>;
-export declare function createOne<TTableName extends string>(sourceTable: Table): <TForeignTable extends Table, TColumns extends [AnyColumn<{
-    tableName: TTableName;
-}>, ...AnyColumn<{
-    tableName: TTableName;
-}>[]]>(table: TForeignTable, config?: RelationConfig<TTableName, TForeignTable["_"]["name"], TColumns>) => One<TForeignTable["_"]["name"], Equal<TColumns[number]["_"]["notNull"], true>>;
-export declare function createMany(sourceTable: Table): <TForeignTable extends Table>(referencedTable: TForeignTable, config?: {
-    relationName: string;
-}) => Many<TForeignTable["_"]["name"]>;
+export type InferRelationalQueryTableResult<TRawSelection extends Record<string, unknown>, TSelectedFields extends Record<string, unknown> | 'Full' = 'Full', TFilteredSelection extends Record<string, unknown> = TSelectedFields extends 'Full' ? TRawSelection : {
+    [K in Equal<Exclude<TSelectedFields[keyof TSelectedFields & keyof TRawSelection], undefined>, false> extends true ? Exclude<keyof TRawSelection, NonUndefinedKeysOnly<TSelectedFields>> : {
+        [K in keyof TSelectedFields]: Equal<TSelectedFields[K], true> extends true ? K : never;
+    }[keyof TSelectedFields] & keyof TRawSelection]: TRawSelection[K];
+}, TColumns extends Record<string, unknown> = ExtractSelectionColumns<TFilteredSelection>, TSubqueries extends Record<string, unknown> = ExtractSelectionNonColumns<TFilteredSelection>> = (TColumns extends Record<string, Column> ? InferModelFromColumns<TColumns> : {}) & (TSubqueries extends Record<string, Exclude<FieldValue, Column>> ? {
+    [K in keyof TSubqueries as TSubqueries[K] extends FieldValue ? K : never]: ReturnType<Assume<TSubqueries[K], SQLWrapper>['getSQL']>['_']['type'];
+} : {});
+export type BuildQueryResult<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig, TFullSelection extends true | Record<string, unknown>> = Equal<TFullSelection, true> extends true ? Simplify<InferRelationalQueryTableResult<TTableConfig['columns']>> : TFullSelection extends Record<string, unknown> ? Simplify<(InferRelationalQueryTableResult<TTableConfig['columns'], TFullSelection['columns'] extends Record<string, unknown> ? TFullSelection['columns'] : 'Full'>) & (TFullSelection['extras'] extends Record<string, unknown> | ((...args: any[]) => Record<string, unknown>) ? {
+    [K in NonUndefinedKeysOnly<ReturnTypeOrValue<TFullSelection['extras']>>]: ReturnType<Assume<ReturnTypeOrValue<TFullSelection['extras']>[K], SQLWrapper>['getSQL']>['_']['type'];
+} : {}) & (TFullSelection['with'] extends Record<string, unknown> ? BuildRelationResult<TSchema, TFullSelection['with'], TTableConfig['relations']> : {})> : never;
 export interface NormalizedRelation {
     fields: AnyColumn[];
     references: AnyColumn[];
 }
-export declare function normalizeRelation(schema: TablesRelationalConfig, tableNamesMap: Record<string, string>, relation: Relation): NormalizedRelation;
-export declare function createTableRelationsHelpers<TTableName extends string>(sourceTable: AnyTable<{
-    name: TTableName;
-}>): {
-    one: <TForeignTable extends Table, TColumns extends [AnyColumn<{
+export interface BuildRelationalQueryResult {
+    selection: {
+        key: string;
+        field: Column | Table | SQL | SQL.Aliased | SQLWrapper | AggregatedField;
+        isArray?: boolean;
+        selection?: BuildRelationalQueryResult['selection'];
+        isOptional?: boolean;
+    }[];
+    sql: SQL;
+}
+export declare function mapRelationalRow(row: Record<string, unknown>, buildQueryResultSelection: BuildRelationalQueryResult['selection'], mapColumnValue?: (value: unknown) => unknown, 
+/** Needed for SQLite as it returns JSON values as strings */
+parseJson?: boolean, path?: string): Record<string, unknown>;
+export declare class RelationsBuilderTable<TTableName extends string = string> implements SQLWrapper {
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly name: TTableName;
+        readonly table: AnyTable<{
+            name: TTableName;
+        }> | View<TTableName>;
+    };
+    constructor(table: AnyTable<{
+        name: TTableName;
+    }> | View<TTableName>, key: string);
+    getSQL(): SQL;
+}
+export type RelationsBuilderColumnConfig<TTableName extends string = string, TData = unknown> = {
+    readonly tableName: TTableName;
+    readonly data: TData;
+    readonly column: AnyColumn<{
         tableName: TTableName;
-    }>, ...AnyColumn<{
+    }> | SQL<TData> | SQLWrapper<TData> | SQL.Aliased<TData>;
+    readonly through?: RelationsBuilderColumnBase;
+    readonly key: string;
+};
+export type RelationsBuilderColumnBase<TTableName extends string = string, TData = unknown> = {
+    _: RelationsBuilderColumnConfig<TTableName, TData>;
+} & SQLWrapper;
+export declare class RelationsBuilderColumn<TTableName extends string = string, TData = unknown> implements SQLWrapper, RelationsBuilderColumnBase<TTableName, TData> {
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly tableName: TTableName;
+        readonly data: TData;
+        readonly column: AnyColumn<{
+            tableName: TTableName;
+        }> | SQL<TData> | SQLWrapper<TData> | SQL.Aliased<TData>;
+        readonly through?: RelationsBuilderColumnBase;
+        readonly key: string;
+    };
+    constructor(column: AnyColumn<{
         tableName: TTableName;
-    }>[]]>(table: TForeignTable, config?: RelationConfig<TTableName, TForeignTable["_"]["name"], TColumns> | undefined) => One<TForeignTable["_"]["name"], Equal<TColumns[number]["_"]["notNull"], true>>;
-    many: <TForeignTable extends Table>(referencedTable: TForeignTable, config?: {
-        relationName: string;
-    }) => Many<TForeignTable["_"]["name"]>;
-};
-export type TableRelationsHelpers<TTableName extends string> = ReturnType<typeof createTableRelationsHelpers<TTableName>>;
-export interface BuildRelationalQueryResult<TTable extends Table = Table, TColumn extends Column = Column> {
-    tableTsKey: string;
+    }> | SQL<TData> | SQLWrapper<TData> | SQL.Aliased<TData>, tableName: TTableName, key: string, through?: RelationsBuilderColumn);
+    through(column: RelationsBuilderColumn): RelationsBuilderColumnBase<TTableName, TData>;
+    getSQL(): SQL;
+}
+export type RelationFieldsFilterInternals<T> = {
+    eq?: T | Placeholder;
+    ne?: T | Placeholder;
+    gt?: T | Placeholder;
+    gte?: T | Placeholder;
+    lt?: T | Placeholder;
+    lte?: T | Placeholder;
+    in?: (T | Placeholder)[] | Placeholder;
+    notIn?: (T | Placeholder)[] | Placeholder;
+    like?: string | Placeholder;
+    ilike?: string | Placeholder;
+    notLike?: string | Placeholder;
+    notIlike?: string | Placeholder;
+    isNull?: true;
+    isNotNull?: true;
+    NOT?: RelationsFieldFilter<T>;
+    OR?: RelationsFieldFilter<T>[];
+};
+export type RelationsFieldFilter<T = unknown> = RelationFieldsFilterInternals<T> | (unknown extends T ? never : T extends object ? never : T);
+export type RelationsFilter<TTable extends Table | View = Table | View, TColumns extends FieldSelection = TTable extends View ? Assume<TTable['_']['selectedFields'], FieldSelection> : Assume<TTable, Table>['_']['columns']> = {
+    [K in keyof TColumns]?: TColumns[K] extends Column ? RelationsFieldFilter<TColumns[K]['_']['data']> : RelationsFieldFilter<unknown>;
+} & {
+    OR?: RelationsFilter<TTable, TColumns>[];
+    NOT?: RelationsFilter<TTable, TColumns>;
+    RAW?: (table: TTable, operators: Operators) => SQL;
+};
+export interface OneConfig<TSchema extends Record<string, Table | View>, TSourceColumns extends Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]]> | Readonly<RelationsBuilderColumnBase>, TTargetTableName extends string, TOptional extends boolean> {
+    from?: TSourceColumns | Writable<TSourceColumns>;
+    to?: TSourceColumns extends [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]] ? {
+        [K in keyof TSourceColumns]: RelationsBuilderColumnBase<TTargetTableName>;
+    } : RelationsBuilderColumnBase<TTargetTableName>;
+    where?: TSourceColumns extends [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]] ? RelationsFilter<TSchema[TSourceColumns[number]['_']['tableName']]> : RelationsFilter<TSchema[Assume<TSourceColumns, RelationsBuilderColumnBase>['_']['tableName']]>;
+    optional?: TOptional;
+    alias?: string;
+}
+export type AnyOneConfig = OneConfig<Record<string, Table | View>, Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]] | RelationsBuilderColumnBase<string, unknown>>, string, boolean>;
+export interface ManyConfig<TSchema extends Record<string, Table | View>, TSourceColumns extends Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]]> | Readonly<RelationsBuilderColumnBase>, TTargetTableName extends string> {
+    from?: TSourceColumns;
+    to?: TSourceColumns extends [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]] ? {
+        [K in keyof TSourceColumns]: RelationsBuilderColumnBase<TTargetTableName>;
+    } : RelationsBuilderColumnBase<TTargetTableName>;
+    where?: TSourceColumns extends [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]] ? RelationsFilter<TSchema[TSourceColumns[number]['_']['tableName']]> : RelationsFilter<TSchema[Assume<TSourceColumns, RelationsBuilderColumnBase>['_']['tableName']]>;
+    alias?: string;
+}
+export type AnyManyConfig = ManyConfig<Record<string, Table | View>, Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]]> | Readonly<RelationsBuilderColumnBase>, string>;
+export interface OneFn<TTables extends Record<string, Table | View>, TTargetTableName extends string> {
+    <TSourceColumns extends Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]]> | RelationsBuilderColumnBase = any, TOptional extends boolean = true>(config?: OneConfig<TTables, TSourceColumns, TTargetTableName, TOptional>): One<TSourceColumns extends [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]] ? TSourceColumns[number]['_']['tableName'] : Assume<TSourceColumns, RelationsBuilderColumnBase>['_']['tableName'], TTargetTableName, TOptional>;
+}
+export interface ManyFn<TTables extends Record<string, Table | View>, TTargetTableName extends string> {
+    <TSourceColumns extends Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]]> | RelationsBuilderColumnBase = any>(config?: ManyConfig<TTables, TSourceColumns, TTargetTableName>): Many<TSourceColumns extends [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]] ? TSourceColumns[number]['_']['tableName'] : Assume<TSourceColumns, RelationsBuilderColumnBase>['_']['tableName'], TTargetTableName>;
+}
+export declare class RelationsHelperStatic<TTables extends Record<string, Table | View>> {
+    static readonly [entityKind]: string;
+    readonly $brand: 'RelationsHelperStatic';
+    readonly _: {
+        readonly tables: TTables;
+    };
+    constructor(tables: TTables);
+    one: {
+        [K in keyof TTables]: OneFn<TTables, K & string>;
+    };
+    many: {
+        [K in keyof TTables]: ManyFn<TTables, K & string>;
+    };
+}
+export type RelationsBuilder<TSchema extends Record<string, Table | View>> = {
+    [TTableName in keyof TSchema & string]: TSchema[TTableName] extends Table | View<string, boolean, FieldSelection> ? ({
+        [TColumnName in keyof (TSchema[TTableName] extends Table ? TSchema[TTableName]['_']['columns'] : Assume<TSchema[TTableName], View>['_']['selectedFields'])]: RelationsBuilderColumn<TTableName, (TSchema[TTableName] extends Table ? TSchema[TTableName]['_']['columns'] : Assume<Assume<TSchema[TTableName], View>['_']['selectedFields'], FieldSelection>)[TColumnName] extends infer Field ? Field extends Column ? Field['_']['data'] : Field extends SQLWrapper<infer Data> | SQL<infer Data> | SQL.Aliased<infer Data> ? Data : never : never>;
+    } & RelationsBuilderTable<TTableName>) : DrizzleTypeError<'Views with nested selections are not supported by the relational query builder'>;
+} & RelationsHelperStatic<TSchema>;
+export type RelationsBuilderConfig<TTables extends Record<string, Table | View>> = {
+    [TTableName in keyof TTables & string]?: TTables[TTableName] extends Table | View<string, boolean, FieldSelection> ? Record<string, RelationsBuilderEntry<TTables, TTableName>> : DrizzleTypeError<'Views with nested selections are not supported by the relational query builder'>;
+};
+export type RelationsBuilderEntry<TTables extends Record<string, Table | View> = Record<string, Table | View>, TSourceTableName extends string = string> = Relation<TSourceTableName, keyof TTables & string> | AggregatedField<any>;
+export type ExtractTablesFromSchema<TSchema extends Record<string, unknown>> = {
+    [K in keyof TSchema as TSchema[K] extends Table | View ? K : never]: TSchema[K] extends Table | View ? TSchema[K] : never;
+};
+export declare function createRelationsHelper<TSchema extends Record<string, unknown>, TTables extends Record<string, Table | View>>(schema: TSchema): RelationsBuilder<TTables>;
+export declare function defineRelations<TSchema extends Record<string, unknown>, TConfig extends RelationsBuilderConfig<TTables>, TTables extends Record<string, Table | View> = ExtractTablesFromSchema<TSchema>>(schema: TSchema, relations: (helpers: RelationsBuilder<TTables>) => TConfig): Relations<TSchema, TTables, TConfig>;
+export type WithContainer<TRelatedTables extends Record<string, Table> = Record<string, Table>> = {
+    with?: {
+        [K in keyof TRelatedTables]?: boolean | DBQueryConfig;
+    };
+};
+export type ColumnWithTSName = {
+    column: Column | SQL | SQLWrapper | SQL.Aliased;
+    tsName: string;
+};
+export type RelationsOrder<TColumns extends FieldSelection> = {
+    [K in keyof TColumns]?: 'asc' | 'desc';
+};
+export type OrderBy = Exclude<DBQueryConfig['orderBy'], undefined>;
+export type Extras = Exclude<DBQueryConfig['extras'], undefined>;
+export declare function relationsFilterToSQL(table: Table | View, filter: RelationsFilter): SQL | undefined;
+export declare function relationsOrderToSQL(table: Table | View, orders: OrderBy): SQL | undefined;
+export declare function relationExtrasToSQL(table: Table | View, extras: Extras): {
+    sql: SQL<unknown> | undefined;
     selection: {
-        dbKey: string;
-        tsKey: string;
-        field: TColumn | SQL | SQL.Aliased;
-        relationTableTsKey: string | undefined;
-        isJson: boolean;
-        isExtra?: boolean;
-        selection: BuildRelationalQueryResult<TTable>['selection'];
+        key: string;
+        field: Column | Table | SQL | SQL.Aliased | SQLWrapper | AggregatedField;
+        isArray?: boolean;
+        selection?: BuildRelationalQueryResult["selection"];
+        isOptional?: boolean;
     }[];
-    sql: TTable | SQL;
-}
-export declare function mapRelationalRow(tablesConfig: TablesRelationalConfig, tableConfig: TableRelationalConfig, row: unknown[], buildQueryResultSelection: BuildRelationalQueryResult['selection'], mapColumnValue?: (value: unknown) => unknown): Record<string, unknown>;
+};
+export type BuiltRelationFilters = {
+    filter?: SQL;
+    joinCondition?: SQL;
+};
+export declare function relationToSQL(relation: Relation, sourceTable: Table | View, targetTable: Table | View, throughTable?: Table | View): BuiltRelationFilters;
+export declare function getTableAsAliasSQL(table: Table | View): SQL<unknown>;
+export {};