drizzle-orm 0.36.4-7fe6033 → 0.36.4-dbf7383

package/relations.d.ts

@@ -2,70 +2,80 @@ 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;
+import { type Placeholder, SQL, sql, type SQLWrapper } from "./sql/sql.js";
+import { type Assume, type Equal, type Simplify, type ValueOrArray, type Writable } from "./utils.js";
+export declare class Relations<TSchema extends Record<string, unknown> = Record<string, unknown>, TTables extends Record<string, Table> = Record<string, Table>, TConfig extends RelationsBuilderConfig<TTables> = RelationsBuilderConfig<TTables>> {
+    readonly schema: TSchema;
+    readonly tables: TTables;
+    readonly config: TConfig;
+    static readonly [entityKind]: string;
+    readonly $brand: 'Relations';
+    /** 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;
     }>;
-    readonly relationName: string | undefined;
     static readonly [entityKind]: string;
     readonly $brand: 'Relation';
-    readonly referencedTableName: TTableName;
     fieldName: string;
-    constructor(sourceTable: Table, referencedTable: AnyTable<{
-        name: TTableName;
-    }>, relationName: string | undefined);
-    abstract withFieldName(fieldName: string): Relation<TTableName>;
-}
-export declare class Relations<TTableName extends string = string, TConfig extends Record<string, Relation> = Record<string, Relation>> {
-    readonly table: AnyTable<{
-        name: TTableName;
+    sourceColumns: AnyColumn<{
+        tableName: TSourceTableName;
+    }>[];
+    targetColumns: AnyColumn<{
+        tableName: TTargetTableName;
+    }>[];
+    alias: string | undefined;
+    where: RelationsFilter<Record<string, Column>> | undefined;
+    sourceTable: AnyTable<{
+        name: TSourceTableName;
     }>;
-    readonly config: (helpers: TableRelationsHelpers<TTableName>) => TConfig;
-    static readonly [entityKind]: string;
-    readonly $brand: 'Relations';
-    constructor(table: AnyTable<{
-        name: TTableName;
-    }>, config: (helpers: TableRelationsHelpers<TTableName>) => TConfig);
+    constructor(targetTable: AnyTable<{
+        name: TTargetTableName;
+    }>);
 }
-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 One<TSourceTableName extends string, TTargetTableName extends string, TOptional extends boolean = boolean> extends Relation<TSourceTableName, TTargetTableName> {
     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>;
+    readonly optional: TOptional;
+    constructor(targetTable: AnyTable<{
+        name: TTargetTableName;
+    }>, config: AnyOneConfig | undefined);
 }
-export declare class Many<TTableName extends string> extends Relation<TTableName> {
-    readonly config: {
-        relationName: string;
-    } | undefined;
+export declare class Many<TSourceTableName extends string, TTargetTableName extends string> extends Relation<TSourceTableName, TTargetTableName> {
+    readonly config: AnyManyConfig | undefined;
     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;
-}>;
+    constructor(targetTable: AnyTable<{
+        name: TTargetTableName;
+    }>, config: AnyManyConfig | undefined);
+}
+export declare abstract class AggregatedField<T = unknown> implements SQLWrapper<T> {
+    static readonly [entityKind]: string;
+    readonly $brand: 'AggregatedField';
+    readonly _: {
+        readonly data: T;
+    };
+    protected table: Table | undefined;
+    onTable(table: Table): 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,7 +99,12 @@ 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;
@@ -97,57 +112,67 @@ export declare function getOrderByOperators(): {
 };
 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];
+    [K in keyof TSchema as TSchema[K]['table']['_']['name'] extends TTableName ? K : never]: TSchema[K];
+}>;
+export type FindTableInRelationsConfig<TSchema extends TablesRelationalConfig, TTargetTable extends Table, TTableName extends string = TTargetTable['_']['name'], TSchemaName extends string | undefined = TTargetTable['_']['schema'] extends undefined ? undefined : TTargetTable['_']['schema']> = ExtractObjectValues<{
+    [K in keyof TSchema as TSchema[K]['dbName'] extends TTableName ? TSchema[K]['schema'] extends undefined ? TSchemaName extends undefined ? K : never : TSchemaName extends TSchema[K]['schema'] ? K : never : 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> = {
+    config?: TTableConfig['relations'];
     columns?: {
-        [K in keyof TTableConfig['columns']]?: boolean;
+        [K in keyof TTableConfig['columns']]?: true;
+    } | {
+        [K in keyof TTableConfig['columns']]?: false;
     };
     with?: {
-        [K in keyof TTableConfig['relations']]?: true | DBQueryConfig<TTableConfig['relations'][K] extends One ? 'one' : 'many', false, TSchema, FindTableByDBName<TSchema, TTableConfig['relations'][K]['referencedTableName']>>;
+        [K in keyof TTableConfig['relations']]?: true | (TTableConfig['relations'][K] extends Relation ? DBQueryConfig<TTableConfig['relations'][K] extends One<string, string> ? 'one' : 'many', TSchema, FindTableInRelationsConfig<TSchema, TTableConfig['relations'][K]['targetTable']>> : never);
     };
-    extras?: Record<string, SQL.Aliased> | ((fields: Simplify<[
-        TTableConfig['columns']
-    ] extends [never] ? {} : TTableConfig['columns']>, operators: {
-        sql: Operators['sql'];
-    }) => Record<string, SQL.Aliased>);
-} & (TRelationType extends 'many' ? {
-    where?: SQL | undefined | ((fields: Simplify<[
+    extras?: Record<string, SQLWrapper> | ((fields: Simplify<[
         TTableConfig['columns']
-    ] extends [never] ? {} : TTableConfig['columns']>, operators: Operators) => SQL | undefined);
+    ] extends [never] ? {} : TTableConfig['columns']>, operators: SQLOperator) => Record<string, SQLWrapper>);
+    offset?: number | Placeholder;
+    where?: RelationsFilter<TTableConfig['columns']>;
     orderBy?: ValueOrArray<AnyColumn | SQL> | ((fields: Simplify<[
         TTableConfig['columns']
     ] extends [never] ? {} : TTableConfig['columns']>, operators: OrderByOperators) => ValueOrArray<AnyColumn | SQL>);
+} & (TRelationType extends 'many' ? {
     limit?: number | Placeholder;
-} & (TIsRoot extends true ? {
-    offset?: number | Placeholder;
-} : {}) : {});
+} : {});
 export interface TableRelationalConfig {
+    table: Table;
     tsName: string;
     dbName: string;
     columns: Record<string, Column>;
-    relations: Record<string, Relation>;
+    relations: Record<string, RelationsBuilderEntry>;
     primaryKey: AnyColumn[];
     schema?: string;
 }
 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> = 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']>;
+        dbName: TTables[K]['_']['name'];
+        columns: TTables[K]['_']['columns'];
+        relations: K extends keyof TRelations['config'] ? TRelations['config'][K] extends Record<string, any> ? NonUndefinedRecord<TRelations['config'][K]> : Record<string, never> : Record<string, never>;
         primaryKey: AnyColumn[];
-    } : never;
+        schema: TTables[K]['_']['schema'];
+    };
 };
 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 NonUndefinedKeysOnly<TInclude> & keyof TRelations]: TRelations[K] extends infer TRel extends Relation ? BuildQueryResult<TConfig, FindTableInRelationsConfig<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 : 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;
@@ -157,59 +182,170 @@ export type BuildQueryResult<TSchema extends TablesRelationalConfig, TTableConfi
         [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'];
+    [K in NonUndefinedKeysOnly<ReturnTypeOrValue<TFullSelection['extras']>>]: Assume<ReturnTypeOrValue<TFullSelection['extras']>[K], SQL>['_']['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 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 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'];
+    }[];
+    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): 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;
+        }>;
+    };
+    constructor(table: AnyTable<{
+        name: TTableName;
+    }>);
+    getSQL(): SQL;
+}
+export type RelationsBuilderColumnConfig<TTableName extends string = string, TData = unknown> = {
+    readonly tableName: TTableName;
+    readonly data: TData;
+    readonly column: AnyColumn<{
         tableName: TTableName;
-    }>, ...AnyColumn<{
+    }>;
+    through?: RelationsBuilderColumnBase;
+};
+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;
+        }>;
+        through?: RelationsBuilderColumnBase;
+    };
+    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;
+    }>);
+    through(column: RelationsBuilderColumnBase<string, TData>): Omit<this, 'through'>;
+    getSQL(): SQL;
+}
+export type RelationFieldsFilterInternals<T> = {
+    eq?: T;
+    ne?: T;
+    gt?: T;
+    gte?: T;
+    lt?: T;
+    lte?: T;
+    in?: T[];
+    notIn?: T[];
+    like?: string;
+    ilike?: string;
+    notLike?: string;
+    notIlike?: string;
+    isNull?: true;
+    isNotNull?: true;
+    $not?: RelationsFieldFilter<T>;
+    $or?: RelationsFieldFilter<T>[];
+};
+export type RelationsFieldFilter<T> = T | RelationFieldsFilterInternals<T>;
+export type RelationsFilter<TColumns extends Record<string, Column>> = {
+    [K in keyof TColumns]?: RelationsFieldFilter<TColumns[K]['_']['data']>;
+} & {
+    $or?: RelationsFilter<TColumns>[];
+    $not?: RelationsFilter<TColumns>[];
+    $raw?: (operators: Operators) => SQL;
+};
+export interface OneConfig<TSchema extends Record<string, Table>, 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']]['_']['columns']> : RelationsFilter<TSchema[Assume<TSourceColumns, RelationsBuilderColumnBase>['_']['tableName']]['_']['columns']>;
+    optional?: TOptional;
+    alias?: string;
+}
+export type AnyOneConfig = OneConfig<Record<string, Table>, Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]] | RelationsBuilderColumnBase<string, unknown>>, string, boolean>;
+export interface ManyConfig<TSchema extends Record<string, Table>, 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']]['_']['columns']> : RelationsFilter<TSchema[Assume<TSourceColumns, RelationsBuilderColumnBase>['_']['tableName']]['_']['columns']>;
+    alias?: string;
+}
+export type AnyManyConfig = ManyConfig<Record<string, Table>, Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]]> | Readonly<RelationsBuilderColumnBase>, string>;
+export interface OneFn<TTables extends Record<string, Table>, TTargetTableName extends string> {
+    <TSourceColumns extends Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]]> | RelationsBuilderColumnBase = any, TOptional extends boolean = false>(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>, 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>> {
+    static readonly [entityKind]: string;
+    readonly $brand: 'RelationsHelperStatic';
+    readonly _: {
+        readonly tables: TTables;
+    };
+    constructor(tables: TTables);
+    one: {
+        [K in keyof TTables]: OneFn<TTables, TTables[K]['_']['name']>;
+    };
+    many: {
+        [K in keyof TTables]: ManyFn<TTables, TTables[K]['_']['name']>;
+    };
+    aggs: {
+        count(): Count;
+    };
+}
+export type RelationsBuilder<TSchema extends Record<string, Table>> = {
+    [TTableName in keyof TSchema & string]: {
+        [TColumnName in keyof TSchema[TTableName]['_']['columns']]: RelationsBuilderColumn<TTableName, TSchema[TTableName]['_']['columns'][TColumnName]['_']['data']>;
+    } & RelationsBuilderTable<TTableName>;
+} & RelationsHelperStatic<TSchema>;
+export type RelationsBuilderConfig<TTables extends Record<string, Table>> = {
+    [TTableName in keyof TTables & string]?: Record<string, RelationsBuilderEntry<TTables, TTableName>>;
+};
+export type RelationsBuilderEntry<TTables extends Record<string, Table> = Record<string, Table>, 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 ? K : never]: TSchema[K] extends Table ? TSchema[K] : never;
+};
+export declare function createRelationsHelper<TSchema extends Record<string, unknown>, TTables extends Record<string, Table>>(schema: TSchema): RelationsBuilder<TTables>;
+export declare function defineRelations<TSchema extends Record<string, unknown>, TConfig extends RelationsBuilderConfig<TTables>, TTables extends Record<string, Table> = ExtractTablesFromSchema<TSchema>>(schema: TSchema, relations: (helpers: RelationsBuilder<TTables>) => TConfig): Relations<TSchema, TTables, TConfig>;
+export type WithContainer<TRelatedTables extends Record<string, Table>> = {
+    with?: {
+        [K in keyof TRelatedTables]?: boolean | DBQueryConfig;
+    };
+};
+export type ColumnWithTSName = {
+    column: Column;
+    tsName: string;
+};
+export type RelationsOrder<TColumns extends Record<string, Column>> = {
+    [K in keyof TColumns]?: 'asc' | 'desc';
+};
+export type OrderBy = ValueOrArray<AnyColumn | SQL> | ((fields: Record<string, Column>, operators: OrderByOperators) => ValueOrArray<AnyColumn | SQL>);
+export type Extras = Record<string, SQL> | ((fields: Record<string, Column>, operators: SQLOperator) => Record<string, SQL>);
+export declare function relationFilterToSQL(table: Table, filter: RelationsFilter<Record<string, Column>>): SQL | undefined;
+export declare function relationsOrderToSQL(table: Table, orders: ValueOrArray<AnyColumn | SQL> | ((fields: Record<string, Column>, operators: OrderByOperators) => ValueOrArray<AnyColumn | SQL>)): SQL | undefined;
+export declare function relationExtrasToSQL(table: Table, extras: Record<string, SQLWrapper> | ((columns: Record<string, Column>, operators: SQLOperator) => Record<string, SQLWrapper>)): {
+    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"];
     }[];
-    sql: TTable | SQL;
-}
-export declare function mapRelationalRow(tablesConfig: TablesRelationalConfig, tableConfig: TableRelationalConfig, row: unknown[], buildQueryResultSelection: BuildRelationalQueryResult['selection'], mapColumnValue?: (value: unknown) => unknown): Record<string, unknown>;
+};
+export declare function relationToSQL(relation: Relation): SQL | undefined;
+export {};