@coffre/cli 0.1.1 → 0.1.3

package/dist/relations-CJCGPRst.js

@@ -0,0 +1,2712 @@
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/entity.js
+const entityKind = Symbol.for("drizzle:entityKind");
+function is(value, type) {
+	if (!value || typeof value !== "object") return false;
+	if (value instanceof type) return true;
+	if (!Object.prototype.hasOwnProperty.call(type, entityKind)) throw new Error(`Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`);
+	let cls = Object.getPrototypeOf(value).constructor;
+	if (cls) while (cls) {
+		if (entityKind in cls && cls[entityKind] === type[entityKind]) return true;
+		cls = Object.getPrototypeOf(cls);
+	}
+	return false;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/column.js
+var Column = class {
+	constructor(table, config) {
+		this.table = table;
+		this.config = config;
+		this.name = config.name;
+		this.keyAsName = config.keyAsName;
+		this.notNull = config.notNull;
+		this.default = config.default;
+		this.defaultFn = config.defaultFn;
+		this.onUpdateFn = config.onUpdateFn;
+		this.hasDefault = config.hasDefault;
+		this.primary = config.primaryKey;
+		this.isUnique = config.isUnique;
+		this.uniqueName = config.uniqueName;
+		this.uniqueType = config.uniqueType;
+		this.dataType = config.dataType;
+		this.columnType = config.columnType;
+		this.generated = config.generated;
+		this.generatedIdentity = config.generatedIdentity;
+	}
+	static [entityKind] = "Column";
+	name;
+	keyAsName;
+	primary;
+	notNull;
+	default;
+	defaultFn;
+	onUpdateFn;
+	hasDefault;
+	isUnique;
+	uniqueName;
+	uniqueType;
+	dataType;
+	columnType;
+	enumValues = void 0;
+	generated = void 0;
+	generatedIdentity = void 0;
+	config;
+	mapFromDriverValue(value) {
+		return value;
+	}
+	mapToDriverValue(value) {
+		return value;
+	}
+	shouldDisableInsert() {
+		return this.config.generated !== void 0 && this.config.generated.type !== "byDefault";
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/column-builder.js
+var ColumnBuilder = class {
+	static [entityKind] = "ColumnBuilder";
+	config;
+	constructor(name, dataType, columnType) {
+		this.config = {
+			name,
+			keyAsName: name === "",
+			notNull: false,
+			default: void 0,
+			hasDefault: false,
+			primaryKey: false,
+			isUnique: false,
+			uniqueName: void 0,
+			uniqueType: void 0,
+			dataType,
+			columnType,
+			generated: void 0
+		};
+	}
+	/**
+	* Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
+	*
+	* @example
+	* ```ts
+	* const users = pgTable('users', {
+	* 	id: integer('id').$type<UserId>().primaryKey(),
+	* 	details: json('details').$type<UserDetails>().notNull(),
+	* });
+	* ```
+	*/
+	$type() {
+		return this;
+	}
+	/**
+	* Adds a `not null` clause to the column definition.
+	*
+	* Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
+	*/
+	notNull() {
+		this.config.notNull = true;
+		return this;
+	}
+	/**
+	* Adds a `default <value>` clause to the column definition.
+	*
+	* Affects the `insert` model of the table - columns *with* `default` are optional on insert.
+	*
+	* If you need to set a dynamic default value, use {@link $defaultFn} instead.
+	*/
+	default(value) {
+		this.config.default = value;
+		this.config.hasDefault = true;
+		return this;
+	}
+	/**
+	* Adds a dynamic default value to the column.
+	* The function will be called when the row is inserted, and the returned value will be used as the column value.
+	*
+	* **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+	*/
+	$defaultFn(fn) {
+		this.config.defaultFn = fn;
+		this.config.hasDefault = true;
+		return this;
+	}
+	/**
+	* Alias for {@link $defaultFn}.
+	*/
+	$default = this.$defaultFn;
+	/**
+	* Adds a dynamic update value to the column.
+	* The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.
+	* If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.
+	*
+	* **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+	*/
+	$onUpdateFn(fn) {
+		this.config.onUpdateFn = fn;
+		this.config.hasDefault = true;
+		return this;
+	}
+	/**
+	* Alias for {@link $onUpdateFn}.
+	*/
+	$onUpdate = this.$onUpdateFn;
+	/**
+	* Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
+	*
+	* In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
+	*/
+	primaryKey() {
+		this.config.primaryKey = true;
+		this.config.notNull = true;
+		return this;
+	}
+	/** @internal Sets the name of the column to the key within the table definition if a name was not given. */
+	setName(name) {
+		if (this.config.name !== "") return;
+		this.config.name = name;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/table.utils.js
+const TableName = Symbol.for("drizzle:Name");
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/foreign-keys.js
+var ForeignKeyBuilder = class {
+	static [entityKind] = "PgForeignKeyBuilder";
+	/** @internal */
+	reference;
+	/** @internal */
+	_onUpdate = "no action";
+	/** @internal */
+	_onDelete = "no action";
+	constructor(config, actions) {
+		this.reference = () => {
+			const { name, columns, foreignColumns } = config();
+			return {
+				name,
+				columns,
+				foreignTable: foreignColumns[0].table,
+				foreignColumns
+			};
+		};
+		if (actions) {
+			this._onUpdate = actions.onUpdate;
+			this._onDelete = actions.onDelete;
+		}
+	}
+	onUpdate(action) {
+		this._onUpdate = action === void 0 ? "no action" : action;
+		return this;
+	}
+	onDelete(action) {
+		this._onDelete = action === void 0 ? "no action" : action;
+		return this;
+	}
+	/** @internal */
+	build(table) {
+		return new ForeignKey(table, this);
+	}
+};
+var ForeignKey = class {
+	constructor(table, builder) {
+		this.table = table;
+		this.reference = builder.reference;
+		this.onUpdate = builder._onUpdate;
+		this.onDelete = builder._onDelete;
+	}
+	static [entityKind] = "PgForeignKey";
+	reference;
+	onUpdate;
+	onDelete;
+	getName() {
+		const { name, columns, foreignColumns } = this.reference();
+		const columnNames = columns.map((column) => column.name);
+		const foreignColumnNames = foreignColumns.map((column) => column.name);
+		const chunks = [
+			this.table[TableName],
+			...columnNames,
+			foreignColumns[0].table[TableName],
+			...foreignColumnNames
+		];
+		return name ?? `${chunks.join("_")}_fk`;
+	}
+};
+function foreignKey(config) {
+	function mappedConfig() {
+		const { name, columns, foreignColumns } = config;
+		return {
+			name,
+			columns,
+			foreignColumns
+		};
+	}
+	return new ForeignKeyBuilder(mappedConfig);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/tracing-utils.js
+function iife(fn, ...args) {
+	return fn(...args);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/unique-constraint.js
+function unique(name) {
+	return new UniqueOnConstraintBuilder(name);
+}
+function uniqueKeyName(table, columns) {
+	return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+var UniqueConstraintBuilder = class {
+	constructor(columns, name) {
+		this.name = name;
+		this.columns = columns;
+	}
+	static [entityKind] = "PgUniqueConstraintBuilder";
+	/** @internal */
+	columns;
+	/** @internal */
+	nullsNotDistinctConfig = false;
+	nullsNotDistinct() {
+		this.nullsNotDistinctConfig = true;
+		return this;
+	}
+	/** @internal */
+	build(table) {
+		return new UniqueConstraint(table, this.columns, this.nullsNotDistinctConfig, this.name);
+	}
+};
+var UniqueOnConstraintBuilder = class {
+	static [entityKind] = "PgUniqueOnConstraintBuilder";
+	/** @internal */
+	name;
+	constructor(name) {
+		this.name = name;
+	}
+	on(...columns) {
+		return new UniqueConstraintBuilder(columns, this.name);
+	}
+};
+var UniqueConstraint = class {
+	constructor(table, columns, nullsNotDistinct, name) {
+		this.table = table;
+		this.columns = columns;
+		this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));
+		this.nullsNotDistinct = nullsNotDistinct;
+	}
+	static [entityKind] = "PgUniqueConstraint";
+	columns;
+	name;
+	nullsNotDistinct = false;
+	getName() {
+		return this.name;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/utils/array.js
+function parsePgArrayValue(arrayString, startFrom, inQuotes) {
+	for (let i = startFrom; i < arrayString.length; i++) {
+		const char = arrayString[i];
+		if (char === "\\") {
+			i++;
+			continue;
+		}
+		if (char === "\"") return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i + 1];
+		if (inQuotes) continue;
+		if (char === "," || char === "}") return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i];
+	}
+	return [arrayString.slice(startFrom).replace(/\\/g, ""), arrayString.length];
+}
+function parsePgNestedArray(arrayString, startFrom = 0) {
+	const result = [];
+	let i = startFrom;
+	let lastCharIsComma = false;
+	while (i < arrayString.length) {
+		const char = arrayString[i];
+		if (char === ",") {
+			if (lastCharIsComma || i === startFrom) result.push("");
+			lastCharIsComma = true;
+			i++;
+			continue;
+		}
+		lastCharIsComma = false;
+		if (char === "\\") {
+			i += 2;
+			continue;
+		}
+		if (char === "\"") {
+			const [value2, startFrom2] = parsePgArrayValue(arrayString, i + 1, true);
+			result.push(value2);
+			i = startFrom2;
+			continue;
+		}
+		if (char === "}") return [result, i + 1];
+		if (char === "{") {
+			const [value2, startFrom2] = parsePgNestedArray(arrayString, i + 1);
+			result.push(value2);
+			i = startFrom2;
+			continue;
+		}
+		const [value, newStartFrom] = parsePgArrayValue(arrayString, i, false);
+		result.push(value);
+		i = newStartFrom;
+	}
+	return [result, i];
+}
+function parsePgArray(arrayString) {
+	const [result] = parsePgNestedArray(arrayString, 1);
+	return result;
+}
+function makePgArray(array) {
+	return `{${array.map((item) => {
+		if (Array.isArray(item)) return makePgArray(item);
+		if (typeof item === "string") return `"${item.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+		return `${item}`;
+	}).join(",")}}`;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/common.js
+var PgColumnBuilder = class extends ColumnBuilder {
+	foreignKeyConfigs = [];
+	static [entityKind] = "PgColumnBuilder";
+	array(size) {
+		return new PgArrayBuilder(this.config.name, this, size);
+	}
+	references(ref, actions = {}) {
+		this.foreignKeyConfigs.push({
+			ref,
+			actions
+		});
+		return this;
+	}
+	unique(name, config) {
+		this.config.isUnique = true;
+		this.config.uniqueName = name;
+		this.config.uniqueType = config?.nulls;
+		return this;
+	}
+	generatedAlwaysAs(as) {
+		this.config.generated = {
+			as,
+			type: "always",
+			mode: "stored"
+		};
+		return this;
+	}
+	/** @internal */
+	buildForeignKeys(column, table) {
+		return this.foreignKeyConfigs.map(({ ref, actions }) => {
+			return iife((ref2, actions2) => {
+				const builder = new ForeignKeyBuilder(() => {
+					const foreignColumn = ref2();
+					return {
+						columns: [column],
+						foreignColumns: [foreignColumn]
+					};
+				});
+				if (actions2.onUpdate) builder.onUpdate(actions2.onUpdate);
+				if (actions2.onDelete) builder.onDelete(actions2.onDelete);
+				return builder.build(table);
+			}, ref, actions);
+		});
+	}
+	/** @internal */
+	buildExtraConfigColumn(table) {
+		return new ExtraConfigColumn(table, this.config);
+	}
+};
+var PgColumn = class extends Column {
+	constructor(table, config) {
+		if (!config.uniqueName) config.uniqueName = uniqueKeyName(table, [config.name]);
+		super(table, config);
+		this.table = table;
+	}
+	static [entityKind] = "PgColumn";
+};
+var ExtraConfigColumn = class extends PgColumn {
+	static [entityKind] = "ExtraConfigColumn";
+	getSQLType() {
+		return this.getSQLType();
+	}
+	indexConfig = {
+		order: this.config.order ?? "asc",
+		nulls: this.config.nulls ?? "last",
+		opClass: this.config.opClass
+	};
+	defaultConfig = {
+		order: "asc",
+		nulls: "last",
+		opClass: void 0
+	};
+	asc() {
+		this.indexConfig.order = "asc";
+		return this;
+	}
+	desc() {
+		this.indexConfig.order = "desc";
+		return this;
+	}
+	nullsFirst() {
+		this.indexConfig.nulls = "first";
+		return this;
+	}
+	nullsLast() {
+		this.indexConfig.nulls = "last";
+		return this;
+	}
+	/**
+	* ### PostgreSQL documentation quote
+	*
+	* > An operator class with optional parameters can be specified for each column of an index.
+	* The operator class identifies the operators to be used by the index for that column.
+	* For example, a B-tree index on four-byte integers would use the int4_ops class;
+	* this operator class includes comparison functions for four-byte integers.
+	* In practice the default operator class for the column's data type is usually sufficient.
+	* The main point of having operator classes is that for some data types, there could be more than one meaningful ordering.
+	* For example, we might want to sort a complex-number data type either by absolute value or by real part.
+	* We could do this by defining two operator classes for the data type and then selecting the proper class when creating an index.
+	* More information about operator classes check:
+	*
+	* ### Useful links
+	* https://www.postgresql.org/docs/current/sql-createindex.html
+	*
+	* https://www.postgresql.org/docs/current/indexes-opclass.html
+	*
+	* https://www.postgresql.org/docs/current/xindex.html
+	*
+	* ### Additional types
+	* If you have the `pg_vector` extension installed in your database, you can use the
+	* `vector_l2_ops`, `vector_ip_ops`, `vector_cosine_ops`, `vector_l1_ops`, `bit_hamming_ops`, `bit_jaccard_ops`, `halfvec_l2_ops`, `sparsevec_l2_ops` options, which are predefined types.
+	*
+	* **You can always specify any string you want in the operator class, in case Drizzle doesn't have it natively in its types**
+	*
+	* @param opClass
+	* @returns
+	*/
+	op(opClass) {
+		this.indexConfig.opClass = opClass;
+		return this;
+	}
+};
+var IndexedColumn = class {
+	static [entityKind] = "IndexedColumn";
+	constructor(name, keyAsName, type, indexConfig) {
+		this.name = name;
+		this.keyAsName = keyAsName;
+		this.type = type;
+		this.indexConfig = indexConfig;
+	}
+	name;
+	keyAsName;
+	type;
+	indexConfig;
+};
+var PgArrayBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgArrayBuilder";
+	constructor(name, baseBuilder, size) {
+		super(name, "array", "PgArray");
+		this.config.baseBuilder = baseBuilder;
+		this.config.size = size;
+	}
+	/** @internal */
+	build(table) {
+		const baseColumn = this.config.baseBuilder.build(table);
+		return new PgArray(table, this.config, baseColumn);
+	}
+};
+var PgArray = class PgArray extends PgColumn {
+	constructor(table, config, baseColumn, range) {
+		super(table, config);
+		this.baseColumn = baseColumn;
+		this.range = range;
+		this.size = config.size;
+	}
+	size;
+	static [entityKind] = "PgArray";
+	getSQLType() {
+		return `${this.baseColumn.getSQLType()}[${typeof this.size === "number" ? this.size : ""}]`;
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") value = parsePgArray(value);
+		return value.map((v) => this.baseColumn.mapFromDriverValue(v));
+	}
+	mapToDriverValue(value, isNestedArray = false) {
+		const a = value.map((v) => v === null ? null : is(this.baseColumn, PgArray) ? this.baseColumn.mapToDriverValue(v, true) : this.baseColumn.mapToDriverValue(v));
+		if (isNestedArray) return a;
+		return makePgArray(a);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/enum.js
+const isPgEnumSym = Symbol.for("drizzle:isPgEnum");
+function isPgEnum(obj) {
+	return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/subquery.js
+var Subquery = class {
+	static [entityKind] = "Subquery";
+	constructor(sql, fields, alias, isWith = false, usedTables = []) {
+		this._ = {
+			brand: "Subquery",
+			sql,
+			selectedFields: fields,
+			alias,
+			isWith,
+			usedTables
+		};
+	}
+};
+var WithSubquery = class extends Subquery {
+	static [entityKind] = "WithSubquery";
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/tracing.js
+const tracer = { startActiveSpan(name, fn) {
+	return fn();
+} };
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/view-common.js
+const ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/table.js
+const Schema = Symbol.for("drizzle:Schema");
+const Columns = Symbol.for("drizzle:Columns");
+const ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
+const OriginalName = Symbol.for("drizzle:OriginalName");
+const BaseName = Symbol.for("drizzle:BaseName");
+const IsAlias = Symbol.for("drizzle:IsAlias");
+const ExtraConfigBuilder = Symbol.for("drizzle:ExtraConfigBuilder");
+const IsDrizzleTable = Symbol.for("drizzle:IsDrizzleTable");
+var Table = class {
+	static [entityKind] = "Table";
+	/** @internal */
+	static Symbol = {
+		Name: TableName,
+		Schema,
+		OriginalName,
+		Columns,
+		ExtraConfigColumns,
+		BaseName,
+		IsAlias,
+		ExtraConfigBuilder
+	};
+	/**
+	* @internal
+	* Can be changed if the table is aliased.
+	*/
+	[TableName];
+	/**
+	* @internal
+	* Used to store the original name of the table, before any aliasing.
+	*/
+	[OriginalName];
+	/** @internal */
+	[Schema];
+	/** @internal */
+	[Columns];
+	/** @internal */
+	[ExtraConfigColumns];
+	/**
+	*  @internal
+	* Used to store the table name before the transformation via the `tableCreator` functions.
+	*/
+	[BaseName];
+	/** @internal */
+	[IsAlias] = false;
+	/** @internal */
+	[IsDrizzleTable] = true;
+	/** @internal */
+	[ExtraConfigBuilder] = void 0;
+	constructor(name, schema, baseName) {
+		this[TableName] = this[OriginalName] = name;
+		this[Schema] = schema;
+		this[BaseName] = baseName;
+	}
+};
+function getTableName(table) {
+	return table[TableName];
+}
+function getTableUniqueName(table) {
+	return `${table[Schema] ?? "public"}.${table[TableName]}`;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/sql/sql.js
+function isSQLWrapper(value) {
+	return value !== null && value !== void 0 && typeof value.getSQL === "function";
+}
+function mergeQueries(queries) {
+	const result = {
+		sql: "",
+		params: []
+	};
+	for (const query of queries) {
+		result.sql += query.sql;
+		result.params.push(...query.params);
+		if (query.typings?.length) {
+			if (!result.typings) result.typings = [];
+			result.typings.push(...query.typings);
+		}
+	}
+	return result;
+}
+var StringChunk = class {
+	static [entityKind] = "StringChunk";
+	value;
+	constructor(value) {
+		this.value = Array.isArray(value) ? value : [value];
+	}
+	getSQL() {
+		return new SQL([this]);
+	}
+};
+var SQL = class SQL {
+	constructor(queryChunks) {
+		this.queryChunks = queryChunks;
+		for (const chunk of queryChunks) if (is(chunk, Table)) {
+			const schemaName = chunk[Table.Symbol.Schema];
+			this.usedTables.push(schemaName === void 0 ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]);
+		}
+	}
+	static [entityKind] = "SQL";
+	/** @internal */
+	decoder = noopDecoder;
+	shouldInlineParams = false;
+	/** @internal */
+	usedTables = [];
+	append(query) {
+		this.queryChunks.push(...query.queryChunks);
+		return this;
+	}
+	toQuery(config) {
+		return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
+			const query = this.buildQueryFromSourceParams(this.queryChunks, config);
+			span?.setAttributes({
+				"drizzle.query.text": query.sql,
+				"drizzle.query.params": JSON.stringify(query.params)
+			});
+			return query;
+		});
+	}
+	buildQueryFromSourceParams(chunks, _config) {
+		const config = Object.assign({}, _config, {
+			inlineParams: _config.inlineParams || this.shouldInlineParams,
+			paramStartIndex: _config.paramStartIndex || { value: 0 }
+		});
+		const { casing, escapeName, escapeParam, prepareTyping, inlineParams, paramStartIndex } = config;
+		return mergeQueries(chunks.map((chunk) => {
+			if (is(chunk, StringChunk)) return {
+				sql: chunk.value.join(""),
+				params: []
+			};
+			if (is(chunk, Name)) return {
+				sql: escapeName(chunk.value),
+				params: []
+			};
+			if (chunk === void 0) return {
+				sql: "",
+				params: []
+			};
+			if (Array.isArray(chunk)) {
+				const result = [new StringChunk("(")];
+				for (const [i, p] of chunk.entries()) {
+					result.push(p);
+					if (i < chunk.length - 1) result.push(new StringChunk(", "));
+				}
+				result.push(new StringChunk(")"));
+				return this.buildQueryFromSourceParams(result, config);
+			}
+			if (is(chunk, SQL)) return this.buildQueryFromSourceParams(chunk.queryChunks, {
+				...config,
+				inlineParams: inlineParams || chunk.shouldInlineParams
+			});
+			if (is(chunk, Table)) {
+				const schemaName = chunk[Table.Symbol.Schema];
+				const tableName = chunk[Table.Symbol.Name];
+				return {
+					sql: schemaName === void 0 || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
+					params: []
+				};
+			}
+			if (is(chunk, Column)) {
+				const columnName = casing.getColumnCasing(chunk);
+				if (_config.invokeSource === "indexes") return {
+					sql: escapeName(columnName),
+					params: []
+				};
+				const schemaName = chunk.table[Table.Symbol.Schema];
+				return {
+					sql: chunk.table[IsAlias] || schemaName === void 0 ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
+					params: []
+				};
+			}
+			if (is(chunk, View)) {
+				const schemaName = chunk[ViewBaseConfig].schema;
+				const viewName = chunk[ViewBaseConfig].name;
+				return {
+					sql: schemaName === void 0 || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
+					params: []
+				};
+			}
+			if (is(chunk, Param)) {
+				if (is(chunk.value, Placeholder)) return {
+					sql: escapeParam(paramStartIndex.value++, chunk),
+					params: [chunk],
+					typings: ["none"]
+				};
+				const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
+				if (is(mappedValue, SQL)) return this.buildQueryFromSourceParams([mappedValue], config);
+				if (inlineParams) return {
+					sql: this.mapInlineParam(mappedValue, config),
+					params: []
+				};
+				let typings = ["none"];
+				if (prepareTyping) typings = [prepareTyping(chunk.encoder)];
+				return {
+					sql: escapeParam(paramStartIndex.value++, mappedValue),
+					params: [mappedValue],
+					typings
+				};
+			}
+			if (is(chunk, Placeholder)) return {
+				sql: escapeParam(paramStartIndex.value++, chunk),
+				params: [chunk],
+				typings: ["none"]
+			};
+			if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== void 0) return {
+				sql: escapeName(chunk.fieldAlias),
+				params: []
+			};
+			if (is(chunk, Subquery)) {
+				if (chunk._.isWith) return {
+					sql: escapeName(chunk._.alias),
+					params: []
+				};
+				return this.buildQueryFromSourceParams([
+					new StringChunk("("),
+					chunk._.sql,
+					new StringChunk(") "),
+					new Name(chunk._.alias)
+				], config);
+			}
+			if (isPgEnum(chunk)) {
+				if (chunk.schema) return {
+					sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName),
+					params: []
+				};
+				return {
+					sql: escapeName(chunk.enumName),
+					params: []
+				};
+			}
+			if (isSQLWrapper(chunk)) {
+				if (chunk.shouldOmitSQLParens?.()) return this.buildQueryFromSourceParams([chunk.getSQL()], config);
+				return this.buildQueryFromSourceParams([
+					new StringChunk("("),
+					chunk.getSQL(),
+					new StringChunk(")")
+				], config);
+			}
+			if (inlineParams) return {
+				sql: this.mapInlineParam(chunk, config),
+				params: []
+			};
+			return {
+				sql: escapeParam(paramStartIndex.value++, chunk),
+				params: [chunk],
+				typings: ["none"]
+			};
+		}));
+	}
+	mapInlineParam(chunk, { escapeString }) {
+		if (chunk === null) return "null";
+		if (typeof chunk === "number" || typeof chunk === "boolean") return chunk.toString();
+		if (typeof chunk === "string") return escapeString(chunk);
+		if (typeof chunk === "object") {
+			const mappedValueAsString = chunk.toString();
+			if (mappedValueAsString === "[object Object]") return escapeString(JSON.stringify(chunk));
+			return escapeString(mappedValueAsString);
+		}
+		throw new Error("Unexpected param value: " + chunk);
+	}
+	getSQL() {
+		return this;
+	}
+	as(alias) {
+		if (alias === void 0) return this;
+		return new SQL.Aliased(this, alias);
+	}
+	mapWith(decoder) {
+		this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
+		return this;
+	}
+	inlineParams() {
+		this.shouldInlineParams = true;
+		return this;
+	}
+	/**
+	* This method is used to conditionally include a part of the query.
+	*
+	* @param condition - Condition to check
+	* @returns itself if the condition is `true`, otherwise `undefined`
+	*/
+	if(condition) {
+		return condition ? this : void 0;
+	}
+};
+var Name = class {
+	constructor(value) {
+		this.value = value;
+	}
+	static [entityKind] = "Name";
+	brand;
+	getSQL() {
+		return new SQL([this]);
+	}
+};
+function isDriverValueEncoder(value) {
+	return typeof value === "object" && value !== null && "mapToDriverValue" in value && typeof value.mapToDriverValue === "function";
+}
+const noopDecoder = { mapFromDriverValue: (value) => value };
+const noopEncoder = { mapToDriverValue: (value) => value };
+({
+	...noopDecoder,
+	...noopEncoder
+});
+var Param = class {
+	/**
+	* @param value - Parameter value
+	* @param encoder - Encoder to convert the value to a driver parameter
+	*/
+	constructor(value, encoder = noopEncoder) {
+		this.value = value;
+		this.encoder = encoder;
+	}
+	static [entityKind] = "Param";
+	brand;
+	getSQL() {
+		return new SQL([this]);
+	}
+};
+function sql(strings, ...params) {
+	const queryChunks = [];
+	if (params.length > 0 || strings.length > 0 && strings[0] !== "") queryChunks.push(new StringChunk(strings[0]));
+	for (const [paramIndex, param2] of params.entries()) queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
+	return new SQL(queryChunks);
+}
+((sql2) => {
+	function empty() {
+		return new SQL([]);
+	}
+	sql2.empty = empty;
+	function fromList(list) {
+		return new SQL(list);
+	}
+	sql2.fromList = fromList;
+	function raw(str) {
+		return new SQL([new StringChunk(str)]);
+	}
+	sql2.raw = raw;
+	function join(chunks, separator) {
+		const result = [];
+		for (const [i, chunk] of chunks.entries()) {
+			if (i > 0 && separator !== void 0) result.push(separator);
+			result.push(chunk);
+		}
+		return new SQL(result);
+	}
+	sql2.join = join;
+	function identifier(value) {
+		return new Name(value);
+	}
+	sql2.identifier = identifier;
+	function placeholder2(name2) {
+		return new Placeholder(name2);
+	}
+	sql2.placeholder = placeholder2;
+	function param2(value, encoder) {
+		return new Param(value, encoder);
+	}
+	sql2.param = param2;
+})(sql || (sql = {}));
+((SQL2) => {
+	class Aliased {
+		constructor(sql2, fieldAlias) {
+			this.sql = sql2;
+			this.fieldAlias = fieldAlias;
+		}
+		static [entityKind] = "SQL.Aliased";
+		/** @internal */
+		isSelectionField = false;
+		getSQL() {
+			return this.sql;
+		}
+		/** @internal */
+		clone() {
+			return new Aliased(this.sql, this.fieldAlias);
+		}
+	}
+	SQL2.Aliased = Aliased;
+})(SQL || (SQL = {}));
+var Placeholder = class {
+	constructor(name2) {
+		this.name = name2;
+	}
+	static [entityKind] = "Placeholder";
+	getSQL() {
+		return new SQL([this]);
+	}
+};
+function fillPlaceholders(params, values) {
+	return params.map((p) => {
+		if (is(p, Placeholder)) {
+			if (!(p.name in values)) throw new Error(`No value for placeholder "${p.name}" was provided`);
+			return values[p.name];
+		}
+		if (is(p, Param) && is(p.value, Placeholder)) {
+			if (!(p.value.name in values)) throw new Error(`No value for placeholder "${p.value.name}" was provided`);
+			return p.encoder.mapToDriverValue(values[p.value.name]);
+		}
+		return p;
+	});
+}
+const IsDrizzleView = Symbol.for("drizzle:IsDrizzleView");
+var View = class {
+	static [entityKind] = "View";
+	/** @internal */
+	[ViewBaseConfig];
+	/** @internal */
+	[IsDrizzleView] = true;
+	constructor({ name: name2, schema, selectedFields, query }) {
+		this[ViewBaseConfig] = {
+			name: name2,
+			originalName: name2,
+			schema,
+			selectedFields,
+			query,
+			isExisting: !query,
+			isAlias: false
+		};
+	}
+	getSQL() {
+		return new SQL([this]);
+	}
+};
+Column.prototype.getSQL = function() {
+	return new SQL([this]);
+};
+Table.prototype.getSQL = function() {
+	return new SQL([this]);
+};
+Subquery.prototype.getSQL = function() {
+	return new SQL([this]);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/utils.js
+function mapResultRow(columns, row, joinsNotNullableMap) {
+	const nullifyMap = {};
+	const result = columns.reduce((result2, { path, field }, columnIndex) => {
+		let decoder;
+		if (is(field, Column)) decoder = field;
+		else if (is(field, SQL)) decoder = field.decoder;
+		else if (is(field, Subquery)) decoder = field._.sql.decoder;
+		else decoder = field.sql.decoder;
+		let node = result2;
+		for (const [pathChunkIndex, pathChunk] of path.entries()) if (pathChunkIndex < path.length - 1) {
+			if (!(pathChunk in node)) node[pathChunk] = {};
+			node = node[pathChunk];
+		} else {
+			const rawValue = row[columnIndex];
+			const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
+			if (joinsNotNullableMap && is(field, Column) && path.length === 2) {
+				const objectName = path[0];
+				if (!(objectName in nullifyMap)) nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
+				else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) nullifyMap[objectName] = false;
+			}
+		}
+		return result2;
+	}, {});
+	if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
+		for (const [objectName, tableName] of Object.entries(nullifyMap)) if (typeof tableName === "string" && !joinsNotNullableMap[tableName]) result[objectName] = null;
+	}
+	return result;
+}
+function orderSelectedFields(fields, pathPrefix) {
+	return Object.entries(fields).reduce((result, [name, field]) => {
+		if (typeof name !== "string") return result;
+		const newPath = pathPrefix ? [...pathPrefix, name] : [name];
+		if (is(field, Column) || is(field, SQL) || is(field, SQL.Aliased) || is(field, Subquery)) result.push({
+			path: newPath,
+			field
+		});
+		else if (is(field, Table)) result.push(...orderSelectedFields(field[Table.Symbol.Columns], newPath));
+		else result.push(...orderSelectedFields(field, newPath));
+		return result;
+	}, []);
+}
+function haveSameKeys(left, right) {
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	if (leftKeys.length !== rightKeys.length) return false;
+	for (const [index, key] of leftKeys.entries()) if (key !== rightKeys[index]) return false;
+	return true;
+}
+function mapUpdateSet(table, values) {
+	const entries = Object.entries(values).filter(([, value]) => value !== void 0).map(([key, value]) => {
+		if (is(value, SQL) || is(value, Column)) return [key, value];
+		else return [key, new Param(value, table[Table.Symbol.Columns][key])];
+	});
+	if (entries.length === 0) throw new Error("No values to set");
+	return Object.fromEntries(entries);
+}
+function applyMixins(baseClass, extendedClasses) {
+	for (const extendedClass of extendedClasses) for (const name of Object.getOwnPropertyNames(extendedClass.prototype)) {
+		if (name === "constructor") continue;
+		Object.defineProperty(baseClass.prototype, name, Object.getOwnPropertyDescriptor(extendedClass.prototype, name) || /* @__PURE__ */ Object.create(null));
+	}
+}
+function getTableColumns(table) {
+	return table[Table.Symbol.Columns];
+}
+function getTableLikeName(table) {
+	return is(table, Subquery) ? table._.alias : is(table, View) ? table[ViewBaseConfig].name : is(table, SQL) ? void 0 : table[Table.Symbol.IsAlias] ? table[Table.Symbol.Name] : table[Table.Symbol.BaseName];
+}
+function getColumnNameAndConfig(a, b) {
+	return {
+		name: typeof a === "string" && a.length > 0 ? a : "",
+		config: typeof a === "object" ? a : b
+	};
+}
+function isConfig(data) {
+	if (typeof data !== "object" || data === null) return false;
+	if (data.constructor.name !== "Object") return false;
+	if ("logger" in data) {
+		const type = typeof data["logger"];
+		if (type !== "boolean" && (type !== "object" || typeof data["logger"]["logQuery"] !== "function") && type !== "undefined") return false;
+		return true;
+	}
+	if ("schema" in data) {
+		const type = typeof data["schema"];
+		if (type !== "object" && type !== "undefined") return false;
+		return true;
+	}
+	if ("casing" in data) {
+		const type = typeof data["casing"];
+		if (type !== "string" && type !== "undefined") return false;
+		return true;
+	}
+	if ("mode" in data) {
+		if (data["mode"] !== "default" || data["mode"] !== "planetscale" || data["mode"] !== void 0) return false;
+		return true;
+	}
+	if ("connection" in data) {
+		const type = typeof data["connection"];
+		if (type !== "string" && type !== "object" && type !== "undefined") return false;
+		return true;
+	}
+	if ("client" in data) {
+		const type = typeof data["client"];
+		if (type !== "object" && type !== "function" && type !== "undefined") return false;
+		return true;
+	}
+	if (Object.keys(data).length === 0) return true;
+	return false;
+}
+const textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder();
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/int.common.js
+var PgIntColumnBaseBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgIntColumnBaseBuilder";
+	generatedAlwaysAsIdentity(sequence) {
+		if (sequence) {
+			const { name, ...options } = sequence;
+			this.config.generatedIdentity = {
+				type: "always",
+				sequenceName: name,
+				sequenceOptions: options
+			};
+		} else this.config.generatedIdentity = { type: "always" };
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+		return this;
+	}
+	generatedByDefaultAsIdentity(sequence) {
+		if (sequence) {
+			const { name, ...options } = sequence;
+			this.config.generatedIdentity = {
+				type: "byDefault",
+				sequenceName: name,
+				sequenceOptions: options
+			};
+		} else this.config.generatedIdentity = { type: "byDefault" };
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+		return this;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/bigint.js
+var PgBigInt53Builder = class extends PgIntColumnBaseBuilder {
+	static [entityKind] = "PgBigInt53Builder";
+	constructor(name) {
+		super(name, "number", "PgBigInt53");
+	}
+	/** @internal */
+	build(table) {
+		return new PgBigInt53(table, this.config);
+	}
+};
+var PgBigInt53 = class extends PgColumn {
+	static [entityKind] = "PgBigInt53";
+	getSQLType() {
+		return "bigint";
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "number") return value;
+		return Number(value);
+	}
+};
+var PgBigInt64Builder = class extends PgIntColumnBaseBuilder {
+	static [entityKind] = "PgBigInt64Builder";
+	constructor(name) {
+		super(name, "bigint", "PgBigInt64");
+	}
+	/** @internal */
+	build(table) {
+		return new PgBigInt64(table, this.config);
+	}
+};
+var PgBigInt64 = class extends PgColumn {
+	static [entityKind] = "PgBigInt64";
+	getSQLType() {
+		return "bigint";
+	}
+	mapFromDriverValue(value) {
+		return BigInt(value);
+	}
+};
+function bigint(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	if (config.mode === "number") return new PgBigInt53Builder(name);
+	return new PgBigInt64Builder(name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/bigserial.js
+var PgBigSerial53Builder = class extends PgColumnBuilder {
+	static [entityKind] = "PgBigSerial53Builder";
+	constructor(name) {
+		super(name, "number", "PgBigSerial53");
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+	}
+	/** @internal */
+	build(table) {
+		return new PgBigSerial53(table, this.config);
+	}
+};
+var PgBigSerial53 = class extends PgColumn {
+	static [entityKind] = "PgBigSerial53";
+	getSQLType() {
+		return "bigserial";
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "number") return value;
+		return Number(value);
+	}
+};
+var PgBigSerial64Builder = class extends PgColumnBuilder {
+	static [entityKind] = "PgBigSerial64Builder";
+	constructor(name) {
+		super(name, "bigint", "PgBigSerial64");
+		this.config.hasDefault = true;
+	}
+	/** @internal */
+	build(table) {
+		return new PgBigSerial64(table, this.config);
+	}
+};
+var PgBigSerial64 = class extends PgColumn {
+	static [entityKind] = "PgBigSerial64";
+	getSQLType() {
+		return "bigserial";
+	}
+	mapFromDriverValue(value) {
+		return BigInt(value);
+	}
+};
+function bigserial(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	if (config.mode === "number") return new PgBigSerial53Builder(name);
+	return new PgBigSerial64Builder(name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/boolean.js
+var PgBooleanBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgBooleanBuilder";
+	constructor(name) {
+		super(name, "boolean", "PgBoolean");
+	}
+	/** @internal */
+	build(table) {
+		return new PgBoolean(table, this.config);
+	}
+};
+var PgBoolean = class extends PgColumn {
+	static [entityKind] = "PgBoolean";
+	getSQLType() {
+		return "boolean";
+	}
+};
+function boolean(name) {
+	return new PgBooleanBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/char.js
+var PgCharBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgCharBuilder";
+	constructor(name, config) {
+		super(name, "string", "PgChar");
+		this.config.length = config.length;
+		this.config.enumValues = config.enum;
+	}
+	/** @internal */
+	build(table) {
+		return new PgChar(table, this.config);
+	}
+};
+var PgChar = class extends PgColumn {
+	static [entityKind] = "PgChar";
+	length = this.config.length;
+	enumValues = this.config.enumValues;
+	getSQLType() {
+		return this.length === void 0 ? `char` : `char(${this.length})`;
+	}
+};
+function char(a, b = {}) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgCharBuilder(name, config);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/cidr.js
+var PgCidrBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgCidrBuilder";
+	constructor(name) {
+		super(name, "string", "PgCidr");
+	}
+	/** @internal */
+	build(table) {
+		return new PgCidr(table, this.config);
+	}
+};
+var PgCidr = class extends PgColumn {
+	static [entityKind] = "PgCidr";
+	getSQLType() {
+		return "cidr";
+	}
+};
+function cidr(name) {
+	return new PgCidrBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/custom.js
+var PgCustomColumnBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgCustomColumnBuilder";
+	constructor(name, fieldConfig, customTypeParams) {
+		super(name, "custom", "PgCustomColumn");
+		this.config.fieldConfig = fieldConfig;
+		this.config.customTypeParams = customTypeParams;
+	}
+	/** @internal */
+	build(table) {
+		return new PgCustomColumn(table, this.config);
+	}
+};
+var PgCustomColumn = class extends PgColumn {
+	static [entityKind] = "PgCustomColumn";
+	sqlName;
+	mapTo;
+	mapFrom;
+	constructor(table, config) {
+		super(table, config);
+		this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
+		this.mapTo = config.customTypeParams.toDriver;
+		this.mapFrom = config.customTypeParams.fromDriver;
+	}
+	getSQLType() {
+		return this.sqlName;
+	}
+	mapFromDriverValue(value) {
+		return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
+	}
+	mapToDriverValue(value) {
+		return typeof this.mapTo === "function" ? this.mapTo(value) : value;
+	}
+};
+function customType(customTypeParams) {
+	return (a, b) => {
+		const { name, config } = getColumnNameAndConfig(a, b);
+		return new PgCustomColumnBuilder(name, config, customTypeParams);
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/date.common.js
+var PgDateColumnBaseBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgDateColumnBaseBuilder";
+	defaultNow() {
+		return this.default(sql`now()`);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/date.js
+var PgDateBuilder = class extends PgDateColumnBaseBuilder {
+	static [entityKind] = "PgDateBuilder";
+	constructor(name) {
+		super(name, "date", "PgDate");
+	}
+	/** @internal */
+	build(table) {
+		return new PgDate(table, this.config);
+	}
+};
+var PgDate = class extends PgColumn {
+	static [entityKind] = "PgDate";
+	getSQLType() {
+		return "date";
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") return new Date(value);
+		return value;
+	}
+	mapToDriverValue(value) {
+		return value.toISOString();
+	}
+};
+var PgDateStringBuilder = class extends PgDateColumnBaseBuilder {
+	static [entityKind] = "PgDateStringBuilder";
+	constructor(name) {
+		super(name, "string", "PgDateString");
+	}
+	/** @internal */
+	build(table) {
+		return new PgDateString(table, this.config);
+	}
+};
+var PgDateString = class extends PgColumn {
+	static [entityKind] = "PgDateString";
+	getSQLType() {
+		return "date";
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") return value;
+		return value.toISOString().slice(0, -14);
+	}
+};
+function date(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	if (config?.mode === "date") return new PgDateBuilder(name);
+	return new PgDateStringBuilder(name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/double-precision.js
+var PgDoublePrecisionBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgDoublePrecisionBuilder";
+	constructor(name) {
+		super(name, "number", "PgDoublePrecision");
+	}
+	/** @internal */
+	build(table) {
+		return new PgDoublePrecision(table, this.config);
+	}
+};
+var PgDoublePrecision = class extends PgColumn {
+	static [entityKind] = "PgDoublePrecision";
+	getSQLType() {
+		return "double precision";
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") return Number.parseFloat(value);
+		return value;
+	}
+};
+function doublePrecision(name) {
+	return new PgDoublePrecisionBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/inet.js
+var PgInetBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgInetBuilder";
+	constructor(name) {
+		super(name, "string", "PgInet");
+	}
+	/** @internal */
+	build(table) {
+		return new PgInet(table, this.config);
+	}
+};
+var PgInet = class extends PgColumn {
+	static [entityKind] = "PgInet";
+	getSQLType() {
+		return "inet";
+	}
+};
+function inet(name) {
+	return new PgInetBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/integer.js
+var PgIntegerBuilder = class extends PgIntColumnBaseBuilder {
+	static [entityKind] = "PgIntegerBuilder";
+	constructor(name) {
+		super(name, "number", "PgInteger");
+	}
+	/** @internal */
+	build(table) {
+		return new PgInteger(table, this.config);
+	}
+};
+var PgInteger = class extends PgColumn {
+	static [entityKind] = "PgInteger";
+	getSQLType() {
+		return "integer";
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") return Number.parseInt(value);
+		return value;
+	}
+};
+function integer(name) {
+	return new PgIntegerBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/interval.js
+var PgIntervalBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgIntervalBuilder";
+	constructor(name, intervalConfig) {
+		super(name, "string", "PgInterval");
+		this.config.intervalConfig = intervalConfig;
+	}
+	/** @internal */
+	build(table) {
+		return new PgInterval(table, this.config);
+	}
+};
+var PgInterval = class extends PgColumn {
+	static [entityKind] = "PgInterval";
+	fields = this.config.intervalConfig.fields;
+	precision = this.config.intervalConfig.precision;
+	getSQLType() {
+		return `interval${this.fields ? ` ${this.fields}` : ""}${this.precision ? `(${this.precision})` : ""}`;
+	}
+};
+function interval(a, b = {}) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgIntervalBuilder(name, config);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/json.js
+var PgJsonBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgJsonBuilder";
+	constructor(name) {
+		super(name, "json", "PgJson");
+	}
+	/** @internal */
+	build(table) {
+		return new PgJson(table, this.config);
+	}
+};
+var PgJson = class extends PgColumn {
+	static [entityKind] = "PgJson";
+	constructor(table, config) {
+		super(table, config);
+	}
+	getSQLType() {
+		return "json";
+	}
+	mapToDriverValue(value) {
+		return JSON.stringify(value);
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") try {
+			return JSON.parse(value);
+		} catch {
+			return value;
+		}
+		return value;
+	}
+};
+function json(name) {
+	return new PgJsonBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/jsonb.js
+var PgJsonbBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgJsonbBuilder";
+	constructor(name) {
+		super(name, "json", "PgJsonb");
+	}
+	/** @internal */
+	build(table) {
+		return new PgJsonb(table, this.config);
+	}
+};
+var PgJsonb = class extends PgColumn {
+	static [entityKind] = "PgJsonb";
+	constructor(table, config) {
+		super(table, config);
+	}
+	getSQLType() {
+		return "jsonb";
+	}
+	mapToDriverValue(value) {
+		return JSON.stringify(value);
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") try {
+			return JSON.parse(value);
+		} catch {
+			return value;
+		}
+		return value;
+	}
+};
+function jsonb(name) {
+	return new PgJsonbBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/line.js
+var PgLineBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgLineBuilder";
+	constructor(name) {
+		super(name, "array", "PgLine");
+	}
+	/** @internal */
+	build(table) {
+		return new PgLineTuple(table, this.config);
+	}
+};
+var PgLineTuple = class extends PgColumn {
+	static [entityKind] = "PgLine";
+	getSQLType() {
+		return "line";
+	}
+	mapFromDriverValue(value) {
+		const [a, b, c] = value.slice(1, -1).split(",");
+		return [
+			Number.parseFloat(a),
+			Number.parseFloat(b),
+			Number.parseFloat(c)
+		];
+	}
+	mapToDriverValue(value) {
+		return `{${value[0]},${value[1]},${value[2]}}`;
+	}
+};
+var PgLineABCBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgLineABCBuilder";
+	constructor(name) {
+		super(name, "json", "PgLineABC");
+	}
+	/** @internal */
+	build(table) {
+		return new PgLineABC(table, this.config);
+	}
+};
+var PgLineABC = class extends PgColumn {
+	static [entityKind] = "PgLineABC";
+	getSQLType() {
+		return "line";
+	}
+	mapFromDriverValue(value) {
+		const [a, b, c] = value.slice(1, -1).split(",");
+		return {
+			a: Number.parseFloat(a),
+			b: Number.parseFloat(b),
+			c: Number.parseFloat(c)
+		};
+	}
+	mapToDriverValue(value) {
+		return `{${value.a},${value.b},${value.c}}`;
+	}
+};
+function line(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	if (!config?.mode || config.mode === "tuple") return new PgLineBuilder(name);
+	return new PgLineABCBuilder(name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/macaddr.js
+var PgMacaddrBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgMacaddrBuilder";
+	constructor(name) {
+		super(name, "string", "PgMacaddr");
+	}
+	/** @internal */
+	build(table) {
+		return new PgMacaddr(table, this.config);
+	}
+};
+var PgMacaddr = class extends PgColumn {
+	static [entityKind] = "PgMacaddr";
+	getSQLType() {
+		return "macaddr";
+	}
+};
+function macaddr(name) {
+	return new PgMacaddrBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/macaddr8.js
+var PgMacaddr8Builder = class extends PgColumnBuilder {
+	static [entityKind] = "PgMacaddr8Builder";
+	constructor(name) {
+		super(name, "string", "PgMacaddr8");
+	}
+	/** @internal */
+	build(table) {
+		return new PgMacaddr8(table, this.config);
+	}
+};
+var PgMacaddr8 = class extends PgColumn {
+	static [entityKind] = "PgMacaddr8";
+	getSQLType() {
+		return "macaddr8";
+	}
+};
+function macaddr8(name) {
+	return new PgMacaddr8Builder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/numeric.js
+var PgNumericBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgNumericBuilder";
+	constructor(name, precision, scale) {
+		super(name, "string", "PgNumeric");
+		this.config.precision = precision;
+		this.config.scale = scale;
+	}
+	/** @internal */
+	build(table) {
+		return new PgNumeric(table, this.config);
+	}
+};
+var PgNumeric = class extends PgColumn {
+	static [entityKind] = "PgNumeric";
+	precision;
+	scale;
+	constructor(table, config) {
+		super(table, config);
+		this.precision = config.precision;
+		this.scale = config.scale;
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") return value;
+		return String(value);
+	}
+	getSQLType() {
+		if (this.precision !== void 0 && this.scale !== void 0) return `numeric(${this.precision}, ${this.scale})`;
+		else if (this.precision === void 0) return "numeric";
+		else return `numeric(${this.precision})`;
+	}
+};
+var PgNumericNumberBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgNumericNumberBuilder";
+	constructor(name, precision, scale) {
+		super(name, "number", "PgNumericNumber");
+		this.config.precision = precision;
+		this.config.scale = scale;
+	}
+	/** @internal */
+	build(table) {
+		return new PgNumericNumber(table, this.config);
+	}
+};
+var PgNumericNumber = class extends PgColumn {
+	static [entityKind] = "PgNumericNumber";
+	precision;
+	scale;
+	constructor(table, config) {
+		super(table, config);
+		this.precision = config.precision;
+		this.scale = config.scale;
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "number") return value;
+		return Number(value);
+	}
+	mapToDriverValue = String;
+	getSQLType() {
+		if (this.precision !== void 0 && this.scale !== void 0) return `numeric(${this.precision}, ${this.scale})`;
+		else if (this.precision === void 0) return "numeric";
+		else return `numeric(${this.precision})`;
+	}
+};
+var PgNumericBigIntBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgNumericBigIntBuilder";
+	constructor(name, precision, scale) {
+		super(name, "bigint", "PgNumericBigInt");
+		this.config.precision = precision;
+		this.config.scale = scale;
+	}
+	/** @internal */
+	build(table) {
+		return new PgNumericBigInt(table, this.config);
+	}
+};
+var PgNumericBigInt = class extends PgColumn {
+	static [entityKind] = "PgNumericBigInt";
+	precision;
+	scale;
+	constructor(table, config) {
+		super(table, config);
+		this.precision = config.precision;
+		this.scale = config.scale;
+	}
+	mapFromDriverValue = BigInt;
+	mapToDriverValue = String;
+	getSQLType() {
+		if (this.precision !== void 0 && this.scale !== void 0) return `numeric(${this.precision}, ${this.scale})`;
+		else if (this.precision === void 0) return "numeric";
+		else return `numeric(${this.precision})`;
+	}
+};
+function numeric(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	const mode = config?.mode;
+	return mode === "number" ? new PgNumericNumberBuilder(name, config?.precision, config?.scale) : mode === "bigint" ? new PgNumericBigIntBuilder(name, config?.precision, config?.scale) : new PgNumericBuilder(name, config?.precision, config?.scale);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/point.js
+var PgPointTupleBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgPointTupleBuilder";
+	constructor(name) {
+		super(name, "array", "PgPointTuple");
+	}
+	/** @internal */
+	build(table) {
+		return new PgPointTuple(table, this.config);
+	}
+};
+var PgPointTuple = class extends PgColumn {
+	static [entityKind] = "PgPointTuple";
+	getSQLType() {
+		return "point";
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") {
+			const [x, y] = value.slice(1, -1).split(",");
+			return [Number.parseFloat(x), Number.parseFloat(y)];
+		}
+		return [value.x, value.y];
+	}
+	mapToDriverValue(value) {
+		return `(${value[0]},${value[1]})`;
+	}
+};
+var PgPointObjectBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgPointObjectBuilder";
+	constructor(name) {
+		super(name, "json", "PgPointObject");
+	}
+	/** @internal */
+	build(table) {
+		return new PgPointObject(table, this.config);
+	}
+};
+var PgPointObject = class extends PgColumn {
+	static [entityKind] = "PgPointObject";
+	getSQLType() {
+		return "point";
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") {
+			const [x, y] = value.slice(1, -1).split(",");
+			return {
+				x: Number.parseFloat(x),
+				y: Number.parseFloat(y)
+			};
+		}
+		return value;
+	}
+	mapToDriverValue(value) {
+		return `(${value.x},${value.y})`;
+	}
+};
+function point(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	if (!config?.mode || config.mode === "tuple") return new PgPointTupleBuilder(name);
+	return new PgPointObjectBuilder(name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/postgis_extension/utils.js
+function hexToBytes(hex) {
+	const bytes = [];
+	for (let c = 0; c < hex.length; c += 2) bytes.push(Number.parseInt(hex.slice(c, c + 2), 16));
+	return new Uint8Array(bytes);
+}
+function bytesToFloat64(bytes, offset) {
+	const view = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+	for (let i = 0; i < 8; i++) view.setUint8(i, bytes[offset + i]);
+	return view.getFloat64(0, true);
+}
+function parseEWKB(hex) {
+	const bytes = hexToBytes(hex);
+	let offset = 0;
+	const byteOrder = bytes[offset];
+	offset += 1;
+	const view = new DataView(bytes.buffer);
+	const geomType = view.getUint32(offset, byteOrder === 1);
+	offset += 4;
+	if (geomType & 536870912) {
+		view.getUint32(offset, byteOrder === 1);
+		offset += 4;
+	}
+	if ((geomType & 65535) === 1) {
+		const x = bytesToFloat64(bytes, offset);
+		offset += 8;
+		const y = bytesToFloat64(bytes, offset);
+		offset += 8;
+		return [x, y];
+	}
+	throw new Error("Unsupported geometry type");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/postgis_extension/geometry.js
+var PgGeometryBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgGeometryBuilder";
+	constructor(name) {
+		super(name, "array", "PgGeometry");
+	}
+	/** @internal */
+	build(table) {
+		return new PgGeometry(table, this.config);
+	}
+};
+var PgGeometry = class extends PgColumn {
+	static [entityKind] = "PgGeometry";
+	getSQLType() {
+		return "geometry(point)";
+	}
+	mapFromDriverValue(value) {
+		return parseEWKB(value);
+	}
+	mapToDriverValue(value) {
+		return `point(${value[0]} ${value[1]})`;
+	}
+};
+var PgGeometryObjectBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgGeometryObjectBuilder";
+	constructor(name) {
+		super(name, "json", "PgGeometryObject");
+	}
+	/** @internal */
+	build(table) {
+		return new PgGeometryObject(table, this.config);
+	}
+};
+var PgGeometryObject = class extends PgColumn {
+	static [entityKind] = "PgGeometryObject";
+	getSQLType() {
+		return "geometry(point)";
+	}
+	mapFromDriverValue(value) {
+		const parsed = parseEWKB(value);
+		return {
+			x: parsed[0],
+			y: parsed[1]
+		};
+	}
+	mapToDriverValue(value) {
+		return `point(${value.x} ${value.y})`;
+	}
+};
+function geometry(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	if (!config?.mode || config.mode === "tuple") return new PgGeometryBuilder(name);
+	return new PgGeometryObjectBuilder(name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/real.js
+var PgRealBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgRealBuilder";
+	constructor(name, length) {
+		super(name, "number", "PgReal");
+		this.config.length = length;
+	}
+	/** @internal */
+	build(table) {
+		return new PgReal(table, this.config);
+	}
+};
+var PgReal = class extends PgColumn {
+	static [entityKind] = "PgReal";
+	constructor(table, config) {
+		super(table, config);
+	}
+	getSQLType() {
+		return "real";
+	}
+	mapFromDriverValue = (value) => {
+		if (typeof value === "string") return Number.parseFloat(value);
+		return value;
+	};
+};
+function real(name) {
+	return new PgRealBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/serial.js
+var PgSerialBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgSerialBuilder";
+	constructor(name) {
+		super(name, "number", "PgSerial");
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+	}
+	/** @internal */
+	build(table) {
+		return new PgSerial(table, this.config);
+	}
+};
+var PgSerial = class extends PgColumn {
+	static [entityKind] = "PgSerial";
+	getSQLType() {
+		return "serial";
+	}
+};
+function serial(name) {
+	return new PgSerialBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/smallint.js
+var PgSmallIntBuilder = class extends PgIntColumnBaseBuilder {
+	static [entityKind] = "PgSmallIntBuilder";
+	constructor(name) {
+		super(name, "number", "PgSmallInt");
+	}
+	/** @internal */
+	build(table) {
+		return new PgSmallInt(table, this.config);
+	}
+};
+var PgSmallInt = class extends PgColumn {
+	static [entityKind] = "PgSmallInt";
+	getSQLType() {
+		return "smallint";
+	}
+	mapFromDriverValue = (value) => {
+		if (typeof value === "string") return Number(value);
+		return value;
+	};
+};
+function smallint(name) {
+	return new PgSmallIntBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/smallserial.js
+var PgSmallSerialBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgSmallSerialBuilder";
+	constructor(name) {
+		super(name, "number", "PgSmallSerial");
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+	}
+	/** @internal */
+	build(table) {
+		return new PgSmallSerial(table, this.config);
+	}
+};
+var PgSmallSerial = class extends PgColumn {
+	static [entityKind] = "PgSmallSerial";
+	getSQLType() {
+		return "smallserial";
+	}
+};
+function smallserial(name) {
+	return new PgSmallSerialBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/text.js
+var PgTextBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgTextBuilder";
+	constructor(name, config) {
+		super(name, "string", "PgText");
+		this.config.enumValues = config.enum;
+	}
+	/** @internal */
+	build(table) {
+		return new PgText(table, this.config);
+	}
+};
+var PgText = class extends PgColumn {
+	static [entityKind] = "PgText";
+	enumValues = this.config.enumValues;
+	getSQLType() {
+		return "text";
+	}
+};
+function text(a, b = {}) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgTextBuilder(name, config);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/time.js
+var PgTimeBuilder = class extends PgDateColumnBaseBuilder {
+	constructor(name, withTimezone, precision) {
+		super(name, "string", "PgTime");
+		this.withTimezone = withTimezone;
+		this.precision = precision;
+		this.config.withTimezone = withTimezone;
+		this.config.precision = precision;
+	}
+	static [entityKind] = "PgTimeBuilder";
+	/** @internal */
+	build(table) {
+		return new PgTime(table, this.config);
+	}
+};
+var PgTime = class extends PgColumn {
+	static [entityKind] = "PgTime";
+	withTimezone;
+	precision;
+	constructor(table, config) {
+		super(table, config);
+		this.withTimezone = config.withTimezone;
+		this.precision = config.precision;
+	}
+	getSQLType() {
+		return `time${this.precision === void 0 ? "" : `(${this.precision})`}${this.withTimezone ? " with time zone" : ""}`;
+	}
+};
+function time(a, b = {}) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgTimeBuilder(name, config.withTimezone ?? false, config.precision);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/timestamp.js
+var PgTimestampBuilder = class extends PgDateColumnBaseBuilder {
+	static [entityKind] = "PgTimestampBuilder";
+	constructor(name, withTimezone, precision) {
+		super(name, "date", "PgTimestamp");
+		this.config.withTimezone = withTimezone;
+		this.config.precision = precision;
+	}
+	/** @internal */
+	build(table) {
+		return new PgTimestamp(table, this.config);
+	}
+};
+var PgTimestamp = class extends PgColumn {
+	static [entityKind] = "PgTimestamp";
+	withTimezone;
+	precision;
+	constructor(table, config) {
+		super(table, config);
+		this.withTimezone = config.withTimezone;
+		this.precision = config.precision;
+	}
+	getSQLType() {
+		return `timestamp${this.precision === void 0 ? "" : ` (${this.precision})`}${this.withTimezone ? " with time zone" : ""}`;
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") return new Date(this.withTimezone ? value : value + "+0000");
+		return value;
+	}
+	mapToDriverValue = (value) => {
+		return value.toISOString();
+	};
+};
+var PgTimestampStringBuilder = class extends PgDateColumnBaseBuilder {
+	static [entityKind] = "PgTimestampStringBuilder";
+	constructor(name, withTimezone, precision) {
+		super(name, "string", "PgTimestampString");
+		this.config.withTimezone = withTimezone;
+		this.config.precision = precision;
+	}
+	/** @internal */
+	build(table) {
+		return new PgTimestampString(table, this.config);
+	}
+};
+var PgTimestampString = class extends PgColumn {
+	static [entityKind] = "PgTimestampString";
+	withTimezone;
+	precision;
+	constructor(table, config) {
+		super(table, config);
+		this.withTimezone = config.withTimezone;
+		this.precision = config.precision;
+	}
+	getSQLType() {
+		return `timestamp${this.precision === void 0 ? "" : `(${this.precision})`}${this.withTimezone ? " with time zone" : ""}`;
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") return value;
+		const shortened = value.toISOString().slice(0, -1).replace("T", " ");
+		if (this.withTimezone) {
+			const offset = value.getTimezoneOffset();
+			return `${shortened}${offset <= 0 ? "+" : "-"}${Math.floor(Math.abs(offset) / 60).toString().padStart(2, "0")}`;
+		}
+		return shortened;
+	}
+};
+function timestamp(a, b = {}) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	if (config?.mode === "string") return new PgTimestampStringBuilder(name, config.withTimezone ?? false, config.precision);
+	return new PgTimestampBuilder(name, config?.withTimezone ?? false, config?.precision);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/uuid.js
+var PgUUIDBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgUUIDBuilder";
+	constructor(name) {
+		super(name, "string", "PgUUID");
+	}
+	/**
+	* Adds `default gen_random_uuid()` to the column definition.
+	*/
+	defaultRandom() {
+		return this.default(sql`gen_random_uuid()`);
+	}
+	/** @internal */
+	build(table) {
+		return new PgUUID(table, this.config);
+	}
+};
+var PgUUID = class extends PgColumn {
+	static [entityKind] = "PgUUID";
+	getSQLType() {
+		return "uuid";
+	}
+};
+function uuid(name) {
+	return new PgUUIDBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/varchar.js
+var PgVarcharBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgVarcharBuilder";
+	constructor(name, config) {
+		super(name, "string", "PgVarchar");
+		this.config.length = config.length;
+		this.config.enumValues = config.enum;
+	}
+	/** @internal */
+	build(table) {
+		return new PgVarchar(table, this.config);
+	}
+};
+var PgVarchar = class extends PgColumn {
+	static [entityKind] = "PgVarchar";
+	length = this.config.length;
+	enumValues = this.config.enumValues;
+	getSQLType() {
+		return this.length === void 0 ? `varchar` : `varchar(${this.length})`;
+	}
+};
+function varchar(a, b = {}) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgVarcharBuilder(name, config);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/vector_extension/bit.js
+var PgBinaryVectorBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgBinaryVectorBuilder";
+	constructor(name, config) {
+		super(name, "string", "PgBinaryVector");
+		this.config.dimensions = config.dimensions;
+	}
+	/** @internal */
+	build(table) {
+		return new PgBinaryVector(table, this.config);
+	}
+};
+var PgBinaryVector = class extends PgColumn {
+	static [entityKind] = "PgBinaryVector";
+	dimensions = this.config.dimensions;
+	getSQLType() {
+		return `bit(${this.dimensions})`;
+	}
+};
+function bit(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgBinaryVectorBuilder(name, config);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/vector_extension/halfvec.js
+var PgHalfVectorBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgHalfVectorBuilder";
+	constructor(name, config) {
+		super(name, "array", "PgHalfVector");
+		this.config.dimensions = config.dimensions;
+	}
+	/** @internal */
+	build(table) {
+		return new PgHalfVector(table, this.config);
+	}
+};
+var PgHalfVector = class extends PgColumn {
+	static [entityKind] = "PgHalfVector";
+	dimensions = this.config.dimensions;
+	getSQLType() {
+		return `halfvec(${this.dimensions})`;
+	}
+	mapToDriverValue(value) {
+		return JSON.stringify(value);
+	}
+	mapFromDriverValue(value) {
+		return value.slice(1, -1).split(",").map((v) => Number.parseFloat(v));
+	}
+};
+function halfvec(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgHalfVectorBuilder(name, config);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/vector_extension/sparsevec.js
+var PgSparseVectorBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgSparseVectorBuilder";
+	constructor(name, config) {
+		super(name, "string", "PgSparseVector");
+		this.config.dimensions = config.dimensions;
+	}
+	/** @internal */
+	build(table) {
+		return new PgSparseVector(table, this.config);
+	}
+};
+var PgSparseVector = class extends PgColumn {
+	static [entityKind] = "PgSparseVector";
+	dimensions = this.config.dimensions;
+	getSQLType() {
+		return `sparsevec(${this.dimensions})`;
+	}
+};
+function sparsevec(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgSparseVectorBuilder(name, config);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/vector_extension/vector.js
+var PgVectorBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgVectorBuilder";
+	constructor(name, config) {
+		super(name, "array", "PgVector");
+		this.config.dimensions = config.dimensions;
+	}
+	/** @internal */
+	build(table) {
+		return new PgVector(table, this.config);
+	}
+};
+var PgVector = class extends PgColumn {
+	static [entityKind] = "PgVector";
+	dimensions = this.config.dimensions;
+	getSQLType() {
+		return `vector(${this.dimensions})`;
+	}
+	mapToDriverValue(value) {
+		return JSON.stringify(value);
+	}
+	mapFromDriverValue(value) {
+		return value.slice(1, -1).split(",").map((v) => Number.parseFloat(v));
+	}
+};
+function vector(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgVectorBuilder(name, config);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/columns/all.js
+function getPgColumnBuilders() {
+	return {
+		bigint,
+		bigserial,
+		boolean,
+		char,
+		cidr,
+		customType,
+		date,
+		doublePrecision,
+		inet,
+		integer,
+		interval,
+		json,
+		jsonb,
+		line,
+		macaddr,
+		macaddr8,
+		numeric,
+		point,
+		geometry,
+		real,
+		serial,
+		smallint,
+		smallserial,
+		text,
+		time,
+		timestamp,
+		uuid,
+		varchar,
+		bit,
+		halfvec,
+		sparsevec,
+		vector
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/table.js
+const InlineForeignKeys = Symbol.for("drizzle:PgInlineForeignKeys");
+const EnableRLS = Symbol.for("drizzle:EnableRLS");
+var PgTable = class extends Table {
+	static [entityKind] = "PgTable";
+	/** @internal */
+	static Symbol = Object.assign({}, Table.Symbol, {
+		InlineForeignKeys,
+		EnableRLS
+	});
+	/**@internal */
+	[InlineForeignKeys] = [];
+	/** @internal */
+	[EnableRLS] = false;
+	/** @internal */
+	[Table.Symbol.ExtraConfigBuilder] = void 0;
+	/** @internal */
+	[Table.Symbol.ExtraConfigColumns] = {};
+};
+function pgTableWithSchema(name, columns, extraConfig, schema, baseName = name) {
+	const rawTable = new PgTable(name, schema, baseName);
+	const parsedColumns = typeof columns === "function" ? columns(getPgColumnBuilders()) : columns;
+	const builtColumns = Object.fromEntries(Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
+		const colBuilder = colBuilderBase;
+		colBuilder.setName(name2);
+		const column = colBuilder.build(rawTable);
+		rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
+		return [name2, column];
+	}));
+	const builtColumnsForExtraConfig = Object.fromEntries(Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
+		const colBuilder = colBuilderBase;
+		colBuilder.setName(name2);
+		return [name2, colBuilder.buildExtraConfigColumn(rawTable)];
+	}));
+	const table = Object.assign(rawTable, builtColumns);
+	table[Table.Symbol.Columns] = builtColumns;
+	table[Table.Symbol.ExtraConfigColumns] = builtColumnsForExtraConfig;
+	if (extraConfig) table[PgTable.Symbol.ExtraConfigBuilder] = extraConfig;
+	return Object.assign(table, { enableRLS: () => {
+		table[PgTable.Symbol.EnableRLS] = true;
+		return table;
+	} });
+}
+const pgTable = (name, columns, extraConfig) => {
+	return pgTableWithSchema(name, columns, extraConfig, void 0);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/pg-core/primary-keys.js
+function primaryKey(...config) {
+	if (config[0].columns) return new PrimaryKeyBuilder(config[0].columns, config[0].name);
+	return new PrimaryKeyBuilder(config);
+}
+var PrimaryKeyBuilder = class {
+	static [entityKind] = "PgPrimaryKeyBuilder";
+	/** @internal */
+	columns;
+	/** @internal */
+	name;
+	constructor(columns, name) {
+		this.columns = columns;
+		this.name = name;
+	}
+	/** @internal */
+	build(table) {
+		return new PrimaryKey(table, this.columns, this.name);
+	}
+};
+var PrimaryKey = class {
+	constructor(table, columns, name) {
+		this.table = table;
+		this.columns = columns;
+		this.name = name;
+	}
+	static [entityKind] = "PgPrimaryKey";
+	columns;
+	name;
+	getName() {
+		return this.name ?? `${this.table[PgTable.Symbol.Name]}_${this.columns.map((column) => column.name).join("_")}_pk`;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/sql/expressions/conditions.js
+function bindIfParam(value, column) {
+	if (isDriverValueEncoder(column) && !isSQLWrapper(value) && !is(value, Param) && !is(value, Placeholder) && !is(value, Column) && !is(value, Table) && !is(value, View)) return new Param(value, column);
+	return value;
+}
+const eq = (left, right) => {
+	return sql`${left} = ${bindIfParam(right, left)}`;
+};
+const ne = (left, right) => {
+	return sql`${left} <> ${bindIfParam(right, left)}`;
+};
+function and(...unfilteredConditions) {
+	const conditions = unfilteredConditions.filter((c) => c !== void 0);
+	if (conditions.length === 0) return;
+	if (conditions.length === 1) return new SQL(conditions);
+	return new SQL([
+		new StringChunk("("),
+		sql.join(conditions, new StringChunk(" and ")),
+		new StringChunk(")")
+	]);
+}
+function or(...unfilteredConditions) {
+	const conditions = unfilteredConditions.filter((c) => c !== void 0);
+	if (conditions.length === 0) return;
+	if (conditions.length === 1) return new SQL(conditions);
+	return new SQL([
+		new StringChunk("("),
+		sql.join(conditions, new StringChunk(" or ")),
+		new StringChunk(")")
+	]);
+}
+function not(condition) {
+	return sql`not ${condition}`;
+}
+const gt = (left, right) => {
+	return sql`${left} > ${bindIfParam(right, left)}`;
+};
+const gte = (left, right) => {
+	return sql`${left} >= ${bindIfParam(right, left)}`;
+};
+const lt = (left, right) => {
+	return sql`${left} < ${bindIfParam(right, left)}`;
+};
+const lte = (left, right) => {
+	return sql`${left} <= ${bindIfParam(right, left)}`;
+};
+function inArray(column, values) {
+	if (Array.isArray(values)) {
+		if (values.length === 0) return sql`false`;
+		return sql`${column} in ${values.map((v) => bindIfParam(v, column))}`;
+	}
+	return sql`${column} in ${bindIfParam(values, column)}`;
+}
+function notInArray(column, values) {
+	if (Array.isArray(values)) {
+		if (values.length === 0) return sql`true`;
+		return sql`${column} not in ${values.map((v) => bindIfParam(v, column))}`;
+	}
+	return sql`${column} not in ${bindIfParam(values, column)}`;
+}
+function isNull(value) {
+	return sql`${value} is null`;
+}
+function isNotNull(value) {
+	return sql`${value} is not null`;
+}
+function exists(subquery) {
+	return sql`exists ${subquery}`;
+}
+function notExists(subquery) {
+	return sql`not exists ${subquery}`;
+}
+function between(column, min, max) {
+	return sql`${column} between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
+}
+function notBetween(column, min, max) {
+	return sql`${column} not between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
+}
+function like(column, value) {
+	return sql`${column} like ${value}`;
+}
+function notLike(column, value) {
+	return sql`${column} not like ${value}`;
+}
+function ilike(column, value) {
+	return sql`${column} ilike ${value}`;
+}
+function notIlike(column, value) {
+	return sql`${column} not ilike ${value}`;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/sql/expressions/select.js
+function asc(column) {
+	return sql`${column} asc`;
+}
+function desc(column) {
+	return sql`${column} desc`;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/relations.js
+var Relation = class {
+	constructor(sourceTable, referencedTable, relationName) {
+		this.sourceTable = sourceTable;
+		this.referencedTable = referencedTable;
+		this.relationName = relationName;
+		this.referencedTableName = referencedTable[Table.Symbol.Name];
+	}
+	static [entityKind] = "Relation";
+	referencedTableName;
+	fieldName;
+};
+var Relations = class {
+	constructor(table, config) {
+		this.table = table;
+		this.config = config;
+	}
+	static [entityKind] = "Relations";
+};
+var One = class One extends Relation {
+	constructor(sourceTable, referencedTable, config, isNullable) {
+		super(sourceTable, referencedTable, config?.relationName);
+		this.config = config;
+		this.isNullable = isNullable;
+	}
+	static [entityKind] = "One";
+	withFieldName(fieldName) {
+		const relation = new One(this.sourceTable, this.referencedTable, this.config, this.isNullable);
+		relation.fieldName = fieldName;
+		return relation;
+	}
+};
+var Many = class Many extends Relation {
+	constructor(sourceTable, referencedTable, config) {
+		super(sourceTable, referencedTable, config?.relationName);
+		this.config = config;
+	}
+	static [entityKind] = "Many";
+	withFieldName(fieldName) {
+		const relation = new Many(this.sourceTable, this.referencedTable, this.config);
+		relation.fieldName = fieldName;
+		return relation;
+	}
+};
+function getOperators() {
+	return {
+		and,
+		between,
+		eq,
+		exists,
+		gt,
+		gte,
+		ilike,
+		inArray,
+		isNull,
+		isNotNull,
+		like,
+		lt,
+		lte,
+		ne,
+		not,
+		notBetween,
+		notExists,
+		notLike,
+		notIlike,
+		notInArray,
+		or,
+		sql
+	};
+}
+function getOrderByOperators() {
+	return {
+		sql,
+		asc,
+		desc
+	};
+}
+function extractTablesRelationalConfig(schema, configHelpers) {
+	if (Object.keys(schema).length === 1 && "default" in schema && !is(schema["default"], Table)) schema = schema["default"];
+	const tableNamesMap = {};
+	const relationsBuffer = {};
+	const tablesConfig = {};
+	for (const [key, value] of Object.entries(schema)) if (is(value, Table)) {
+		const dbName = getTableUniqueName(value);
+		const bufferedRelations = relationsBuffer[dbName];
+		tableNamesMap[dbName] = key;
+		tablesConfig[key] = {
+			tsName: key,
+			dbName: value[Table.Symbol.Name],
+			schema: value[Table.Symbol.Schema],
+			columns: value[Table.Symbol.Columns],
+			relations: bufferedRelations?.relations ?? {},
+			primaryKey: bufferedRelations?.primaryKey ?? []
+		};
+		for (const column of Object.values(value[Table.Symbol.Columns])) if (column.primary) tablesConfig[key].primaryKey.push(column);
+		const extraConfig = value[Table.Symbol.ExtraConfigBuilder]?.(value[Table.Symbol.ExtraConfigColumns]);
+		if (extraConfig) {
+			for (const configEntry of Object.values(extraConfig)) if (is(configEntry, PrimaryKeyBuilder)) tablesConfig[key].primaryKey.push(...configEntry.columns);
+		}
+	} else if (is(value, Relations)) {
+		const dbName = getTableUniqueName(value.table);
+		const tableName = tableNamesMap[dbName];
+		const relations2 = value.config(configHelpers(value.table));
+		let primaryKey;
+		for (const [relationName, relation] of Object.entries(relations2)) if (tableName) {
+			const tableConfig = tablesConfig[tableName];
+			tableConfig.relations[relationName] = relation;
+		} else {
+			if (!(dbName in relationsBuffer)) relationsBuffer[dbName] = {
+				relations: {},
+				primaryKey
+			};
+			relationsBuffer[dbName].relations[relationName] = relation;
+		}
+	}
+	return {
+		tables: tablesConfig,
+		tableNamesMap
+	};
+}
+function relations(table, relations2) {
+	return new Relations(table, (helpers) => Object.fromEntries(Object.entries(relations2(helpers)).map(([key, value]) => [key, value.withFieldName(key)])));
+}
+function createOne(sourceTable) {
+	return function one(table, config) {
+		return new One(sourceTable, table, config, config?.fields.reduce((res, f) => res && f.notNull, true) ?? false);
+	};
+}
+function createMany(sourceTable) {
+	return function many(referencedTable, config) {
+		return new Many(sourceTable, referencedTable, config);
+	};
+}
+function normalizeRelation(schema, tableNamesMap, relation) {
+	if (is(relation, One) && relation.config) return {
+		fields: relation.config.fields,
+		references: relation.config.references
+	};
+	const referencedTableTsName = tableNamesMap[getTableUniqueName(relation.referencedTable)];
+	if (!referencedTableTsName) throw new Error(`Table "${relation.referencedTable[Table.Symbol.Name]}" not found in schema`);
+	const referencedTableConfig = schema[referencedTableTsName];
+	if (!referencedTableConfig) throw new Error(`Table "${referencedTableTsName}" not found in schema`);
+	const sourceTable = relation.sourceTable;
+	const sourceTableTsName = tableNamesMap[getTableUniqueName(sourceTable)];
+	if (!sourceTableTsName) throw new Error(`Table "${sourceTable[Table.Symbol.Name]}" not found in schema`);
+	const reverseRelations = [];
+	for (const referencedTableRelation of Object.values(referencedTableConfig.relations)) if (relation.relationName && relation !== referencedTableRelation && referencedTableRelation.relationName === relation.relationName || !relation.relationName && referencedTableRelation.referencedTable === relation.sourceTable) reverseRelations.push(referencedTableRelation);
+	if (reverseRelations.length > 1) throw relation.relationName ? /* @__PURE__ */ new Error(`There are multiple relations with name "${relation.relationName}" in table "${referencedTableTsName}"`) : /* @__PURE__ */ new Error(`There are multiple relations between "${referencedTableTsName}" and "${relation.sourceTable[Table.Symbol.Name]}". Please specify relation name`);
+	if (reverseRelations[0] && is(reverseRelations[0], One) && reverseRelations[0].config) return {
+		fields: reverseRelations[0].config.references,
+		references: reverseRelations[0].config.fields
+	};
+	throw new Error(`There is not enough information to infer relation "${sourceTableTsName}.${relation.fieldName}"`);
+}
+function createTableRelationsHelpers(sourceTable) {
+	return {
+		one: createOne(sourceTable),
+		many: createMany(sourceTable)
+	};
+}
+function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelection, mapColumnValue = (value) => value) {
+	const result = {};
+	for (const [selectionItemIndex, selectionItem] of buildQueryResultSelection.entries()) if (selectionItem.isJson) {
+		const relation = tableConfig.relations[selectionItem.tsKey];
+		const rawSubRows = row[selectionItemIndex];
+		const subRows = typeof rawSubRows === "string" ? JSON.parse(rawSubRows) : rawSubRows;
+		result[selectionItem.tsKey] = is(relation, One) ? subRows && mapRelationalRow(tablesConfig, tablesConfig[selectionItem.relationTableTsKey], subRows, selectionItem.selection, mapColumnValue) : subRows.map((subRow) => mapRelationalRow(tablesConfig, tablesConfig[selectionItem.relationTableTsKey], subRow, selectionItem.selection, mapColumnValue));
+	} else {
+		const value = mapColumnValue(row[selectionItemIndex]);
+		const field = selectionItem.field;
+		let decoder;
+		if (is(field, Column)) decoder = field;
+		else if (is(field, SQL)) decoder = field.decoder;
+		else decoder = field.sql.decoder;
+		result[selectionItem.tsKey] = value === null ? null : decoder.mapFromDriverValue(value);
+	}
+	return result;
+}
+//#endregion
+export { Subquery as $, bigint as A, textDecoder as B, PgJsonb as C, PgDateString as D, PgDate as E, haveSameKeys as F, sql as G, SQL as H, isConfig as I, Table as J, Columns as K, mapResultRow as L, getColumnNameAndConfig as M, getTableColumns as N, customType as O, getTableLikeName as P, tracer as Q, mapUpdateSet as R, PgNumeric as S, integer as T, View as U, Param as V, fillPlaceholders as W, getTableUniqueName as X, getTableName as Y, ViewBaseConfig as Z, PgTimestamp as _, getOperators as a, TableName as at, PgTime as b, normalizeRelation as c, entityKind as ct, eq as d, WithSubquery as et, primaryKey as f, uuid as g, PgUUID as h, extractTablesRelationalConfig as i, foreignKey as it, applyMixins as j, boolean as k, relations as l, is as lt, pgTable as m, One as n, PgColumn as nt, getOrderByOperators as o, ColumnBuilder as ot, PgTable as p, Schema as q, createTableRelationsHelpers as r, unique as rt, mapRelationalRow as s, Column as st, Many as t, IndexedColumn as tt, and as u, PgTimestampString as v, PgJson as w, text as x, timestamp as y, orderSelectedFields as z };