drizzle-orm 0.38.4-e36471e → 0.39.0-0cc153d

package/relations.d.ts

@@ -2,9 +2,11 @@ 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, 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>> {
+import { type Placeholder, SQL, sql, type SQLWrapper, View } from "./sql/sql.js";
+import type { Assume, 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;
@@ -20,7 +22,7 @@ export type AnyRelations = Relations<Record<string, any>, Record<string, any>, R
 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: 'RelationV2';
     fieldName: string;
@@ -31,35 +33,35 @@ export declare abstract class Relation<TSourceTableName extends string = string,
         tableName: TTargetTableName;
     }>[];
     alias: string | undefined;
-    where: RelationsFilter<Record<string, Column>> | undefined;
+    where: RelationsFilter | undefined;
     sourceTable: AnyTable<{
         name: TSourceTableName;
-    }>;
+    }> | View<TSourceTableName>;
     through?: {
-        source: AnyColumn[];
-        target: AnyColumn[];
+        source: RelationsBuilderColumnBase[];
+        target: RelationsBuilderColumnBase[];
     };
-    throughTable?: Table;
+    throughTable?: Table | View;
     isReversed?: boolean;
     constructor(targetTable: AnyTable<{
         name: TTargetTableName;
-    }>);
+    }> | View<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<{
+    constructor(tables: Record<string, Table | View>, targetTable: AnyTable<{
         name: TTargetTableName;
-    }>, config: AnyOneConfig | undefined);
+    }> | View<TTargetTableName>, config: AnyOneConfig | 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: 'ManyV2';
-    constructor(targetTable: AnyTable<{
+    constructor(tables: Record<string, Table | View>, targetTable: AnyTable<{
         name: TTargetTableName;
-    }>, config: AnyManyConfig | undefined);
+    }> | View<TTargetTableName>, config: AnyManyConfig | undefined);
 }
 export declare abstract class AggregatedField<T = unknown> implements SQLWrapper<T> {
     static readonly [entityKind]: string;
@@ -67,8 +69,8 @@ export declare abstract class AggregatedField<T = unknown> implements SQLWrapper
     readonly _: {
         readonly data: T;
     };
-    protected table: Table | undefined;
-    onTable(table: Table): this;
+    protected table: Table | View | undefined;
+    onTable(table: Table | View): this;
     abstract getSQL(): SQL<T>;
 }
 export declare class Count extends AggregatedField<number> {
@@ -117,7 +119,7 @@ export declare function getOrderByOperators(): {
     desc: typeof desc;
 };
 export type OrderByOperators = ReturnType<typeof getOrderByOperators>;
-export type FindTableInRelationalConfig<TSchema extends TablesRelationalConfig, TTargetTable extends Table, TTableName extends string = TTargetTable['_']['name']> = ExtractObjectValues<{
+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 SQLOperator = {
@@ -130,23 +132,22 @@ export type DBQueryConfig<TRelationType extends 'one' | 'many' = 'one' | 'many',
     with?: {
         [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, SQLWrapper> | ((table: Simplify<AnyTable<TTableConfig> & TTableConfig['columns']>, operators: SQLOperator) => Record<string, SQLWrapper>) | undefined;
-    offset?: number | Placeholder | undefined;
-    where?: RelationsFilter<TTableConfig['columns']> | 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;
-    } | ((fields: Simplify<AnyTable<TTableConfig> & TTableConfig['columns']>, operators: OrderByOperators) => ValueOrArray<AnyColumn | SQL>) | undefined;
+    } | ((table: TTableConfig['table'], operators: OrderByOperators) => ValueOrArray<AnyColumn | SQL>) | undefined;
+    offset?: number | Placeholder | undefined;
 } & (TRelationType extends 'many' ? {
     limit?: number | Placeholder | undefined;
 } : {});
 export interface TableRelationalConfig {
-    table: Table;
+    table: Table | View;
     tsName: string;
     dbName: string;
-    columns: Record<string, Column>;
-    relations: Record<string, RelationsBuilderEntry>;
-    primaryKey: AnyColumn[];
     schema: string | undefined;
+    columns: FieldSelection;
+    relations: Record<string, RelationsBuilderEntry>;
 }
 export type TablesRelationalConfig = Record<string, TableRelationalConfig>;
 export interface RelationalSchemaConfig<TTablesConfig extends TablesRelationalConfig> {
@@ -157,15 +158,14 @@ export interface RelationalSchemaConfig<TTablesConfig extends TablesRelationalCo
 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']> = {
+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: TTables[K]['_']['name'];
-        columns: TTables[K]['_']['columns'];
+        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>;
-        primaryKey: AnyColumn[];
-        schema: TTables[K]['_']['schema'];
+        schema: TTables[K] extends Table ? TTables[K]['_']['schema'] : string | undefined;
     };
 };
 export type ReturnTypeOrValue<T> = T extends (...args: any[]) => infer R ? R : T;
@@ -178,11 +178,20 @@ export type NonUndefinedKeysOnly<T> = ExtractObjectValues<{
 export type TruthyKeysOnly<T> = ExtractObjectValues<{
     [K in keyof T as T[K] extends undefined | false ? 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>) ? {
+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 type InferRelationalQueryTableResult<TRawSelection extends Record<string, unknown>, TSelectedFields extends Record<string, unknown> | undefined = undefined, TFilteredSelection extends Record<string, unknown> = TSelectedFields extends undefined ? 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'] : undefined>) & (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 {
@@ -208,11 +217,11 @@ export declare class RelationsBuilderTable<TTableName extends string = string> i
         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> = {
@@ -220,8 +229,9 @@ export type RelationsBuilderColumnConfig<TTableName extends string = string, TDa
     readonly data: TData;
     readonly column: AnyColumn<{
         tableName: TTableName;
-    }>;
+    }> | 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>;
@@ -233,12 +243,13 @@ export declare class RelationsBuilderColumn<TTableName extends string = string,
         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;
-    }>, through?: RelationsBuilderColumn);
+    }> | SQL<TData> | SQLWrapper<TData> | SQL.Aliased<TData>, tableName: TTableName, key: string, through?: RelationsBuilderColumn);
     through(column: RelationsBuilderColumn): RelationsBuilderColumnBase<TTableName, TData>;
     getSQL(): SQL;
 }
