drizzle-orm 0.38.3-7db411e → 0.38.3-8e428d1

package/relations.d.cts

@@ -2,80 +2,70 @@ import { type AnyTable, type InferModelFromColumns, Table } from "./table.cjs";
 import { type AnyColumn, Column } from "./column.cjs";
 import { entityKind } from "./entity.cjs";
 import { and, asc, between, desc, exists, ilike, inArray, isNotNull, isNull, like, not, notBetween, notExists, notIlike, notInArray, notLike, or } from "./sql/expressions/index.cjs";
-import { Placeholder, SQL, sql, type SQLWrapper } from "./sql/sql.cjs";
-import { type Assume, type Equal, type Simplify, type ValueOrArray, type Writable } from "./utils.cjs";
-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: '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;
+import { type Placeholder, SQL, sql } from "./sql/sql.cjs";
+import type { Assume, ColumnsWithTable, Equal, Simplify, ValueOrArray } from "./utils.cjs";
+export declare abstract class Relation<TTableName extends string = string> {
+    readonly sourceTable: Table;
+    readonly referencedTable: AnyTable<{
+        name: TTableName;
     }>;
+    readonly relationName: string | undefined;
     static readonly [entityKind]: string;
-    readonly $brand: 'RelationV2';
+    readonly $brand: 'Relation';
+    readonly referencedTableName: TTableName;
     fieldName: string;
-    sourceColumns: AnyColumn<{
-        tableName: TSourceTableName;
-    }>[];
-    targetColumns: AnyColumn<{
-        tableName: TTargetTableName;
-    }>[];
-    alias: string | undefined;
-    where: RelationsFilter<Record<string, Column>> | undefined;
-    sourceTable: AnyTable<{
-        name: TSourceTableName;
-    }>;
-    constructor(targetTable: AnyTable<{
-        name: TTargetTableName;
-    }>);
-}
-export declare class One<TSourceTableName extends string, TTargetTableName extends string, TOptional extends boolean = boolean> extends Relation<TSourceTableName, TTargetTableName> {
-    static readonly [entityKind]: string;
-    protected $relationBrand: 'OneV2';
-    readonly optional: TOptional;
-    constructor(targetTable: AnyTable<{
-        name: TTargetTableName;
-    }>, config: AnyOneConfig | undefined);
+    constructor(sourceTable: Table, referencedTable: AnyTable<{
+        name: TTableName;
+    }>, relationName: string | undefined);
+    abstract withFieldName(fieldName: string): Relation<TTableName>;
 }
-export declare class Many<TSourceTableName extends string, TTargetTableName extends string> extends Relation<TSourceTableName, TTargetTableName> {
-    readonly config: AnyManyConfig | undefined;
+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;
     static readonly [entityKind]: string;
-    protected $relationBrand: 'ManyV2';
-    constructor(targetTable: AnyTable<{
-        name: TTargetTableName;
-    }>, config: AnyManyConfig | undefined);
+    readonly $brand: 'Relations';
+    constructor(table: AnyTable<{
+        name: TTableName;
+    }>, config: (helpers: TableRelationsHelpers<TTableName>) => TConfig);
 }
-export declare abstract class AggregatedField<T = unknown> implements SQLWrapper<T> {
+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;
     static readonly [entityKind]: string;
-    readonly $brand: 'AggregatedField';
-    readonly _: {
-        readonly data: T;
-    };
-    protected table: Table | undefined;
-    onTable(table: Table): this;
-    abstract getSQL(): SQL<T>;
+    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>;
 }
