@erfanium/drizzle-orm 1.0.0 → 1.0.1

package/relations.d.ts

@@ -1,400 +1,430 @@
-import { entityKind } from "./entity.js";
-import { BinaryOperator, and, arrayContained, arrayContains, arrayOverlaps, between, exists, ilike, inArray, isNotNull, isNull, like, not, notBetween, notExists, notIlike, notInArray, notLike, or } from "./sql/expressions/conditions.js";
-import { asc, desc } from "./sql/expressions/select.js";
-import { Assume, DrizzleTypeError, Equal, Simplify, ValueOrArray } from "./utils.js";
-import { CodecsCollection, NormalizeArrayCodec, NormalizeCodec } from "./codecs.js";
-import { CommentInput, Placeholder, SQL, SQLWrapper, View, sql } from "./sql/sql.js";
-import { AnyColumn, Column } from "./column.js";
-import { Table } from "./table.js";
-
-//#region src/relations.d.ts
-type FilteredSchemaEntry = Table<any> | View<string, boolean, FieldSelection>;
-type SchemaEntry = Table<any> | View<string, boolean, any>;
-type Schema = Record<string, SchemaEntry>;
-type GetTableViewColumns<T extends SchemaEntry> = T extends View<string, boolean, any> ? T['_']['selectedFields'] : T extends Table<any> ? T['_']['columns'] : never;
-type GetTableViewFieldSelection<T extends SchemaEntry> = T extends View<string, boolean, FieldSelection> ? T['_']['selectedFields'] : T extends Table<any> ? T['_']['columns'] : never;
-type FieldValue = Column<any> | SQLWrapper | SQL.Aliased | SQL;
-type FieldSelection = Record<string, FieldValue>;
-declare function processRelations(tablesConfig: TablesRelationalConfig, tables: Schema): TablesRelationalConfig;
+import { Table } from './table.js';
+import type { CodecsCollection, NormalizeArrayCodec, NormalizeCodec } from './codecs.js';
+import { type AnyColumn, Column } from './column.js';
+import { entityKind } from './entity.js';
+import { and, arrayContained, arrayContains, arrayOverlaps, asc, between, desc, exists, ilike, inArray, isNotNull, isNull, like, not, notBetween, notExists, notIlike, notInArray, notLike, or } from './sql/expressions/index.js';
+import { type CommentInput, Placeholder, SQL, sql, type SQLWrapper, View } from './sql/sql.js';
+import { type Assume, type DrizzleTypeError, type Equal, type Simplify, type ValueOrArray } from './utils.js';
+export type FilteredSchemaEntry = Table<any> | View<string, boolean, FieldSelection>;
+export type SchemaEntry = Table<any> | View<string, boolean, any>;
+export type Schema = Record<string, SchemaEntry>;
+export type GetTableViewColumns<T extends SchemaEntry> = T extends View<string, boolean, any> ? T['_']['selectedFields'] : T extends Table<any> ? T['_']['columns'] : never;
+export type GetTableViewFieldSelection<T extends SchemaEntry> = T extends View<string, boolean, FieldSelection> ? T['_']['selectedFields'] : T extends Table<any> ? T['_']['columns'] : never;
+export type FieldValue = Column<any> | SQLWrapper | SQL.Aliased | SQL;
+export type FieldSelection = Record<string, FieldValue>;
+export declare function processRelations(tablesConfig: TablesRelationalConfig, tables: Schema): TablesRelationalConfig;
 /** Builds relational config for every table in schema */
-declare function buildRelations<TTables extends Schema, TConfig extends AnyRelationsBuilderConfig>(tables: TTables, config: TConfig): ExtractTablesWithRelations<TConfig, TTables>;
+export declare function buildRelations<TTables extends Schema, TConfig extends AnyRelationsBuilderConfig>(tables: TTables, config: TConfig): ExtractTablesWithRelations<TConfig, TTables>;
 /** Builds relational config only for tables present in relational config */
