import { entityKind } from "./entity.cjs";
import { BinaryOperator, and, arrayContained, arrayContains, arrayOverlaps, between, exists, ilike, inArray, isNotNull, isNull, like, not, notBetween, notExists, notIlike, notInArray, notLike, or } from "./sql/expressions/conditions.cjs";
import { asc, desc } from "./sql/expressions/select.cjs";
import { Assume, DrizzleTypeError, Equal, Simplify, ValueOrArray } from "./utils.cjs";
import { CodecsCollection, NormalizeArrayCodec, NormalizeCodec } from "./codecs.cjs";
import { CommentInput, Placeholder, SQL, SQLWrapper, View, sql } from "./sql/sql.cjs";
import { AnyColumn, Column } from "./column.cjs";
import { Table } from "./table.cjs";

//#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;
/** Builds relational config for every table in schema */
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 | EmptyFilter;
  sourceTable: SchemaEntry;
  targetTable: SchemaEntry;
  through?: {
    source: RelationsBuilderColumnBase[];
    target: RelationsBuilderColumnBase[];
  };
  throughTable?: SchemaEntry;
  isFilterReversed?: 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);
}
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);
}
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>;
}
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;
};
type Operators = typeof operators;
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'];
}
type DBQueryConfigColumns<TColumns extends FieldSelection> = { [K in keyof TColumns]?: boolean | undefined };
type DBQueryConfigExtras<TTable extends SchemaEntry> = Record<string, SQLWrapper | ((table: TTable, operators: SQLOperator) => SQLWrapper | undefined)>;
type DBQueryConfigOrderByCallback<TTable extends SchemaEntry> = (table: TTable, operators: OrderByOperators) => ValueOrArray<AnyColumn | SQL> | undefined;
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;
}) & {
  columns?: DBQueryConfigColumns<GetTableViewFieldSelection<TTableConfig['table']>> | undefined;
  where?: RelationsFilter<TTableConfig, TSchema> | EmptyFilter;
  extras?: DBQueryConfigExtras<TTableConfig['table']> | undefined;
  orderBy?: DBQueryConfigOrderBy<TTableConfig['table'], GetTableViewFieldSelection<TTableConfig['table']>> | undefined;
  offset?: number | Placeholder | undefined;
} & (TRelationType extends 'many' ? {
  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;
};
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;
}
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;
    codec?: NormalizeCodec | NormalizeArrayCodec; /** For array type columns */
    arrayDimensions?: number; /** For array type relations */
    isArray?: boolean;
    selection?: BuildRelationalQueryResult['selection'];
    isOptional?: boolean;
  } & ({
    field: Column<any>;
    fieldType: 'Column';
  } | {
    field: SQL;
    fieldType: 'SQL';
  } | {
    field: SQL.Aliased;
    fieldType: 'SQL.Aliased';
  } | {
    field: SQLWrapper;
    fieldType: 'SQLWrapper';
  } | {
    field: AggregatedField;
    fieldType: 'AggregatedField';
  } | {
    field: Table | View;
    fieldType: 'Nested';
  }))[];
  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 */

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 */

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> | undefined;
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);
}
interface RelationsBuilderColumnConfig<TTableName extends string = string> {
  readonly tableName: TTableName;
  readonly column: FieldValue;
  readonly through?: RelationsBuilderColumnBase;
  readonly key: string;
}
interface RelationsBuilderColumnBase<TTableName extends string = string> {
  _: RelationsBuilderColumnConfig<TTableName>;
}
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>;
}
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);
}
interface RelationFieldsFilterInternals<T> {
  eq?: T | Placeholder | EmptyFilter;
  ne?: T | Placeholder | EmptyFilter;
  gt?: T | Placeholder | EmptyFilter;
  gte?: T | Placeholder | EmptyFilter;
  lt?: T | Placeholder | EmptyFilter;
  lte?: T | Placeholder | EmptyFilter;
  in?: (T | Placeholder)[] | Placeholder | EmptyFilter;
  notIn?: (T | Placeholder)[] | Placeholder | EmptyFilter;
  arrayContains?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | EmptyFilter;
  arrayContained?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | EmptyFilter;
  arrayOverlaps?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | EmptyFilter;
  like?: string | Placeholder | EmptyFilter;
  ilike?: string | Placeholder | EmptyFilter;
  notLike?: string | Placeholder | EmptyFilter;
  notIlike?: string | Placeholder | EmptyFilter;
  isNull?: true | EmptyFilter;
  isNotNull?: true | EmptyFilter;
  NOT?: RelationsFieldFilter<T> | EmptyFilter;
  OR?: RelationsFieldFilter<T>[] | EmptyFilter;
  AND?: RelationsFieldFilter<T>[] | EmptyFilter;
}
type Primitive = string | number | bigint | boolean | symbol | null | undefined;
type RelationsFieldFilter<T = unknown> = RelationFieldsFilterInternals<T> | (unknown extends T ? never : T extends Primitive ? T : never) | Placeholder;
interface RelationsFilterCommons<TTable extends TableRelationalConfig = TableRelationalConfig, TSchema extends TablesRelationalConfig = TablesRelationalConfig> {
  OR?: RelationsFilter<TTable, TSchema>[] | EmptyFilter;
  NOT?: RelationsFilter<TTable, TSchema> | EmptyFilter;
  AND?: RelationsFilter<TTable, TSchema>[] | EmptyFilter;
  RAW?: SQLWrapper | ((table: TTable['table'], operators: Operators) => SQL | EmptyFilter) | EmptyFilter;
}
type RelationsFilterColumns<TColumns extends Record<string, unknown>> = { [K in keyof TColumns]?: (TColumns[K] extends {
  _: {
    data: infer Data;
  };
} ? RelationsFieldFilter<Data> : RelationsFieldFilter<unknown>) | EmptyFilter };
type RelationsFilterRelations<TTable extends TableRelationalConfig, TSchema extends TablesRelationalConfig, TRelations extends RelationsRecord = TTable['relations']> = { [K in keyof TRelations]?: boolean | RelationsFilter<FindTargetTableInRelationalConfig<TSchema, TRelations[K]>, TSchema> | EmptyFilter };
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>[] | EmptyFilter;
  NOT?: TableFilter<TTable, TColumns> | EmptyFilter;
  AND?: TableFilter<TTable, TColumns>[] | EmptyFilter;
  RAW?: SQLWrapper | ((table: TTable, operators: Operators) => SQL | EmptyFilter) | EmptyFilter;
}
type TableFilterColumns<TColumns extends Record<string, unknown>> = { [K in keyof TColumns]?: (TColumns[K] extends {
  _: {
    data: infer Data;
  };
} ? RelationsFieldFilter<Data> : RelationsFieldFilter<unknown>) | EmptyFilter };
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> | EmptyFilter;
  optional?: TOptional;
  alias?: string;
}
type AnyOneConfig = OneConfig<SchemaEntry, boolean>;
interface ManyConfig<TTargetTable extends SchemaEntry> {
  from?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
  to?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
  where?: TableFilter<TTargetTable> | EmptyFilter;
  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>;
}
interface ManyFn<TTargetTable extends SchemaEntry, TTargetTableName extends string> {
  (config?: ManyConfig<TTargetTable>): Many<TTargetTableName>;
}
declare class RelationsHelperStatic<TTables extends Schema> {
  static readonly [entityKind]: string;
  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]: {} };