-export declare class Count extends AggregatedField<number> {
+export declare class Many<TTableName extends string> extends Relation<TTableName> {
+    readonly config: {
+        relationName: string;
+    } | undefined;
     static readonly [entityKind]: string;
-    protected $aggregatedFieldBrand: 'Count';
-    private query;
-    getSQL(): SQL<number>;
-}
+    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;
+}>;
 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 const operators: {
+export declare function getOperators(): {
     and: typeof and;
     between: typeof between;
     eq: import("./expressions.ts").BinaryOperator;
@@ -99,72 +89,65 @@ export declare const operators: {
     or: typeof or;
     sql: typeof sql;
 };
-export type Operators = typeof operators;
-export declare const orderByOperators: {
-    sql: typeof sql;
-    asc: typeof asc;
-    desc: typeof desc;
-};
+export type Operators = ReturnType<typeof getOperators>;
 export declare function getOrderByOperators(): {
     sql: typeof sql;
     asc: typeof asc;
     desc: typeof desc;
 };
 export type OrderByOperators = ReturnType<typeof getOrderByOperators>;
-export type FindTableInRelationalConfig<TSchema extends TablesRelationalConfig, TTargetTable extends Table, TTableName extends string = TTargetTable['_']['name']> = ExtractObjectValues<{
-    [K in keyof TSchema as TSchema[K]['tsName'] extends TTableName ? K : never]: TSchema[K];
+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 SQLOperator = {
-    sql: Operators['sql'];
-};
-export type DBQueryConfig<TRelationType extends 'one' | 'many' = 'one' | 'many', TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig> = {
+export type DBQueryConfig<TRelationType extends 'one' | 'many' = 'one' | 'many', TIsRoot extends boolean = boolean, TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig> = {
     columns?: {
-        [K in keyof TTableConfig['columns']]?: boolean | undefined;
+        [K in keyof TTableConfig['columns']]?: boolean;
     } | undefined;
     with?: {
-        [K in keyof TTableConfig['relations']]?: true | (TTableConfig['relations'][K] extends Relation ? DBQueryConfig<TTableConfig['relations'][K] extends One<string, string> ? 'one' : 'many', TSchema, FindTableInRelationalConfig<TSchema, TTableConfig['relations'][K]['targetTable']>> : never) | undefined;
+        [K in keyof TTableConfig['relations']]?: true | DBQueryConfig<TTableConfig['relations'][K] extends One ? 'one' : 'many', false, TSchema, FindTableByDBName<TSchema, TTableConfig['relations'][K]['referencedTableName']>> | undefined;
     } | undefined;
-    extras?: Record<string, SQLWrapper> | ((table: Simplify<AnyTable<TTableConfig> & TTableConfig['columns']>, operators: SQLOperator) => Record<string, SQLWrapper>) | undefined;
-    offset?: number | Placeholder | undefined;
-    where?: RelationsFilter<TTableConfig['columns']> | undefined;
-    orderBy?: {
-        [K in keyof TTableConfig['columns']]?: 'asc' | 'desc' | undefined;
-    } | ((fields: Simplify<AnyTable<TTableConfig> & TTableConfig['columns']>, operators: OrderByOperators) => ValueOrArray<AnyColumn | SQL>) | undefined;
+    extras?: Record<string, SQL.Aliased> | ((fields: Simplify<[
+        TTableConfig['columns']
+    ] extends [never] ? {} : TTableConfig['columns']>, operators: {
+        sql: Operators['sql'];
+    }) => Record<string, SQL.Aliased>) | 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;
     tsName: string;
     dbName: string;
     columns: Record<string, Column>;
-    relations: Record<string, RelationsBuilderEntry>;
+    relations: Record<string, Relation>;
     primaryKey: AnyColumn[];
-    schema: string | undefined;
+    schema?: string;
 }
 export type TablesRelationalConfig = Record<string, TableRelationalConfig>;
-export interface RelationalSchemaConfig<TTablesConfig extends TablesRelationalConfig> {
-    tables: Record<string, Table>;
-    tablesConfig: TTablesConfig;
+export interface RelationalSchemaConfig<TSchema extends TablesRelationalConfig> {
+    fullSchema: Record<string, unknown>;
+    schema: TSchema;
     tableNamesMap: Record<string, string>;
 }
-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];
+export type ExtractTablesWithRelations<TSchema extends Record<string, unknown>> = {
+    [K in keyof TSchema as TSchema[K] extends Table ? K : never]: TSchema[K] extends Table ? {
         tsName: K & string;
-        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>;
+        dbName: TSchema[K]['_']['name'];
+        columns: TSchema[K]['_']['columns'];
+        relations: ExtractTableRelationsFromSchema<TSchema, TSchema[K]['_']['name']>;
         primaryKey: AnyColumn[];
-        schema: TTables[K]['_']['schema'];
-    };
+    } : never;
 };
 export type ReturnTypeOrValue<T> = T extends (...args: any[]) => infer R ? R : T;
-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, 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 : never) : TResult[] : never : TRelations[K] extends AggregatedField<infer TData> ? TData : never;
+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 NonUndefinedKeysOnly<T> = ExtractObjectValues<{
     [K in keyof T as T[K] extends undefined ? never : K]: K;
@@ -174,174 +157,59 @@ 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']>>]: ReturnType<Assume<ReturnTypeOrValue<TFullSelection['extras']>[K], SQLWrapper>['getSQL']>['_']['type'];
+    [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 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 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<{
+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<{
         tableName: TTableName;
-    }>;
-    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<{
+    }>, ...AnyColumn<{
         tableName: TTableName;
-    }>);
-    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 | Placeholder>;
-export type RelationsFilter<TColumns extends Record<string, Column>> = {
-    [K in keyof TColumns]?: RelationsFieldFilter<TColumns[K]['_']['data']>;
-} & {
-    OR?: RelationsFilter<TColumns>[];
-    NOT?: RelationsFilter<TColumns>;
-    RAW?: (table: Simplify<AnyTable<{
-        columns: TColumns;
-    }> & {
-        [K in keyof TColumns]: TColumns[K];
-    }>, 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, K & string>;
-    };
-    many: {
-        [K in keyof TTables]: ManyFn<TTables, K & string>;
-    };
-    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> = 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 = Exclude<DBQueryConfig['orderBy'], undefined>;
-export type Extras = Exclude<DBQueryConfig['extras'], undefined>;
-export declare function relationsFilterToSQL(table: Table, filter: RelationsFilter<Record<string, Column>>): SQL | undefined;
-export declare function relationsOrderToSQL(table: Table, orders: OrderBy): SQL | undefined;
-export declare function relationExtrasToSQL(table: Table, extras: Extras): {
-    sql: SQL<unknown> | undefined;
+    }>[]]>(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;
     selection: {
-        key: string;
-        field: Column | Table | SQL | SQL.Aliased | SQLWrapper | AggregatedField;
-        isArray?: boolean;
-        selection?: BuildRelationalQueryResult["selection"];
+        dbKey: string;
+        tsKey: string;
+        field: TColumn | SQL | SQL.Aliased;
+        relationTableTsKey: string | undefined;
+        isJson: boolean;
+        isExtra?: boolean;
+        selection: BuildRelationalQueryResult<TTable>['selection'];
     }[];
-};
-export declare function relationToSQL(relation: Relation, sourceTable: Table, targetTable: Table): SQL | undefined;
-export {};
+    sql: TTable | SQL;
+}
+export declare function mapRelationalRow(tablesConfig: TablesRelationalConfig, tableConfig: TableRelationalConfig, row: unknown[], buildQueryResultSelection: BuildRelationalQueryResult['selection'], mapColumnValue?: (value: unknown) => unknown): Record<string, unknown>;