@@ -260,42 +271,40 @@ export type RelationFieldsFilterInternals<T> = {
     NOT?: RelationsFieldFilter<T>;
     OR?: RelationsFieldFilter<T>[];
 };
-export type RelationsFieldFilter<T> = RelationFieldsFilterInternals<T> | (T extends Record<string, any> ? never : T);
-export type RelationsFilter<TColumns extends Record<string, Column>> = {
-    [K in keyof TColumns]?: RelationsFieldFilter<TColumns[K]['_']['data']>;
+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<TColumns>[];
-    NOT?: RelationsFilter<TColumns>;
-    RAW?: (table: Simplify<AnyTable<{
-        columns: TColumns;
-    }> & TColumns>, operators: Operators) => SQL;
+    OR?: RelationsFilter<TTable, TColumns>[];
+    NOT?: RelationsFilter<TTable, TColumns>;
+    RAW?: (table: TTable, operators: Operators) => SQL;
 };
-export interface OneConfig<TSchema extends Record<string, Table>, TSourceColumns extends Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]]> | Readonly<RelationsBuilderColumnBase>, TTargetTableName extends string, TOptional extends boolean> {
+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']]['_']['columns']> : RelationsFilter<TSchema[Assume<TSourceColumns, RelationsBuilderColumnBase>['_']['tableName']]['_']['columns']>;
+    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>, 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> {
+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']]['_']['columns']> : RelationsFilter<TSchema[Assume<TSourceColumns, RelationsBuilderColumnBase>['_']['tableName']]['_']['columns']>;
+    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>, Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]]> | Readonly<RelationsBuilderColumnBase>, string>;
-export interface OneFn<TTables extends Record<string, Table>, TTargetTableName extends 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>, TTargetTableName extends string> {
+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>> {
+export declare class RelationsHelperStatic<TTables extends Record<string, Table | View>> {
     static readonly [entityKind]: string;
     readonly $brand: 'RelationsHelperStatic';
     readonly _: {
@@ -312,37 +321,37 @@ export declare class RelationsHelperStatic<TTables extends Record<string, Table>
         count(): Count;
     };
 }
-export type RelationsBuilder<TSchema extends Record<string, Table>> = {
+export type RelationsBuilder<TSchema extends Record<string, Table | View>> = {
     [TTableName in keyof TSchema & string]: {
-        [TColumnName in keyof TSchema[TTableName]['_']['columns']]: RelationsBuilderColumn<TTableName, TSchema[TTableName]['_']['columns'][TColumnName]['_']['data']>;
+        [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>;
 } & RelationsHelperStatic<TSchema>;
-export type RelationsBuilderConfig<TTables extends Record<string, Table>> = {
+export type RelationsBuilderConfig<TTables extends Record<string, Table | View>> = {
     [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 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 ? K : never]: TSchema[K] extends Table ? TSchema[K] : never;
+    [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>>(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 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;
+    column: Column | SQL | SQLWrapper | SQL.Aliased;
     tsName: string;
 };
-export type RelationsOrder<TColumns extends Record<string, Column>> = {
+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, 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): {
+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: {
         key: string;
@@ -356,5 +365,6 @@ export type BuiltRelationFilters = {
     filter?: SQL;
     joinCondition?: SQL;
 };
-export declare function relationToSQL(relation: Relation, sourceTable: Table, targetTable: Table, throughTable?: Table): BuiltRelationFilters;
+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 {};