durcno 1.0.0-alpha.0

package/dist/src/query-builders/insert-returning.mjs

@@ -0,0 +1,63 @@
+import { QueryPromise } from "./query-promise.mjs";
+import { snakeToCamel } from "../utils.mjs";
+import { Query } from "./query.mjs";
+//#region src/query-builders/insert-returning.ts
+var InsertReturningQuery = class extends QueryPromise {
+	#$table;
+	#$values;
+	#$config;
+	#$executor;
+	constructor(table, values, config, executor) {
+		super();
+		this.#$table = table;
+		this.#$values = values;
+		this.#$config = config;
+		this.#$executor = executor;
+	}
+	toQuery() {
+		const query = new Query("INSERT INTO ", this.handleRows.bind(this));
+		query.sql += this.#$table._.fullName;
+		const allFields = /* @__PURE__ */ new Set();
+		for (const field of Object.keys(this.#$values)) allFields.add(field);
+		for (const col in this.#$table._.columns) {
+			const column = this.#$table._.columns[col];
+			if (!allFields.has(col) && column.hasInsertFn) allFields.add(column.name);
+		}
+		const fields = Array.from(allFields);
+		query.sql += " ( ";
+		query.sql += fields.map((field) => `"${this.#$table._.columns[field].nameSnake}"`).join(", ");
+		query.sql += " ) VALUES ( ";
+		const rowValues = [];
+		for (const field of fields) {
+			let value = this.#$values[field];
+			if (value === void 0) {
+				const column = this.#$table._.columns[field];
+				if (column?.hasInsertFn) value = column.getInsertFnVal();
+			}
+			const driverValue = this.#$table._.columns[field]?.toDriver(value);
+			query.arguments.push(driverValue);
+			rowValues.push(`$${query.arguments.length}`);
+		}
+		query.sql += rowValues.join(", ");
+		query.sql += " ) RETURNING *;";
+		return query;
+	}
+	async execute() {
+		const query = this.toQuery();
+		const res = await this.#$executor.query(query.sql, query.arguments);
+		const rows = this.#$executor.getRows(res);
+		return this.handleRows(rows);
+	}
+	handleRows(rows) {
+		const row = rows[0];
+		const { columns } = this.#$table._;
+		for (const [key, value] of Object.entries(row)) {
+			const keyCamel = snakeToCamel(key);
+			row[keyCamel] = columns[keyCamel].fromDriver(value);
+			if (keyCamel !== key) delete row[key];
+		}
+		return row;
+	}
+};
+//#endregion
+export { InsertReturningQuery };

package/dist/src/query-builders/insert.d.mts

@@ -0,0 +1,22 @@
+import { Query } from "./query.mjs";
+import { QueryPromise } from "./query-promise.mjs";
+import { AnyColumn, TableWithColumns } from "../table.mjs";
+import { Config } from "../index.mjs";
+import { QueryExecutor } from "../connectors/common.mjs";
+
+//#region src/query-builders/insert.d.ts
+declare class InsertBuilder<TTableWC extends TableWithColumns<string, string, Record<string, AnyColumn>>> {
+  #private;
+  constructor(table: TTableWC, config: Config, executor: QueryExecutor);
+  values(values: { [colName in keyof TTableWC["_"]["columns"] as TTableWC["_"]["columns"][colName]["ValTypeInsert"] extends never ? never : undefined extends TTableWC["_"]["columns"][colName]["ValTypeInsert"] ? never : colName]: TTableWC["_"]["columns"][colName]["ValTypeInsert"] } & { [colName in keyof TTableWC["_"]["columns"] as TTableWC["_"]["columns"][colName]["ValTypeInsert"] extends never ? never : undefined extends TTableWC["_"]["columns"][colName]["ValTypeInsert"] ? colName : never]?: Exclude<TTableWC["_"]["columns"][colName]["ValTypeInsert"], undefined> } extends infer TValues ? { [colName in keyof TValues as TValues[colName] extends never ? never : colName]: TValues[colName] } | { [colName in keyof TValues as TValues[colName] extends never ? never : colName]: TValues[colName] }[] : never): InsertQuery<TTableWC, undefined, null>;
+}
+declare class InsertQuery<TTableWC extends TableWithColumns<string, string, Record<string, AnyColumn>>, TReturning extends { [ColName in keyof TTableWC["_"]["columns"]]?: true } | { [ColName in keyof TTableWC["_"]["columns"]]?: false } | undefined, TReturn = (TReturning extends Record<Key, boolean> ? TReturning extends { [ColName in keyof TTableWC["_"]["columns"]]?: false } ? { [ColName in keyof TTableWC["_"]["columns"] as TReturning[ColName] extends false ? never : ColName]: TTableWC["_"]["columns"][ColName]["ValTypeSelect"] }[] : { [ColName in keyof TTableWC["_"]["columns"] as TReturning[ColName] extends true ? ColName : never]: TTableWC["_"]["columns"][ColName]["ValTypeSelect"] }[] : null)> extends QueryPromise<TReturn> {
+  #private;
+  constructor(table: TTableWC, values: Record<string, unknown> | Record<string, unknown>[], returnings: TReturning, config: Config, executor: QueryExecutor);
+  returning<TReturnings extends { [ColName in keyof TTableWC["_"]["columns"]]?: true } | { [ColName in keyof TTableWC["_"]["columns"]]?: false }>(returnings: TReturnings): InsertQuery<TTableWC, TReturnings, TReturnings extends Record<Key, boolean> ? TReturnings extends { [ColName in keyof TTableWC["_"]["columns"]]?: false | undefined } ? { [ColName_1 in keyof TTableWC["_"]["columns"] as TReturnings[ColName_1] extends false ? never : ColName_1]: TTableWC["_"]["columns"][ColName_1]["ValTypeSelect"] }[] : { [ColName_2 in keyof TTableWC["_"]["columns"] as TReturnings[ColName_2] extends true ? ColName_2 : never]: TTableWC["_"]["columns"][ColName_2]["ValTypeSelect"] }[] : null>;
+  toQuery(): Query<TReturn>;
+  execute(): Promise<TReturn>;
+  handleRows(rows: Record<string, unknown>[]): TReturn;
+}
+//#endregion
+export { InsertBuilder };

package/dist/src/query-builders/insert.mjs

@@ -0,0 +1,93 @@
+import { QueryPromise } from "./query-promise.mjs";
+import { snakeToCamel } from "../utils.mjs";
+import { Query } from "./query.mjs";
+//#region src/query-builders/insert.ts
+var InsertBuilder = class {
+	#table;
+	#config;
+	#executor;
+	constructor(table, config, executor) {
+		this.#table = table;
+		this.#config = config;
+		this.#executor = executor;
+	}
+	values(values) {
+		return new InsertQuery(this.#table, values, void 0, this.#config, this.#executor);
+	}
+};
+var InsertQuery = class InsertQuery extends QueryPromise {
+	#table;
+	#$values;
+	#$returning;
+	#config;
+	#executor;
+	constructor(table, values, returnings, config, executor) {
+		super();
+		this.#table = table;
+		this.#$values = values;
+		this.#$returning = returnings;
+		this.#config = config;
+		this.#executor = executor;
+	}
+	returning(returnings) {
+		return new InsertQuery(this.#table, this.#$values, returnings, this.#config, this.#executor);
+	}
+	toQuery() {
+		const query = new Query("INSERT INTO ", this.handleRows.bind(this));
+		query.sql += this.#table._.fullName;
+		const valuesArray = Array.isArray(this.#$values) ? this.#$values : [this.#$values];
+		const allFields = /* @__PURE__ */ new Set();
+		for (const row of valuesArray) for (const field of Object.keys(row)) allFields.add(field);
+		for (const col in this.#table._.columns) {
+			const column = this.#table._.columns[col];
+			if (!allFields.has(col) && column.hasInsertFn) allFields.add(column.name);
+		}
+		const fields = Array.from(allFields);
+		query.sql += " ( ";
+		query.sql += fields.map((field) => `"${this.#table._.columns[field].nameSnake}"`).join(", ");
+		query.sql += " ) VALUES";
+		const rowPlaceholders = [];
+		for (let rowIndex = 0; rowIndex < valuesArray.length; rowIndex++) {
+			const row = valuesArray[rowIndex];
+			const rowValues = [];
+			for (const field of fields) {
+				let value = row[field];
+				if (value === void 0) {
+					const column = this.#table._.columns[field];
+					if (column?.hasInsertFn) value = column.getInsertFnVal();
+				}
+				const driverValue = this.#table._.columns[field]?.toDriver(value);
+				query.arguments.push(driverValue);
+				rowValues.push(`$${query.arguments.length}`);
+			}
+			rowPlaceholders.push(`(${rowValues.join(", ")})`);
+		}
+		query.sql += rowPlaceholders.join(",\n  ");
+		if (this.#$returning) {
+			query.sql += " RETURNING ";
+			const returningFields = Object.keys(this.#$returning).filter((k) => this.#$returning?.[k] === true);
+			query.sql += returningFields.map((field) => `"${this.#table._.columns[field].nameSnake}"`).join(", ");
+		}
+		query.sql += ";";
+		return query;
+	}
+	async execute() {
+		const query = this.toQuery();
+		const res = await this.#executor.query(query.sql, query.arguments);
+		const rows = this.#executor.getRows(res);
+		return this.handleRows(rows);
+	}
+	handleRows(rows) {
+		const { columns } = this.#table._;
+		rows.forEach((row) => {
+			for (const [key, value] of Object.entries(row)) {
+				const keyCamel = snakeToCamel(key);
+				row[keyCamel] = columns[keyCamel].fromDriver(value);
+				if (keyCamel !== key) delete row[key];
+			}
+		});
+		return rows;
+	}
+};
+//#endregion
+export { InsertBuilder };

package/dist/src/query-builders/orderby-clause.d.mts

@@ -0,0 +1,14 @@
+import { AnyColumn, AnyTableWithColumns, TableColumn } from "../table.mjs";
+
+//#region src/query-builders/orderby-clause.d.ts
+declare class Order<TTSchema extends string, TTName extends string, TCName extends Key, TCol extends AnyColumn, TOrder extends "ASC" | "DESC"> {
+  readonly field: TableColumn<TTSchema, TTName, TCName, TCol>;
+  readonly order: TOrder;
+  constructor(field: TableColumn<TTSchema, TTName, TCName, TCol>, order: TOrder);
+  toSQL(): string;
+}
+type OrderBy<TTableWC extends AnyTableWithColumns> = TTableWC extends any ? { [ColName in keyof TTableWC["_"]["columns"]]: TTableWC["_"]["columns"][ColName] extends TableColumn<infer TTSchema, infer TTName, infer TCName, infer TColumn> ? Order<TTSchema, TTName, TCName, TColumn, "ASC" | "DESC"> : never }[keyof TTableWC["_"]["columns"]] : never;
+declare function asc<CTSchema extends string, CTName extends string, CName extends Key, Col extends AnyColumn>(field: TableColumn<CTSchema, CTName, CName, Col>): Order<CTSchema, CTName, CName, Col, "ASC">;
+declare function desc<CTSchema extends string, CTName extends string, CName extends Key, Col extends AnyColumn>(field: TableColumn<CTSchema, CTName, CName, Col>): Order<CTSchema, CTName, CName, Col, "DESC">;
+//#endregion
+export { OrderBy, asc, desc };

package/dist/src/query-builders/orderby-clause.mjs

@@ -0,0 +1,20 @@
+//#region src/query-builders/orderby-clause.ts
+var Order = class {
+	field;
+	order;
+	constructor(field, order) {
+		this.field = field;
+		this.order = order;
+	}
+	toSQL() {
+		return `${this.field.fullName} ${this.order}`;
+	}
+};
+function asc(field) {
+	return new Order(field, "ASC");
+}
+function desc(field) {
+	return new Order(field, "DESC");
+}
+//#endregion
+export { asc, desc };

package/dist/src/query-builders/pre.d.mts

@@ -0,0 +1,36 @@
+import { Query } from "./query.mjs";
+import { QueryPromise } from "./query-promise.mjs";
+import { AnyDBorTX } from "../db.mjs";
+import { entityType } from "../symbols.mjs";
+import { Config } from "../index.mjs";
+import { QueryExecutor } from "../connectors/common.mjs";
+
+//#region src/query-builders/pre.d.ts
+declare class Arg<TType> {
+  static readonly [entityType] = "Arg";
+  readonly type: TType;
+  index: number;
+  key: string;
+  readonly handler: (val: TType) => string | number | null;
+  constructor(handler: (val: TType) => string | number | null);
+}
+type AnyArg = Arg<any>;
+declare class PreparedStatement<TArgs extends Record<string, AnyArg>, TReturn> {
+  #private;
+  constructor(query: Query, args: TArgs);
+  run(db: AnyDBorTX, values: { [K in keyof TArgs]: TArgs[K]["type"] }): PreparedQuery<TReturn>;
+}
+declare class PreparedQuery<TReturn> extends QueryPromise<TReturn> {
+  readonly query: Query;
+  readonly config: Config;
+  readonly executor: QueryExecutor;
+  constructor(query: Query, config: Config, executor: QueryExecutor);
+  toQuery(): Query<TReturn>;
+  execute(): Promise<TReturn>;
+  handleRows(rows: any[]): TReturn;
+}
+declare function prequery<TArgs extends Record<string, AnyArg>, TReturn>(args: TArgs, statement: (...args: [{ [K in keyof TArgs]: TArgs[K] }]) => Promise<TReturn> & {
+  toQuery: () => Query;
+}): PreparedStatement<TArgs, TReturn>;
+//#endregion
+export { Arg, prequery };

package/dist/src/query-builders/pre.mjs

@@ -0,0 +1,60 @@
+import { entityType } from "../symbols.mjs";
+import { QueryPromise } from "./query-promise.mjs";
+//#region src/query-builders/pre.ts
+var Arg = class {
+	static [entityType] = "Arg";
+	type;
+	index = 0;
+	key = "";
+	handler;
+	constructor(handler) {
+		this.handler = handler;
+	}
+};
+var PreparedStatement = class {
+	#query;
+	#args;
+	constructor(query, args) {
+		this.#query = query;
+		this.#args = args;
+	}
+	run(db, values) {
+		const args = [];
+		for (const k of this.#query.arguments) args.push(this.#args[k].handler(values[k]));
+		this.#query.arguments = args;
+		return new PreparedQuery(this.#query, db.$.config, db._.getExecutor());
+	}
+};
+var PreparedQuery = class extends QueryPromise {
+	query;
+	config;
+	executor;
+	constructor(query, config, executor) {
+		super();
+		this.query = query;
+		this.config = config;
+		this.executor = executor;
+	}
+	toQuery() {
+		return this.query;
+	}
+	async execute() {
+		const res = await this.executor.query(this.query.sql, this.query.arguments);
+		const rows = this.executor.getRows(res);
+		return this.handleRows(rows);
+	}
+	handleRows(rows) {
+		return this.query.rowsHandler(rows);
+	}
+};
+function prequery(args, statement) {
+	const keys = Object.keys(args).sort();
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		args[key].index = i + 1;
+		args[key].key = key;
+	}
+	return new PreparedStatement(statement(args).toQuery(), args);
+}
+//#endregion
+export { Arg, prequery };

package/dist/src/query-builders/query-promise.d.mts

@@ -0,0 +1,14 @@
+import { Query } from "./query.mjs";
+
+//#region src/query-builders/query-promise.d.ts
+declare abstract class QueryPromise<T> implements Promise<T> {
+  [Symbol.toStringTag]: string;
+  catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
+  finally(onFinally?: (() => void) | null | undefined): Promise<T>;
+  then<TResult1 = T, TResult2 = never>(onFulfilled: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onRejected: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+  abstract toQuery(): Query<T>;
+  abstract execute(): Promise<T>;
+  abstract handleRows(rows: any[]): T;
+}
+//#endregion
+export { QueryPromise };

package/dist/src/query-builders/query-promise.mjs

@@ -0,0 +1,21 @@
+//#region src/query-builders/query-promise.ts
+var QueryPromise = class {
+	[Symbol.toStringTag] = "QueryPromise";
+	catch(onRejected) {
+		return this.then(void 0, onRejected);
+	}
+	finally(onFinally) {
+		return this.then((value) => {
+			onFinally?.();
+			return value;
+		}, (reason) => {
+			onFinally?.();
+			throw reason;
+		});
+	}
+	then(onFulfilled, onRejected) {
+		return this.execute().then(onFulfilled).catch(onRejected);
+	}
+};
+//#endregion
+export { QueryPromise };

package/dist/src/query-builders/query.d.mts

@@ -0,0 +1,14 @@
+import { Arg } from "./pre.mjs";
+
+//#region src/query-builders/query.d.ts
+type SqlArgType = string | number | null;
+declare class Query<T = unknown> {
+  readonly returnType: T;
+  sql: string;
+  arguments: SqlArgType[];
+  rowsHandler: (rows: any[]) => T;
+  constructor(sql: string, rowsHandler: (rows: any[]) => T);
+  addArg(arg: Arg<any>): void;
+}
+//#endregion
+export { Query };

package/dist/src/query-builders/query.mjs

@@ -0,0 +1,17 @@
+//#region src/query-builders/query.ts
+var Query = class {
+	returnType;
+	sql;
+	arguments = [];
+	rowsHandler;
+	constructor(sql, rowsHandler) {
+		this.sql = sql;
+		this.rowsHandler = rowsHandler;
+	}
+	addArg(arg) {
+		this.sql += `$${arg.index}`;
+		this.arguments.push(arg.key);
+	}
+};
+//#endregion
+export { Query };

package/dist/src/query-builders/raw.d.mts

@@ -0,0 +1,14 @@
+import { Query } from "./query.mjs";
+import { QueryPromise } from "./query-promise.mjs";
+import { QueryExecutor } from "../connectors/common.mjs";
+
+//#region src/query-builders/raw.d.ts
+declare class RawQuery<TReturn> extends QueryPromise<TReturn> {
+  #private;
+  readonly handleRows: (rows: unknown[]) => TReturn;
+  constructor(query: string, args: (string | number | null)[] | undefined, rowsHandler: ((rows: unknown[]) => TReturn) | undefined, executor: QueryExecutor);
+  toQuery(): Query<TReturn>;
+  execute(): Promise<TReturn>;
+}
+//#endregion
+export { RawQuery };

package/dist/src/query-builders/raw.mjs

@@ -0,0 +1,26 @@
+import { QueryPromise } from "./query-promise.mjs";
+import { Query } from "./query.mjs";
+//#region src/query-builders/raw.ts
+var RawQuery = class extends QueryPromise {
+	#queryStr;
+	#args;
+	#executor;
+	handleRows;
+	constructor(query, args = [], rowsHandler, executor) {
+		super();
+		this.#queryStr = query;
+		this.#args = args;
+		this.handleRows = rowsHandler ?? ((rows) => rows);
+		this.#executor = executor;
+	}
+	toQuery() {
+		return new Query(this.#queryStr, this.handleRows.bind(this));
+	}
+	async execute() {
+		const res = await this.#executor.query(this.#queryStr, this.#args);
+		const rows = this.#executor.getRows(res);
+		return this.handleRows(rows);
+	}
+};
+//#endregion
+export { RawQuery };

package/dist/src/query-builders/rq.d.mts

@@ -0,0 +1,36 @@
+import { Query } from "./query.mjs";
+import { OrderBy } from "./orderby-clause.mjs";
+import { QueryPromise } from "./query-promise.mjs";
+import { BuildFilterExpression } from "../filters/index.mjs";
+import { AnyColumn, AnyRelation, Fk, Many, Relations, StdRelations, TColsToLeftRight, TableWithColumns } from "../table.mjs";
+import { Config } from "../index.mjs";
+import { QueryExecutor } from "../connectors/common.mjs";
+
+//#region src/query-builders/rq.d.ts
+type RelationReturnType<O, TRelation extends AnyRelation> = TRelation extends Many<any, any, any, any> ? O[] : TRelation extends Fk<any, any, any, infer TCol> ? TCol["isNotNull"] extends true ? O : O | null : O | null;
+type OptionsBase<TTSchema extends string, TTName extends string, TTColumns extends Record<string, AnyColumn>, TAllRelations extends Record<string, StdRelations>> = {
+  columns?: Partial<Record<keyof TableWithColumns<TTSchema, TTName, TTColumns>["_"]["columns"], true>> | Partial<Record<keyof TableWithColumns<TTSchema, TTName, TTColumns>["_"]["columns"], false>>;
+  where?: BuildFilterExpression<TColsToLeftRight<TableWithColumns<TTSchema, TTName, TTColumns>["_"]["columns"]>>;
+  orderBy?: OrderBy<TableWithColumns<TTSchema, TTName, TTColumns>> | OrderBy<TableWithColumns<TTSchema, TTName, TTColumns>>[];
+  limit?: number;
+  with?: keyof TAllRelations[`"${TTSchema}"."${TTName}"`]["map"] extends never ? never : { [TRelationName in keyof TAllRelations[`"${TTSchema}"."${TTName}"`]["map"]]?: OptionsBase<TAllRelations[`"${TTSchema}"."${TTName}"`]["map"][TRelationName]["table"]["_"]["schema"], TAllRelations[`"${TTSchema}"."${TTName}"`]["map"][TRelationName]["table"]["_"]["name"], TAllRelations[`"${TTSchema}"."${TTName}"`]["map"][TRelationName]["table"]["_"]["cols"], TAllRelations> };
+};
+type Options<TTSchema extends string, TTName extends string, TTColumns extends Record<string, AnyColumn>, TAllRelations extends Record<string, StdRelations>, TOffset extends boolean = false> = OptionsBase<TTSchema, TTName, TTColumns, TAllRelations> & {
+  offset?: TOffset extends true ? number : never;
+};
+type Object$1<TTSchema extends string, TTName extends string, TTColumns extends Record<string, AnyColumn>, TAllRelations extends Record<string, Relations<any, any, Record<any, any>, Record<any, AnyRelation>>>, TOptions extends OptionsBase<TTSchema, TTName, TTColumns, TAllRelations>> = (keyof TOptions["columns"] extends never ? TableWithColumns<TTSchema, TTName, TTColumns>["$"]["inferSelect"] : TOptions["columns"] extends Record<string, true> ? { [ColName in keyof TTColumns as TOptions["columns"][ColName] extends true ? ColName : never]: TTColumns[ColName]["ValTypeSelect"] } : TOptions["columns"] extends Record<string, false> ? { [ColName in keyof TTColumns as TOptions["columns"][ColName] extends false ? never : ColName]: TTColumns[ColName]["ValTypeSelect"] } : TableWithColumns<TTSchema, TTName, TTColumns>["$"]["inferSelect"]) & (keyof TOptions["with"] extends never ? Record<never, never> : { [TWith in keyof TOptions["with"]]: TOptions["with"][TWith] extends infer TNestedOptions ? TNestedOptions extends OptionsBase<TAllRelations[`"${TTSchema}"."${TTName}"`]["map"][TWith]["table"]["_"]["schema"], TAllRelations[`"${TTSchema}"."${TTName}"`]["map"][TWith]["table"]["_"]["name"], TAllRelations[`"${TTSchema}"."${TTName}"`]["map"][TWith]["table"]["_"]["cols"], TAllRelations> ? RelationReturnType<{ [K in keyof Object$1<TAllRelations[`"${TTSchema}"."${TTName}"`]["map"][TWith]["table"]["_"]["schema"], TAllRelations[`"${TTSchema}"."${TTName}"`]["map"][TWith]["table"]["_"]["name"], TAllRelations[`"${TTSchema}"."${TTName}"`]["map"][TWith]["table"]["_"]["cols"], TAllRelations, TNestedOptions>]: Object$1<TAllRelations[`"${TTSchema}"."${TTName}"`]["map"][TWith]["table"]["_"]["schema"], TAllRelations[`"${TTSchema}"."${TTName}"`]["map"][TWith]["table"]["_"]["name"], TAllRelations[`"${TTSchema}"."${TTName}"`]["map"][TWith]["table"]["_"]["cols"], TAllRelations, TNestedOptions>[K] }, TAllRelations[`"${TTSchema}"."${TTName}"`]["map"][TWith]> : never : never });
+declare class RelationQueryBuilder<TTSchema extends string, TTName extends string, TTColumns extends Record<string, AnyColumn>, TTRelations extends Relations<TTSchema, TTName, TTColumns, Record<any, AnyRelation>>, TAllRelations extends Record<string, StdRelations>> {
+  #private;
+  constructor(table: TableWithColumns<TTSchema, TTName, TTColumns>, relations: TTRelations, allRelations: TAllRelations, config: Config, executor: QueryExecutor);
+  findMany<TOptions extends Options<TTSchema, TTName, TTColumns, TAllRelations, true>>(options: TOptions): RelationQuery<TTSchema, TTName, TTColumns, TTRelations, TAllRelations, TOptions, { [K in keyof Object$1<TTSchema, TTName, TTColumns, TAllRelations, TOptions>]: Object$1<TTSchema, TTName, TTColumns, TAllRelations, TOptions>[K] }[]>;
+  findFirst<TOptions extends Options<TTSchema, TTName, TTColumns, TAllRelations>>(options: TOptions): Promise<{ [K in keyof Object$1<TTSchema, TTName, TTColumns, TAllRelations, TOptions>]: Object$1<TTSchema, TTName, TTColumns, TAllRelations, TOptions>[K] } | null>;
+}
+declare class RelationQuery<TTSchema extends string, TTName extends string, TTColumns extends Record<string, AnyColumn>, TTRelations extends Relations<TTSchema, TTName, TTColumns, Record<any, AnyRelation>>, TAllRelations extends Record<string, StdRelations>, TOptions extends Options<TTSchema, TTName, TTColumns, TAllRelations, true>, TReturn = { [K in keyof Object$1<TTSchema, TTName, TTColumns, TAllRelations, TOptions>]: Object$1<TTSchema, TTName, TTColumns, TAllRelations, TOptions>[K] }[]> extends QueryPromise<TReturn> {
+  #private;
+  constructor(table: TableWithColumns<TTSchema, TTName, TTColumns>, relations: TTRelations, allRelations: TAllRelations, options: TOptions, config: Config, executor: QueryExecutor);
+  toQuery(): Query<TReturn>;
+  execute(): Promise<TReturn>;
+  handleRows(rows: Record<string, unknown>[]): TReturn;
+}
+//#endregion
+export { RelationQueryBuilder };