-declare function buildRelationsParts<TTables extends Schema, TConfig extends AnyRelationsBuilderConfig>(tables: TTables, config: TConfig): ExtractTablesWithRelationsParts<TConfig, TTables>;
-type RelationsRecord = Record<string, AnyRelation>;
-type EmptyRelations = {};
-type AnyRelations = TablesRelationalConfig;
-declare abstract class Relation<TTargetTableName extends string = string> {
-  readonly targetTableName: TTargetTableName;
-  static readonly [entityKind]: string;
-  readonly $brand: 'RelationV2';
-  readonly relationType: 'many' | 'one';
-  fieldName: string;
-  sourceColumns: Column<any>[];
-  targetColumns: Column<any>[];
-  alias: string | undefined;
-  where: AnyTableFilter | undefined;
-  sourceTable: SchemaEntry;
-  targetTable: SchemaEntry;
-  through?: {
-    source: RelationsBuilderColumnBase[];
-    target: RelationsBuilderColumnBase[];
-  };
-  throughTable?: SchemaEntry;
-  isReversed?: boolean;
-  constructor(targetTable: SchemaEntry, targetTableName: TTargetTableName);
+export declare function buildRelationsParts<TTables extends Schema, TConfig extends AnyRelationsBuilderConfig>(tables: TTables, config: TConfig): ExtractTablesWithRelationsParts<TConfig, TTables>;
+export type RelationsRecord = Record<string, AnyRelation>;
+export type EmptyRelations = {};
+export type AnyRelations = TablesRelationalConfig;
+export declare abstract class Relation<TTargetTableName extends string = string> {
+    readonly targetTableName: TTargetTableName;
+    static readonly [entityKind]: string;
+    readonly $brand: 'RelationV2';
+    readonly relationType: 'many' | 'one';
+    fieldName: string;
+    sourceColumns: Column<any>[];
+    targetColumns: Column<any>[];
+    alias: string | undefined;
+    where: AnyTableFilter | undefined;
+    sourceTable: SchemaEntry;
+    targetTable: SchemaEntry;
+    through?: {
+        source: RelationsBuilderColumnBase[];
+        target: RelationsBuilderColumnBase[];
+    };
+    throughTable?: SchemaEntry;
+    isReversed?: boolean;
+    constructor(targetTable: SchemaEntry, targetTableName: TTargetTableName);
 }
-type AnyRelation = Relation<string>;
-declare class One<TTargetTableName extends string, TOptional extends boolean = boolean> extends Relation<TTargetTableName> {
-  static readonly [entityKind]: string;
-  protected $relationBrand: 'OneV2';
-  readonly relationType: "one";
-  readonly optional: TOptional;
-  constructor(tables: Schema, targetTable: SchemaEntry, targetTableName: TTargetTableName, config: AnyOneConfig | undefined);
+export type AnyRelation = Relation<string>;
+export declare class One<TTargetTableName extends string, TOptional extends boolean = boolean> extends Relation<TTargetTableName> {
+    static readonly [entityKind]: string;
+    protected $relationBrand: 'OneV2';
+    readonly relationType: "one";
+    readonly optional: TOptional;
+    constructor(tables: Schema, targetTable: SchemaEntry, targetTableName: TTargetTableName, config: AnyOneConfig | undefined);
 }
-type AnyOne = One<string, boolean>;
-declare class Many<TTargetTableName extends string> extends Relation<TTargetTableName> {
-  readonly config: AnyManyConfig | undefined;
-  static readonly [entityKind]: string;
-  protected $relationBrand: 'ManyV2';
-  readonly relationType: "many";
-  constructor(tables: Schema, targetTable: SchemaEntry, targetTableName: TTargetTableName, config: AnyManyConfig | undefined);
+export type AnyOne = One<string, boolean>;
+export declare class Many<TTargetTableName extends string> extends Relation<TTargetTableName> {
+    readonly config: AnyManyConfig | undefined;
+    static readonly [entityKind]: string;
+    protected $relationBrand: 'ManyV2';
+    readonly relationType: "many";
+    constructor(tables: Schema, targetTable: SchemaEntry, targetTableName: TTargetTableName, config: AnyManyConfig | undefined);
 }
-type AnyMany = Many<string>;
-declare abstract class AggregatedField<T = unknown> implements SQLWrapper<T> {
-  static readonly [entityKind]: string;
-  readonly $brand: 'AggregatedField';
-  readonly _: {
-    readonly data: T;
-  };
-  protected table: SchemaEntry | undefined;
-  onTable(table: SchemaEntry): this;
-  abstract getSQL(): SQL<T>;
+export type AnyMany = Many<string>;
+export declare abstract class AggregatedField<T = unknown> implements SQLWrapper<T> {
+    static readonly [entityKind]: string;
+    readonly $brand: 'AggregatedField';
+    readonly _: {
+        readonly data: T;
+    };
+    protected table: SchemaEntry | undefined;
+    onTable(table: SchemaEntry): this;
+    abstract getSQL(): SQL<T>;
 }
-declare class Count extends AggregatedField<number> {
-  static readonly [entityKind]: string;
-  protected $aggregatedFieldBrand: 'Count';
-  private query;
-  getSQL(): SQL<number>;
+export declare class Count extends AggregatedField<number> {
+    static readonly [entityKind]: string;
+    protected $aggregatedFieldBrand: 'Count';
+    private query;
+    getSQL(): SQL<number>;
 }
-type ExtractObjectValues<T> = T[keyof T];
-declare const operators: {
-  and: typeof and;
-  between: typeof between;
-  eq: BinaryOperator;
-  exists: typeof exists;
-  gt: BinaryOperator;
-  gte: BinaryOperator;
-  ilike: typeof ilike;
-  inArray: typeof inArray;
-  arrayContains: typeof arrayContains;
-  arrayContained: typeof arrayContained;
-  arrayOverlaps: typeof arrayOverlaps;
-  isNull: typeof isNull;
-  isNotNull: typeof isNotNull;
-  like: typeof like;
-  lt: BinaryOperator;
-  lte: BinaryOperator;
-  ne: BinaryOperator;
-  not: typeof not;
-  notBetween: typeof notBetween;
-  notExists: typeof notExists;
-  notLike: typeof notLike;
-  notIlike: typeof notIlike;
-  notInArray: typeof notInArray;
-  or: typeof or;
-  sql: typeof sql;
+export type ExtractObjectValues<T> = T[keyof T];
+export declare const operators: {
+    and: typeof and;
+    between: typeof between;
+    eq: import("./index.js").BinaryOperator;
+    exists: typeof exists;
+    gt: import("./index.js").BinaryOperator;
+    gte: import("./index.js").BinaryOperator;
+    ilike: typeof ilike;
+    inArray: typeof inArray;
+    arrayContains: typeof arrayContains;
+    arrayContained: typeof arrayContained;
+    arrayOverlaps: typeof arrayOverlaps;
+    isNull: typeof isNull;
+    isNotNull: typeof isNotNull;
+    like: typeof like;
+    lt: import("./index.js").BinaryOperator;
+    lte: import("./index.js").BinaryOperator;
+    ne: import("./index.js").BinaryOperator;
+    not: typeof not;
+    notBetween: typeof notBetween;
+    notExists: typeof notExists;
+    notLike: typeof notLike;
+    notIlike: typeof notIlike;
+    notInArray: typeof notInArray;
+    or: typeof or;
+    sql: typeof sql;
 };
-type Operators = typeof operators;
-declare const orderByOperators: {
-  sql: typeof sql;
-  asc: typeof asc;
-  desc: typeof desc;
+export type Operators = typeof operators;
+export declare const orderByOperators: {
+    sql: typeof sql;
+    asc: typeof asc;
+    desc: typeof desc;
 };
-type OrderByOperators = typeof orderByOperators;
-declare function getOrderByOperators(): OrderByOperators;
-type FindTargetTableInRelationalConfig<TConfig extends TablesRelationalConfig, TRelation extends AnyRelation> = TConfig[TRelation['targetTableName']];
-interface SQLOperator {
-  sql: Operators['sql'];
+export type OrderByOperators = typeof orderByOperators;
+export declare function getOrderByOperators(): OrderByOperators;
+export type FindTargetTableInRelationalConfig<TConfig extends TablesRelationalConfig, TRelation extends AnyRelation> = TConfig[TRelation['targetTableName']];
+export interface SQLOperator {
+    sql: Operators['sql'];
 }
-type DBQueryConfigColumns<TColumns extends FieldSelection> = { [K in keyof TColumns]?: boolean | undefined };
-type DBQueryConfigExtras<TTable extends SchemaEntry> = Record<string, SQLWrapper | ((table: TTable, operators: SQLOperator) => SQLWrapper)>;
-type DBQueryConfigOrderByCallback<TTable extends SchemaEntry> = (table: TTable, operators: OrderByOperators) => ValueOrArray<AnyColumn | SQL>;
-type DBQueryConfigOrderByObject<TColumns extends FieldSelection> = { [K in keyof TColumns]?: 'asc' | 'desc' | undefined };
-type DBQueryConfigOrderBy<TTable extends SchemaEntry, TColumns extends FieldSelection> = DBQueryConfigOrderByCallback<TTable> | DBQueryConfigOrderByObject<TColumns>;
-type DBQueryConfigWith<TSchema extends TablesRelationalConfig, TRelations extends RelationsRecord> = { [K in keyof TRelations]?: boolean | (DBQueryConfig<TRelations[K]['relationType'], TSchema, FindTargetTableInRelationalConfig<TSchema, TRelations[K]>>) | undefined };
-type DBQueryConfig<TRelationType extends 'one' | 'many' = 'one' | 'many', TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig> = (TTableConfig['relations'] extends Record<string, never> ? {} : {
-  with?: DBQueryConfigWith<TSchema, TTableConfig['relations']> | undefined;
+export type DBQueryConfigColumns<TColumns extends FieldSelection> = {
+    [K in keyof TColumns]?: boolean | undefined;
+};
+export type DBQueryConfigExtras<TTable extends SchemaEntry> = Record<string, SQLWrapper | ((table: TTable, operators: SQLOperator) => SQLWrapper)>;
+export type DBQueryConfigOrderByCallback<TTable extends SchemaEntry> = (table: TTable, operators: OrderByOperators) => ValueOrArray<AnyColumn | SQL>;
+export type DBQueryConfigOrderByObject<TColumns extends FieldSelection> = {
+    [K in keyof TColumns]?: 'asc' | 'desc' | undefined;
+};
+export type DBQueryConfigOrderBy<TTable extends SchemaEntry, TColumns extends FieldSelection> = DBQueryConfigOrderByCallback<TTable> | DBQueryConfigOrderByObject<TColumns>;
+export type DBQueryConfigWith<TSchema extends TablesRelationalConfig, TRelations extends RelationsRecord> = {
+    [K in keyof TRelations]?: boolean | (DBQueryConfig<TRelations[K]['relationType'], TSchema, FindTargetTableInRelationalConfig<TSchema, TRelations[K]>>) | undefined;
+};
+export type DBQueryConfig<TRelationType extends 'one' | 'many' = 'one' | 'many', TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig> = (TTableConfig['relations'] extends Record<string, never> ? {} : {
+    with?: DBQueryConfigWith<TSchema, TTableConfig['relations']> | undefined;
 }) & {
-  columns?: DBQueryConfigColumns<GetTableViewFieldSelection<TTableConfig['table']>> | undefined;
-  where?: RelationsFilter<TTableConfig, TSchema> | undefined;
-  extras?: DBQueryConfigExtras<TTableConfig['table']> | undefined;
-  orderBy?: DBQueryConfigOrderBy<TTableConfig['table'], GetTableViewFieldSelection<TTableConfig['table']>> | undefined;
-  offset?: number | Placeholder | undefined;
+    columns?: DBQueryConfigColumns<GetTableViewFieldSelection<TTableConfig['table']>> | undefined;
+    where?: RelationsFilter<TTableConfig, TSchema> | undefined;
+    extras?: DBQueryConfigExtras<TTableConfig['table']> | undefined;
+    orderBy?: DBQueryConfigOrderBy<TTableConfig['table'], GetTableViewFieldSelection<TTableConfig['table']>> | undefined;
+    offset?: number | Placeholder | undefined;
 } & (TRelationType extends 'many' ? {
-  limit?: number | Placeholder | undefined;
+    limit?: number | Placeholder | undefined;
 } : {});
-type DBQueryConfigWithComment<TRelationType extends 'one' | 'many' = 'one' | 'many', TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig> = DBQueryConfig<TRelationType, TSchema, TTableConfig> & {
-  /**
-   * Attach [sqlcommenter](https://google.github.io/sqlcommenter) comment to a query
-   */
-  comment?: CommentInput | undefined;
+export type DBQueryConfigWithComment<TRelationType extends 'one' | 'many' = 'one' | 'many', TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig> = DBQueryConfig<TRelationType, TSchema, TTableConfig> & {
+    /**
+     * Attach [sqlcommenter](https://google.github.io/sqlcommenter) comment to a query
+     */
+    comment?: CommentInput | undefined;
 };
-type AnyDBQueryConfig = {
-  columns?: DBQueryConfigColumns<GetTableViewFieldSelection<TableRelationalConfig['table']>> | undefined;
-  where?: RelationsFilter<TableRelationalConfig, TablesRelationalConfig> | undefined;
-  extras?: DBQueryConfigExtras<TableRelationalConfig['table']> | undefined;
-  with?: Record<string, AnyDBQueryConfig> | undefined;
-  orderBy?: DBQueryConfigOrderBy<TableRelationalConfig['table'], GetTableViewFieldSelection<TableRelationalConfig['table']>> | undefined;
-  offset?: number | Placeholder | undefined;
-  limit?: number | Placeholder | undefined;
-  comment?: CommentInput | undefined;
+export type AnyDBQueryConfig = {
+    columns?: DBQueryConfigColumns<GetTableViewFieldSelection<TableRelationalConfig['table']>> | undefined;
+    where?: RelationsFilter<TableRelationalConfig, TablesRelationalConfig> | undefined;
+    extras?: DBQueryConfigExtras<TableRelationalConfig['table']> | undefined;
+    with?: Record<string, AnyDBQueryConfig> | undefined;
+    orderBy?: DBQueryConfigOrderBy<TableRelationalConfig['table'], GetTableViewFieldSelection<TableRelationalConfig['table']>> | undefined;
+    offset?: number | Placeholder | undefined;
+    limit?: number | Placeholder | undefined;
+    comment?: CommentInput | undefined;
 };
-interface TableRelationalConfig {
-  table: SchemaEntry;
-  name: string;
-  relations: RelationsRecord;
+export interface TableRelationalConfig {
+    table: SchemaEntry;
+    name: string;
+    relations: RelationsRecord;
 }
-type TablesRelationalConfig = Record<string, TableRelationalConfig>;
-type ExtractTablesWithRelations<TConfig extends AnyRelationsBuilderConfig, TTables extends Schema> = { [K in keyof TTables]: {
-  table: TTables[K];
-  name: K & string;
-  relations: TConfig extends { [CK in K]: Record<string, any> } ? TConfig[K] : {};
-} };
-type ExtractTablesWithRelationsParts<TConfig extends AnyRelationsBuilderConfig, TTables extends Schema> = { [K in NonUndefinedKeysOnly<TConfig> & keyof TTables]: {
-  table: TTables[K & string];
-  name: K & string;
-  relations: TConfig[K] extends Record<string, any> ? TConfig[K] : {};
-} };
-type ReturnTypeOrValue<T> = T extends ((...args: any[]) => infer R) ? R : T;
-type RelationResultKind<TResult, TInclude, TRelation extends AnyRelation> = TRelation extends AnyOne ? (TResult | (Equal<TRelation['optional'], true> extends true ? null : TInclude extends Record<string, unknown> ? TInclude['where'] extends Record<string, any> ? null : never : never)) : TResult[];
-type BuildRelationResult<TConfig extends TablesRelationalConfig, TInclude, TRelations extends RelationsRecord> = { [K in TruthyKeysOnly<TInclude> & keyof TRelations]: TRelations[K] extends infer TRel extends AnyRelation ? RelationResultKind<BuildQueryResult<TConfig, FindTargetTableInRelationalConfig<TConfig, TRel>, Assume<TInclude[K], true | Record<string, unknown>>>, TInclude[K], TRel> : TRelations[K] extends AggregatedField<infer TData> ? TData : never };
-type NonUndefinedKeysOnly<T> = { [K in keyof T]: T[K] extends undefined ? never : K }[keyof T];
-type TruthyKeysOnly<T> = { [K in keyof T]: T[K] extends undefined | false ? never : K }[keyof T];
-type InferRelationalQueryTableResult<TRawSelection extends Record<string, unknown>, TSelectedFields extends Record<string, unknown> | 'Full' = 'Full'> = 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] };
-type BuildQueryResult<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig, TFullSelection extends true | Record<string, unknown>, TModel extends Record<string, unknown> = Assume<TTableConfig['table'], {
-  $inferSelect: Record<string, unknown>;
-}>['$inferSelect']> = TFullSelection extends true | Record<string, never> ? TModel : TFullSelection extends Record<string, unknown> ? Simplify<(InferRelationalQueryTableResult<TModel, TFullSelection['columns'] extends Record<string, unknown> ? TFullSelection['columns'] : 'Full'>) & (TFullSelection['extras'] extends Record<string, SQLWrapper | ((...args: any[]) => SQLWrapper)> ? { [K in NonUndefinedKeysOnly<ReturnTypeOrValue<TFullSelection['extras']>>]: ReturnType<Assume<ReturnTypeOrValue<TFullSelection['extras'][K & string]>, SQLWrapper>['getSQL']>['_']['type'] } : {}) & (TFullSelection['with'] extends Record<string, unknown> ? BuildRelationResult<TSchema, TFullSelection['with'], TTableConfig['relations']> : {})> : never;
-interface BuildRelationalQueryResult {
-  selection: {
-    key: string;
-    field: Column<any> | Table | View | SQL | SQL.Aliased | SQLWrapper | AggregatedField; /** For array type relations */
-    isArray?: boolean;
-    selection?: BuildRelationalQueryResult['selection'];
-    isOptional?: boolean;
-    codec?: NormalizeCodec | NormalizeArrayCodec; /** For array type columns */
-    arrayDimensions?: number;
-  }[];
-  sql: SQL;
+export type TablesRelationalConfig = Record<string, TableRelationalConfig>;
+export type ExtractTablesWithRelations<TConfig extends AnyRelationsBuilderConfig, TTables extends Schema> = {
+    [K in keyof TTables]: {
+        table: TTables[K];
+        name: K & string;
+        relations: TConfig extends {
+            [CK in K]: Record<string, any>;
+        } ? TConfig[K] : {};
+    };
+};
+export type ExtractTablesWithRelationsParts<TConfig extends AnyRelationsBuilderConfig, TTables extends Schema> = {
+    [K in NonUndefinedKeysOnly<TConfig> & keyof TTables]: {
+        table: TTables[K & string];
+        name: K & string;
+        relations: TConfig[K] extends Record<string, any> ? TConfig[K] : {};
+    };
+};
+export type ReturnTypeOrValue<T> = T extends (...args: any[]) => infer R ? R : T;
+export type RelationResultKind<TResult, TInclude, TRelation extends AnyRelation> = TRelation extends AnyOne ? (TResult | (Equal<TRelation['optional'], true> extends true ? null : TInclude extends Record<string, unknown> ? TInclude['where'] extends Record<string, any> ? null : never : never)) : TResult[];
+export type BuildRelationResult<TConfig extends TablesRelationalConfig, TInclude, TRelations extends RelationsRecord> = {
+    [K in TruthyKeysOnly<TInclude> & keyof TRelations]: TRelations[K] extends infer TRel extends AnyRelation ? RelationResultKind<BuildQueryResult<TConfig, FindTargetTableInRelationalConfig<TConfig, TRel>, Assume<TInclude[K], true | Record<string, unknown>>>, TInclude[K], TRel> : TRelations[K] extends AggregatedField<infer TData> ? TData : never;
+};
+export type NonUndefinedKeysOnly<T> = {
+    [K in keyof T]: T[K] extends undefined ? never : K;
+}[keyof T];
+export type TruthyKeysOnly<T> = {
+    [K in keyof T]: T[K] extends undefined | false ? never : K;
+}[keyof T];
+export type InferRelationalQueryTableResult<TRawSelection extends Record<string, unknown>, TSelectedFields extends Record<string, unknown> | 'Full' = 'Full'> = 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];
+};
+export type BuildQueryResult<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig, TFullSelection extends true | Record<string, unknown>, TModel extends Record<string, unknown> = Assume<TTableConfig['table'], {
+    $inferSelect: Record<string, unknown>;
+}>['$inferSelect']> = TFullSelection extends true | Record<string, never> ? TModel : TFullSelection extends Record<string, unknown> ? Simplify<(InferRelationalQueryTableResult<TModel, TFullSelection['columns'] extends Record<string, unknown> ? TFullSelection['columns'] : 'Full'>) & (TFullSelection['extras'] extends Record<string, SQLWrapper | ((...args: any[]) => SQLWrapper)> ? {
+    [K in NonUndefinedKeysOnly<ReturnTypeOrValue<TFullSelection['extras']>>]: ReturnType<Assume<ReturnTypeOrValue<TFullSelection['extras'][K & string]>, SQLWrapper>['getSQL']>['_']['type'];
+} : {}) & (TFullSelection['with'] extends Record<string, unknown> ? BuildRelationResult<TSchema, TFullSelection['with'], TTableConfig['relations']> : {})> : never;
+export interface BuildRelationalQueryResult {
+    selection: {
+        key: string;
+        field: Column<any> | Table | View | SQL | SQL.Aliased | SQLWrapper | AggregatedField;
+        /** For array type relations */
+        isArray?: boolean;
+        selection?: BuildRelationalQueryResult['selection'];
+        isOptional?: boolean;
+        codec?: NormalizeCodec | NormalizeArrayCodec;
+        /** For array type columns */
+        arrayDimensions?: number;
+    }[];
+    sql: SQL;
 }
-declare function mapRelationalRow(rows: Record<string, unknown> | Record<string, unknown>[], isOne: boolean, buildQueryResultSelection: BuildRelationalQueryResult['selection'], /** Needed for SQLite as it returns JSON values as strings */
-
-parseJson?: boolean, /** Needed for SingleStore as it returns JSON arrays as strings */
-
-parseJsonIfString?: boolean, /** Root level data of query is usually not nested in JSON */
-
+export declare function mapRelationalRow(rows: Record<string, unknown> | Record<string, unknown>[], isOne: boolean, buildQueryResultSelection: BuildRelationalQueryResult['selection'], 
+/** Needed for SQLite as it returns JSON values as strings */
+parseJson?: boolean, 
+/** Needed for SingleStore as it returns JSON arrays as strings */
+parseJsonIfString?: boolean, 
+/** Root level data of query is usually not nested in JSON */
 useJsonMappers?: boolean): Record<string, unknown> | Record<string, unknown>[];
-declare function mapRelationalRowFromArrays(rows: unknown[][] | unknown[], isOne: boolean, buildQueryResultSelection: BuildRelationalQueryResult['selection'], /** Needed for SQLite as it returns JSON values as strings */
-
-parseJson?: boolean, /** Needed for SingleStore as it returns JSON arrays as strings */
-
+export declare function mapRelationalRowFromArrays(rows: unknown[][] | unknown[], isOne: boolean, buildQueryResultSelection: BuildRelationalQueryResult['selection'], 
+/** Needed for SQLite as it returns JSON values as strings */
+parseJson?: boolean, 
+/** Needed for SingleStore as it returns JSON arrays as strings */
 parseJsonIfString?: boolean): Record<string, unknown> | Record<string, unknown>[];
-interface RelationalRowsMapper<T = any> {
-  (rows: unknown[][] | Record<string, unknown>[]): T;
-}
-type RelationalRowsMapperGenerator<T = any> = (config: RelationalQueryMapperConfig) => RelationalRowsMapper<T>;
-declare function makeDefaultRqbMapper<T = any>({
-  selection,
-  isFirst,
-  parseJson,
-  parseJsonIfString,
-  rootJsonMappers,
-  arrayModeRoot
-}: RelationalQueryMapperConfig): RelationalRowsMapper<T>;
-interface RelationalQueryMapperConfig {
-  selection: BuildRelationalQueryResult['selection'];
-  /** Used for `db.query.table.findFirst(...)` */
-  isFirst: boolean;
-  /** Used by SQLite & drivers that return JSON-s as strings by default */
-  parseJson: boolean;
-  /** Used by SingleStore to fix malformed outputs for empty JSON arrays */
-  parseJsonIfString: boolean;
-  /** Enable for non-reworked dialects & drivers with JSON-ified root level of relational query */
-  rootJsonMappers: boolean;
-  /** Used when root level of data is in array mode */
-  arrayModeRoot?: boolean;
-}
-declare function makeJitRqbMapper<T = unknown>({
-  selection,
-  isFirst,
-  parseJson,
-  parseJsonIfString,
-  rootJsonMappers,
-  arrayModeRoot
-}: RelationalQueryMapperConfig): RelationalRowsMapper<T>;
-declare class RelationsBuilderTable<TTableName extends string = string> {
-  static readonly [entityKind]: string;
-  protected readonly _: {
-    readonly name: TTableName;
-    readonly table: SchemaEntry;
-  };
-  constructor(table: SchemaEntry, name: TTableName);
+export interface RelationalRowsMapper<T = any> {
+    (rows: unknown[][] | Record<string, unknown>[]): T;
 }
-interface RelationsBuilderColumnConfig<TTableName extends string = string> {
-  readonly tableName: TTableName;
-  readonly column: FieldValue;
-  readonly through?: RelationsBuilderColumnBase;
-  readonly key: string;
+export type RelationalRowsMapperGenerator<T = any> = (config: RelationalQueryMapperConfig) => RelationalRowsMapper<T>;
+export declare function makeDefaultRqbMapper<T = any>({ selection, isFirst, parseJson, parseJsonIfString, rootJsonMappers, arrayModeRoot }: RelationalQueryMapperConfig): RelationalRowsMapper<T>;
+export interface RelationalQueryMapperConfig {
+    selection: BuildRelationalQueryResult['selection'];
+    /** Used for `db.query.table.findFirst(...)` */
+    isFirst: boolean;
+    /** Used by SQLite & drivers that return JSON-s as strings by default */
+    parseJson: boolean;
+    /** Used by SingleStore to fix malformed outputs for empty JSON arrays */
+    parseJsonIfString: boolean;
+    /** Enable for non-reworked dialects & drivers with JSON-ified root level of relational query */
+    rootJsonMappers: boolean;
+    /** Used when root level of data is in array mode */
+    arrayModeRoot?: boolean;
 }
-interface RelationsBuilderColumnBase<TTableName extends string = string> {
-  _: RelationsBuilderColumnConfig<TTableName>;
+export declare function makeJitRqbMapper<T = unknown>({ selection, isFirst, parseJson, parseJsonIfString, rootJsonMappers, arrayModeRoot }: RelationalQueryMapperConfig): RelationalRowsMapper<T>;
+export declare class RelationsBuilderTable<TTableName extends string = string> {
+    static readonly [entityKind]: string;
+    protected readonly _: {
+        readonly name: TTableName;
+        readonly table: SchemaEntry;
+    };
+    constructor(table: SchemaEntry, name: TTableName);
 }
-declare class RelationsBuilderColumn<TTableName extends string = string> implements RelationsBuilderColumnBase<TTableName> {
-  static readonly [entityKind]: string;
-  readonly _: {
+export interface RelationsBuilderColumnConfig<TTableName extends string = string> {
     readonly tableName: TTableName;
     readonly column: FieldValue;
+    readonly through?: RelationsBuilderColumnBase;
     readonly key: string;
-  };
-  constructor(column: FieldValue, tableName: TTableName, key: string);
-  through(column: RelationsBuilderColumn): RelationsBuilderJunctionColumn<TTableName>;
 }
-declare class RelationsBuilderJunctionColumn<TTableName extends string = string> implements RelationsBuilderColumnBase<TTableName> {
-  static readonly [entityKind]: string;
-  readonly _: {
-    readonly tableName: TTableName;
-    readonly column: FieldValue;
-    readonly through: RelationsBuilderColumnBase;
-    readonly key: string;
-  };
-  constructor(column: FieldValue, tableName: TTableName, key: string, through: RelationsBuilderColumnBase);
+export interface RelationsBuilderColumnBase<TTableName extends string = string> {
+    _: RelationsBuilderColumnConfig<TTableName>;
 }
-interface RelationFieldsFilterInternals<T> {
-  eq?: T | Placeholder | undefined;
-  ne?: T | Placeholder | undefined;
-  gt?: T | Placeholder | undefined;
-  gte?: T | Placeholder | undefined;
-  lt?: T | Placeholder | undefined;
-  lte?: T | Placeholder | undefined;
-  in?: (T | Placeholder)[] | Placeholder | undefined;
-  notIn?: (T | Placeholder)[] | Placeholder | undefined;
-  arrayContains?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | undefined;
-  arrayContained?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | undefined;
-  arrayOverlaps?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | undefined;
-  like?: string | Placeholder | undefined;
-  ilike?: string | Placeholder | undefined;
-  notLike?: string | Placeholder | undefined;
-  notIlike?: string | Placeholder | undefined;
-  isNull?: true | undefined;
-  isNotNull?: true | undefined;
-  NOT?: RelationsFieldFilter<T> | undefined;
-  OR?: RelationsFieldFilter<T>[] | undefined;
-  AND?: RelationsFieldFilter<T>[] | undefined;
+export declare class RelationsBuilderColumn<TTableName extends string = string> implements RelationsBuilderColumnBase<TTableName> {
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly tableName: TTableName;
+        readonly column: FieldValue;
+        readonly key: string;
+    };
+    constructor(column: FieldValue, tableName: TTableName, key: string);
+    through(column: RelationsBuilderColumn): RelationsBuilderJunctionColumn<TTableName>;
 }
-type RelationsFieldFilter<T = unknown> = RelationFieldsFilterInternals<T> | (unknown extends T ? never : T extends object ? never : T) | Placeholder;
-interface RelationsFilterCommons<TTable extends TableRelationalConfig = TableRelationalConfig, TSchema extends TablesRelationalConfig = TablesRelationalConfig> {
-  OR?: RelationsFilter<TTable, TSchema>[] | undefined;
-  NOT?: RelationsFilter<TTable, TSchema> | undefined;
-  AND?: RelationsFilter<TTable, TSchema>[] | undefined;
-  RAW?: SQLWrapper | ((table: TTable['table'], operators: Operators) => SQL) | undefined;
+export declare class RelationsBuilderJunctionColumn<TTableName extends string = string> implements RelationsBuilderColumnBase<TTableName> {
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly tableName: TTableName;
+        readonly column: FieldValue;
+        readonly through: RelationsBuilderColumnBase;
+        readonly key: string;
+    };
+    constructor(column: FieldValue, tableName: TTableName, key: string, through: RelationsBuilderColumnBase);
 }
-type RelationsFilterColumns<TColumns extends Record<string, unknown>> = { [K in keyof TColumns]?: (TColumns[K] extends {
-  _: {
-    data: infer Data;
-  };
-} ? RelationsFieldFilter<Data> : RelationsFieldFilter<unknown>) | undefined };
-type RelationsFilterRelations<TTable extends TableRelationalConfig, TSchema extends TablesRelationalConfig, TRelations extends RelationsRecord = TTable['relations']> = { [K in keyof TRelations]?: boolean | RelationsFilter<FindTargetTableInRelationalConfig<TSchema, TRelations[K]>, TSchema> | undefined };
-type RelationsFilter<TTable extends TableRelationalConfig, TSchema extends TablesRelationalConfig, TColumns extends FieldSelection = GetTableViewFieldSelection<TTable['table']>> = TTable['relations'] extends Record<string, never> ? TableFilter<TTable['table']> : RelationsFilterColumns<TColumns> & RelationsFilterRelations<TTable, TSchema> & RelationsFilterCommons<TTable, TSchema>;
-interface TableFilterCommons<TTable extends SchemaEntry = SchemaEntry, TColumns extends Record<string, unknown> = GetTableViewColumns<TTable>> {
-  OR?: TableFilter<TTable, TColumns>[] | undefined;
-  NOT?: TableFilter<TTable, TColumns> | undefined;
-  AND?: TableFilter<TTable, TColumns>[] | undefined;
-  RAW?: SQLWrapper | ((table: TTable, operators: Operators) => SQL) | undefined;
+export interface RelationFieldsFilterInternals<T> {
+    eq?: T | Placeholder | undefined;
+    ne?: T | Placeholder | undefined;
+    gt?: T | Placeholder | undefined;
+    gte?: T | Placeholder | undefined;
+    lt?: T | Placeholder | undefined;
+    lte?: T | Placeholder | undefined;
+    in?: (T | Placeholder)[] | Placeholder | undefined;
+    notIn?: (T | Placeholder)[] | Placeholder | undefined;
+    arrayContains?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | undefined;
+    arrayContained?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | undefined;
+    arrayOverlaps?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | undefined;
+    like?: string | Placeholder | undefined;
+    ilike?: string | Placeholder | undefined;
+    notLike?: string | Placeholder | undefined;
+    notIlike?: string | Placeholder | undefined;
+    isNull?: true | undefined;
+    isNotNull?: true | undefined;
+    NOT?: RelationsFieldFilter<T> | undefined;
+    OR?: RelationsFieldFilter<T>[] | undefined;
+    AND?: RelationsFieldFilter<T>[] | undefined;
 }
-type TableFilterColumns<TColumns extends Record<string, unknown>> = { [K in keyof TColumns]?: (TColumns[K] extends {
-  _: {
-    data: infer Data;
-  };
-} ? RelationsFieldFilter<Data> : RelationsFieldFilter<unknown>) | undefined };
-type TableFilter<TTable extends SchemaEntry = SchemaEntry, TColumns extends Record<string, unknown> = GetTableViewColumns<TTable>> = TableFilterColumns<TColumns> & TableFilterCommons<TTable, TColumns>;
-type AnyRelationsFilter = RelationsFilter<TableRelationalConfig, TablesRelationalConfig, FieldSelection>;
-type AnyTableFilter = TableFilter<SchemaEntry, FieldSelection>;
-interface OneConfig<TTargetTable extends SchemaEntry, TOptional extends boolean> {
-  from?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
-  to?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
-  where?: TableFilter<TTargetTable>;
-  optional?: TOptional;
-  alias?: string;
+export type RelationsFieldFilter<T = unknown> = RelationFieldsFilterInternals<T> | (unknown extends T ? never : T extends object ? never : T) | Placeholder;
+export interface RelationsFilterCommons<TTable extends TableRelationalConfig = TableRelationalConfig, TSchema extends TablesRelationalConfig = TablesRelationalConfig> {
+    OR?: RelationsFilter<TTable, TSchema>[] | undefined;
+    NOT?: RelationsFilter<TTable, TSchema> | undefined;
+    AND?: RelationsFilter<TTable, TSchema>[] | undefined;
+    RAW?: SQLWrapper | ((table: TTable['table'], operators: Operators) => SQL) | undefined;
 }
-type AnyOneConfig = OneConfig<SchemaEntry, boolean>;
-interface ManyConfig<TTargetTable extends SchemaEntry> {
-  from?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
-  to?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
-  where?: TableFilter<TTargetTable>;
-  alias?: string;
+export type RelationsFilterColumns<TColumns extends Record<string, unknown>> = {
+    [K in keyof TColumns]?: (TColumns[K] extends {
+        _: {
+            data: infer Data;
+        };
+    } ? RelationsFieldFilter<Data> : RelationsFieldFilter<unknown>) | undefined;
+};
+export type RelationsFilterRelations<TTable extends TableRelationalConfig, TSchema extends TablesRelationalConfig, TRelations extends RelationsRecord = TTable['relations']> = {
+    [K in keyof TRelations]?: boolean | RelationsFilter<FindTargetTableInRelationalConfig<TSchema, TRelations[K]>, TSchema> | undefined;
+};
+export type RelationsFilter<TTable extends TableRelationalConfig, TSchema extends TablesRelationalConfig, TColumns extends FieldSelection = GetTableViewFieldSelection<TTable['table']>> = TTable['relations'] extends Record<string, never> ? TableFilter<TTable['table']> : RelationsFilterColumns<TColumns> & RelationsFilterRelations<TTable, TSchema> & RelationsFilterCommons<TTable, TSchema>;
+export interface TableFilterCommons<TTable extends SchemaEntry = SchemaEntry, TColumns extends Record<string, unknown> = GetTableViewColumns<TTable>> {
+    OR?: TableFilter<TTable, TColumns>[] | undefined;
+    NOT?: TableFilter<TTable, TColumns> | undefined;
+    AND?: TableFilter<TTable, TColumns>[] | undefined;
+    RAW?: SQLWrapper | ((table: TTable, operators: Operators) => SQL) | undefined;
+}
+export type TableFilterColumns<TColumns extends Record<string, unknown>> = {
+    [K in keyof TColumns]?: (TColumns[K] extends {
+        _: {
+            data: infer Data;
+        };
+    } ? RelationsFieldFilter<Data> : RelationsFieldFilter<unknown>) | undefined;
+};
+export type TableFilter<TTable extends SchemaEntry = SchemaEntry, TColumns extends Record<string, unknown> = GetTableViewColumns<TTable>> = TableFilterColumns<TColumns> & TableFilterCommons<TTable, TColumns>;
+export type AnyRelationsFilter = RelationsFilter<TableRelationalConfig, TablesRelationalConfig, FieldSelection>;
+export type AnyTableFilter = TableFilter<SchemaEntry, FieldSelection>;
+export interface OneConfig<TTargetTable extends SchemaEntry, TOptional extends boolean> {
+    from?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
+    to?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
+    where?: TableFilter<TTargetTable>;
+    optional?: TOptional;
+    alias?: string;
+}
+export type AnyOneConfig = OneConfig<SchemaEntry, boolean>;
+export interface ManyConfig<TTargetTable extends SchemaEntry> {
+    from?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
+    to?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
+    where?: TableFilter<TTargetTable>;
+    alias?: string;
 }
-type AnyManyConfig = ManyConfig<SchemaEntry>;
-interface OneFn<TTargetTable extends SchemaEntry, TTargetTableName extends string> {
-  <TOptional extends boolean = true>(config?: OneConfig<TTargetTable, TOptional>): One<TTargetTableName, TOptional>;
+export type AnyManyConfig = ManyConfig<SchemaEntry>;
+export interface OneFn<TTargetTable extends SchemaEntry, TTargetTableName extends string> {
+    <TOptional extends boolean = true>(config?: OneConfig<TTargetTable, TOptional>): One<TTargetTableName, TOptional>;
 }
-interface ManyFn<TTargetTable extends SchemaEntry, TTargetTableName extends string> {
-  (config?: ManyConfig<TTargetTable>): Many<TTargetTableName>;
+export interface ManyFn<TTargetTable extends SchemaEntry, TTargetTableName extends string> {
+    (config?: ManyConfig<TTargetTable>): Many<TTargetTableName>;
 }
-declare class RelationsHelperStatic<TTables extends Schema> {
-  static readonly [entityKind]: string;
-  private readonly _;
-  constructor(tables: TTables);
-  one: { [K in keyof TTables]: TTables[K] extends FilteredSchemaEntry ? OneFn<TTables[K], K & string> : DrizzleTypeError<'Views with nested selections are not supported by the relational query builder'> };
-  many: { [K in keyof TTables]: TTables[K] extends FilteredSchemaEntry ? ManyFn<TTables[K], K & string> : DrizzleTypeError<'Views with nested selections are not supported by the relational query builder'> };
+export declare class RelationsHelperStatic<TTables extends Schema> {
+    static readonly [entityKind]: string;
+    private readonly _;
+    constructor(tables: TTables);
+    one: {
+        [K in keyof TTables]: TTables[K] extends FilteredSchemaEntry ? OneFn<TTables[K], K & string> : DrizzleTypeError<'Views with nested selections are not supported by the relational query builder'>;
+    };
+    many: {
+        [K in keyof TTables]: TTables[K] extends FilteredSchemaEntry ? ManyFn<TTables[K], K & string> : DrizzleTypeError<'Views with nested selections are not supported by the relational query builder'>;
+    };
 }
-type RelationsBuilderColumns<TTable extends SchemaEntry, TTableName extends string> = { [TColumnName in keyof GetTableViewColumns<TTable>]: RelationsBuilderColumn<TTableName> };
-type RelationsBuilderTables<TSchema extends Schema> = { [TTableName in keyof TSchema]: TSchema[TTableName] extends FilteredSchemaEntry ? (RelationsBuilderColumns<TSchema[TTableName], TTableName & string> & RelationsBuilderTable<TTableName & string>) : DrizzleTypeError<'Views with nested selections are not supported by the relational query builder'> };
-type RelationsBuilder<TSchema extends Schema> = RelationsBuilderTables<TSchema> & RelationsHelperStatic<TSchema>;
-type RelationsBuilderConfigValue = RelationsRecord | undefined;
-type RelationsBuilderConfig<TTables extends Schema> = { [TTableName in keyof TTables]?: RelationsBuilderConfigValue };
-type AnyRelationsBuilderConfig = Record<string, RelationsBuilderConfigValue>;
-type ExtractTablesFromSchema<TSchema extends Record<string, unknown>> = { [K in keyof TSchema as TSchema[K] extends SchemaEntry ? K extends string ? K : never : never]: Assume<TSchema[K], SchemaEntry> };
-declare function createRelationsHelper<TTables extends Schema>(tables: TTables): RelationsBuilder<TTables>;
-declare function extractTablesFromSchema<TSchema extends Record<string, unknown>>(schema: TSchema): ExtractTablesFromSchema<TSchema>;
-type IncludeEveryTable<TTables extends Schema> = { [K in keyof TTables]: {} };
+export type RelationsBuilderColumns<TTable extends SchemaEntry, TTableName extends string> = {
+    [TColumnName in keyof GetTableViewColumns<TTable>]: RelationsBuilderColumn<TTableName>;
+};
+export type RelationsBuilderTables<TSchema extends Schema> = {
+    [TTableName in keyof TSchema]: TSchema[TTableName] extends FilteredSchemaEntry ? (RelationsBuilderColumns<TSchema[TTableName], TTableName & string> & RelationsBuilderTable<TTableName & string>) : DrizzleTypeError<'Views with nested selections are not supported by the relational query builder'>;
+};
+export type RelationsBuilder<TSchema extends Schema> = RelationsBuilderTables<TSchema> & RelationsHelperStatic<TSchema>;
+export type RelationsBuilderConfigValue = RelationsRecord | undefined;
+export type RelationsBuilderConfig<TTables extends Schema> = {
+    [TTableName in keyof TTables]?: RelationsBuilderConfigValue;
+};
+export type AnyRelationsBuilderConfig = Record<string, RelationsBuilderConfigValue>;
+export type ExtractTablesFromSchema<TSchema extends Record<string, unknown>> = {
+    [K in keyof TSchema as TSchema[K] extends SchemaEntry ? K extends string ? K : never : never]: Assume<TSchema[K], SchemaEntry>;
+};
+export declare function createRelationsHelper<TTables extends Schema>(tables: TTables): RelationsBuilder<TTables>;
+export declare function extractTablesFromSchema<TSchema extends Record<string, unknown>>(schema: TSchema): ExtractTablesFromSchema<TSchema>;
+export type IncludeEveryTable<TTables extends Schema> = {
+    [K in keyof TTables]: {};
+};
 /** Builds relational config for every table in schema */
-declare function defineRelations<TSchema extends Record<string, unknown>, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema): ExtractTablesWithRelations<{}, TTables>;
+export declare function defineRelations<TSchema extends Record<string, unknown>, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema): ExtractTablesWithRelations<{}, TTables>;
 /** Builds relational config for every table in schema */
-declare function defineRelations<TSchema extends Record<string, unknown>, TConfig extends RelationsBuilderConfig<TTables>, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema, relations: (helpers: RelationsBuilder<TTables>) => TConfig): ExtractTablesWithRelations<TConfig, TTables>;
+export declare function defineRelations<TSchema extends Record<string, unknown>, TConfig extends RelationsBuilderConfig<TTables>, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema, relations: (helpers: RelationsBuilder<TTables>) => TConfig): ExtractTablesWithRelations<TConfig, TTables>;
 /** Builds relational config for every table in schema */
-declare function defineRelationsPart<TSchema extends Record<string, unknown>, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema): ExtractTablesWithRelationsParts<IncludeEveryTable<TTables>, TTables>;
+export declare function defineRelationsPart<TSchema extends Record<string, unknown>, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema): ExtractTablesWithRelationsParts<IncludeEveryTable<TTables>, TTables>;
 /** Builds relational config only for tables present in relational config */
-declare function defineRelationsPart<TSchema extends Record<string, unknown>, TConfig extends RelationsBuilderConfig<TTables>, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema, relations: (helpers: RelationsBuilder<TTables>) => TConfig): ExtractTablesWithRelationsParts<TConfig, TTables>;
-interface WithContainer {
-  with?: Record<string, boolean | AnyDBQueryConfig | undefined>;
+export declare function defineRelationsPart<TSchema extends Record<string, unknown>, TConfig extends RelationsBuilderConfig<TTables>, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema, relations: (helpers: RelationsBuilder<TTables>) => TConfig): ExtractTablesWithRelationsParts<TConfig, TTables>;
+export interface WithContainer {
+    with?: Record<string, boolean | AnyDBQueryConfig | undefined>;
 }
-interface ColumnWithTSName {
-  column: Table | View | Column<any> | SQL | SQLWrapper | SQL.Aliased;
-  tsName: string;
+export interface ColumnWithTSName {
+    column: Table | View | Column<any> | SQL | SQLWrapper | SQL.Aliased;
+    tsName: string;
 }
-type RelationsOrder<TColumns extends FieldSelection> = { [K in keyof TColumns]?: 'asc' | 'desc' };
-type OrderBy = Exclude<AnyDBQueryConfig['orderBy'], undefined>;
-type Extras = Exclude<AnyDBQueryConfig['extras'], undefined>;
-declare function relationsFilterToSQL(table: SchemaEntry, filter: AnyRelationsFilter | AnyTableFilter): SQL | undefined;
-declare function relationsFilterToSQL(table: SchemaEntry, filter: AnyRelationsFilter | AnyTableFilter, tableRelations: RelationsRecord, tablesRelations: TablesRelationalConfig, depth?: number): SQL | undefined;
-declare function relationsOrderToSQL(table: SchemaEntry, orders: OrderBy): SQL | undefined;
-declare function relationExtrasToSQL(table: SchemaEntry, extras: Extras, codecs?: CodecsCollection, inJson?: boolean): {
-  sql: SQL<unknown> | undefined;
-  selection: {
-    key: string;
-    field: Column<any> | Table | View | SQL | SQL.Aliased | SQLWrapper | AggregatedField; /** For array type relations */
-    isArray?: boolean;
-    selection?: BuildRelationalQueryResult["selection"];
-    isOptional?: boolean;
-    codec?: NormalizeCodec | NormalizeArrayCodec; /** For array type columns */
-    arrayDimensions?: number;
-  }[];
+export type RelationsOrder<TColumns extends FieldSelection> = {
+    [K in keyof TColumns]?: 'asc' | 'desc';
+};
+export type OrderBy = Exclude<AnyDBQueryConfig['orderBy'], undefined>;
+export type Extras = Exclude<AnyDBQueryConfig['extras'], undefined>;
+export declare function relationsFilterToSQL(table: SchemaEntry, filter: AnyRelationsFilter | AnyTableFilter): SQL | undefined;
+export declare function relationsFilterToSQL(table: SchemaEntry, filter: AnyRelationsFilter | AnyTableFilter, tableRelations: RelationsRecord, tablesRelations: TablesRelationalConfig, depth?: number): SQL | undefined;
+export declare function relationsOrderToSQL(table: SchemaEntry, orders: OrderBy): SQL | undefined;
+export declare function relationExtrasToSQL(table: SchemaEntry, extras: Extras, codecs?: CodecsCollection, inJson?: boolean): {
+    sql: SQL<unknown> | undefined;
+    selection: {
+        key: string;
+        field: Column<any> | Table | View | SQL | SQL.Aliased | SQLWrapper | AggregatedField;
+        /** For array type relations */
+        isArray?: boolean;
+        selection?: BuildRelationalQueryResult["selection"];
+        isOptional?: boolean;
+        codec?: NormalizeCodec | NormalizeArrayCodec;
+        /** For array type columns */
+        arrayDimensions?: number;
+    }[];
 };
-interface BuiltRelationFilters {
-  filter?: SQL;
-  joinCondition?: SQL;
+export interface BuiltRelationFilters {
+    filter?: SQL;
+    joinCondition?: SQL;
 }
-declare function relationToSQL(relation: Relation, sourceTable: SchemaEntry, targetTable: SchemaEntry, throughTable?: SchemaEntry): BuiltRelationFilters;
-declare function getTableAsAliasSQL(table: SchemaEntry): SQL<unknown>;
-//#endregion
-export { AggregatedField, AnyDBQueryConfig, AnyMany, AnyManyConfig, AnyOne, AnyOneConfig, AnyRelation, AnyRelations, AnyRelationsBuilderConfig, AnyRelationsFilter, AnyTableFilter, BuildQueryResult, BuildRelationResult, BuildRelationalQueryResult, BuiltRelationFilters, ColumnWithTSName, Count, DBQueryConfig, DBQueryConfigColumns, DBQueryConfigExtras, DBQueryConfigOrderBy, DBQueryConfigOrderByCallback, DBQueryConfigOrderByObject, DBQueryConfigWith, DBQueryConfigWithComment, EmptyRelations, ExtractObjectValues, ExtractTablesFromSchema, ExtractTablesWithRelations, ExtractTablesWithRelationsParts, Extras, FieldSelection, FieldValue, FilteredSchemaEntry, FindTargetTableInRelationalConfig, GetTableViewColumns, GetTableViewFieldSelection, IncludeEveryTable, InferRelationalQueryTableResult, Many, ManyConfig, ManyFn, NonUndefinedKeysOnly, One, OneConfig, OneFn, Operators, OrderBy, OrderByOperators, Relation, RelationFieldsFilterInternals, RelationResultKind, RelationalQueryMapperConfig, RelationalRowsMapper, RelationalRowsMapperGenerator, RelationsBuilder, RelationsBuilderColumn, RelationsBuilderColumnBase, RelationsBuilderColumnConfig, RelationsBuilderColumns, RelationsBuilderConfig, RelationsBuilderConfigValue, RelationsBuilderJunctionColumn, RelationsBuilderTable, RelationsBuilderTables, RelationsFieldFilter, RelationsFilter, RelationsFilterColumns, RelationsFilterCommons, RelationsFilterRelations, RelationsHelperStatic, RelationsOrder, RelationsRecord, ReturnTypeOrValue, SQLOperator, Schema, SchemaEntry, TableFilter, TableFilterColumns, TableFilterCommons, TableRelationalConfig, TablesRelationalConfig, TruthyKeysOnly, WithContainer, buildRelations, buildRelationsParts, createRelationsHelper, defineRelations, defineRelationsPart, extractTablesFromSchema, getOrderByOperators, getTableAsAliasSQL, makeDefaultRqbMapper, makeJitRqbMapper, mapRelationalRow, mapRelationalRowFromArrays, operators, orderByOperators, processRelations, relationExtrasToSQL, relationToSQL, relationsFilterToSQL, relationsOrderToSQL };
-//# sourceMappingURL=relations.d.ts.map
+export declare function relationToSQL(relation: Relation, sourceTable: SchemaEntry, targetTable: SchemaEntry, throughTable?: SchemaEntry): BuiltRelationFilters;
+export declare function getTableAsAliasSQL(table: SchemaEntry): SQL<unknown>;