/** 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>;
/** 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>;
/** 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>;
/** 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>;
}
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 | undefined | EmptyFilter): SQL | undefined;
declare function relationsFilterToSQL(table: SchemaEntry, filter: AnyRelationsFilter | AnyTableFilter | undefined | EmptyFilter, 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;
    codec?: NormalizeCodec | NormalizeArrayCodec; /** For array type columns */
    arrayDimensions?: number; /** For array type relations */
    isArray?: boolean;
    selection?: BuildRelationalQueryResult["selection"];
    isOptional?: boolean;
  } & ({
    field: Column<any>;
    fieldType: "Column";
  } | {
    field: SQL;
    fieldType: "SQL";
  } | {
    field: SQL.Aliased;
    fieldType: "SQL.Aliased";
  } | {
    field: SQLWrapper;
    fieldType: "SQLWrapper";
  } | {
    field: AggregatedField;
    fieldType: "AggregatedField";
  } | {
    field: Table | View;
    fieldType: "Nested";
  }))[];
};
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>;
declare const EmptyFilter: unique symbol;
type EmptyFilter = typeof EmptyFilter;
//#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, EmptyFilter, EmptyRelations, ExtractObjectValues, ExtractTablesFromSchema, ExtractTablesWithRelations, ExtractTablesWithRelationsParts, Extras, FieldSelection, FieldValue, FilteredSchemaEntry, FindTargetTableInRelationalConfig, GetTableViewColumns, GetTableViewFieldSelection, IncludeEveryTable, InferRelationalQueryTableResult, Many, ManyConfig, ManyFn, NonUndefinedKeysOnly, One, OneConfig, OneFn, Operators, OrderBy, OrderByOperators, Primitive, 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.cts.map