appos 0.3.5-0 → 0.3.6-0

package/dist/exports/api/table-6bTIEqON.mjs

@@ -0,0 +1,2636 @@
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/column-common.js
+const OriginalColumn = Symbol.for("drizzle:OriginalColumn");
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/entity.js
+const entityKind = Symbol.for("drizzle:entityKind");
+const hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
+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/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/column.js
+var Column = class {
+	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;
+	length;
+	isLengthExact;
+	isAlias;
+	/** @internal */
+	config;
+	/** @internal */
+	table;
+	/** @internal */
+	onInit() {}
+	constructor(table, config) {
+		this.config = config;
+		this.onInit();
+		this.table = table;
+		this.name = config.name;
+		this.isAlias = false;
+		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;
+		this.length = config["length"];
+		this.isLengthExact = config["isLengthExact"];
+	}
+	mapFromDriverValue(value) {
+		return value;
+	}
+	mapToDriverValue(value) {
+		return value;
+	}
+	shouldDisableInsert() {
+		return this.config.generated !== void 0 && this.config.generated.type !== "byDefault";
+	}
+	/** @internal */
+	[OriginalColumn]() {
+		return this;
+	}
+};
+function getColumnTable(column) {
+	return column.table;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/column-builder.js
+function extractExtendedColumnType(column) {
+	const [type, constraint] = column.dataType.split(" ");
+	return {
+		type,
+		constraint
+	};
+}
+var ColumnBuilder = class {
+	static [entityKind] = "ColumnBuilder";
+	/** @internal */
+	config;
+	constructor(name$1, dataType, columnType) {
+		this.config = {
+			name: name$1,
+			keyAsName: name$1 === "",
+			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$1) {
+		if (this.config.name !== "") return;
+		this.config.name = name$1;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/table.utils.js
+const TableName = Symbol.for("drizzle:Name");
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/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: name$1, columns, foreignColumns } = config();
+			return {
+				name: name$1,
+				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;
+	name;
+	getName() {
+		const { name: name$1, 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$1 ?? `${chunks.join("_")}_fk`;
+	}
+	isNameExplicit() {
+		return !!this.reference().name;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/tracing-utils.js
+function iife(fn, ...args) {
+	return fn(...args);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/utils/array.js
+function parsePgArrayValue(arrayString, startFrom, inQuotes) {
+	for (let i = startFrom; i < arrayString.length; i++) {
+		const char$1 = arrayString[i];
+		if (char$1 === "\\") {
+			i++;
+			continue;
+		}
+		if (char$1 === "\"") return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i + 1];
+		if (inQuotes) continue;
+		if (char$1 === "," || char$1 === "}") 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$1 = arrayString[i];
+		if (char$1 === ",") {
+			if (lastCharIsComma || i === startFrom) result.push("");
+			lastCharIsComma = true;
+			i++;
+			continue;
+		}
+		lastCharIsComma = false;
+		if (char$1 === "\\") {
+			i += 2;
+			continue;
+		}
+		if (char$1 === "\"") {
+			const [value2, startFrom2] = parsePgArrayValue(arrayString, i + 1, true);
+			result.push(value2);
+			i = startFrom2;
+			continue;
+		}
+		if (char$1 === "}") return [result, i + 1];
+		if (char$1 === "{") {
+			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/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/common.js
+var PgColumnBuilder = class extends ColumnBuilder {
+	foreignKeyConfigs = [];
+	static [entityKind] = "PgColumnBuilder";
+	array(length) {
+		return new PgArrayBuilder(this.config.name, this, length);
+	}
+	references(ref, config = {}) {
+		this.foreignKeyConfigs.push({
+			ref,
+			config
+		});
+		return this;
+	}
+	unique(name$1, config) {
+		this.config.isUnique = true;
+		this.config.uniqueName = name$1;
+		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, config }) => {
+			return iife((ref2, config2) => {
+				const builder = new ForeignKeyBuilder(() => {
+					const foreignColumn = ref2();
+					return {
+						name: config2.name,
+						columns: [column],
+						foreignColumns: [foreignColumn]
+					};
+				});
+				if (config2.onUpdate) builder.onUpdate(config2.onUpdate);
+				if (config2.onDelete) builder.onDelete(config2.onDelete);
+				return builder.build(table);
+			}, ref, config);
+		});
+	}
+	/** @internal */
+	buildExtraConfigColumn(table) {
+		return new ExtraConfigColumn(table, this.config);
+	}
+};
+var PgColumn = class extends Column {
+	static [entityKind] = "PgColumn";
+	/** @internal */
+	table;
+	constructor(table, config) {
+		super(table, config);
+		this.table = table;
+	}
+};
+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$1, keyAsName, type, indexConfig) {
+		this.name = name$1;
+		this.keyAsName = keyAsName;
+		this.type = type;
+		this.indexConfig = indexConfig;
+	}
+	name;
+	keyAsName;
+	type;
+	indexConfig;
+};
+var PgArrayBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgArrayBuilder";
+	constructor(name$1, baseBuilder, length) {
+		super(name$1, "array basecolumn", "PgArray");
+		this.config.baseBuilder = baseBuilder;
+		this.config.length = length;
+	}
+	/** @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;
+	}
+	static [entityKind] = "PgArray";
+	getSQLType() {
+		return `${this.baseColumn.getSQLType()}[${typeof this.length === "number" ? this.length : ""}]`;
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") value = parsePgArray(value);
+		return value.map((v) => this.baseColumn.mapFromDriverValue(v));
+	}
+	mapFromJsonValue(value) {
+		if (typeof value === "string") value = parsePgArray(value);
+		const base = this.baseColumn;
+		return "mapFromJsonValue" in base ? value.map((v) => base.mapFromJsonValue(v)) : value.map((v) => base.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/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/enum.js
+var PgEnumObjectColumnBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgEnumObjectColumnBuilder";
+	constructor(name$1, enumInstance) {
+		super(name$1, "string enum", "PgEnumObjectColumn");
+		this.config.enum = enumInstance;
+	}
+	/** @internal */
+	build(table) {
+		return new PgEnumObjectColumn(table, this.config);
+	}
+};
+var PgEnumObjectColumn = class extends PgColumn {
+	static [entityKind] = "PgEnumObjectColumn";
+	enum;
+	enumValues = this.config.enum.enumValues;
+	constructor(table, config) {
+		super(table, config);
+		this.enum = config.enum;
+	}
+	getSQLType() {
+		return this.enum.enumName;
+	}
+};
+const isPgEnumSym = Symbol.for("drizzle:isPgEnum");
+function isPgEnum(obj) {
+	return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
+}
+var PgEnumColumnBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgEnumColumnBuilder";
+	constructor(name$1, enumInstance) {
+		super(name$1, "string enum", "PgEnumColumn");
+		this.config.enum = enumInstance;
+	}
+	/** @internal */
+	build(table) {
+		return new PgEnumColumn(table, this.config);
+	}
+};
+var PgEnumColumn = class extends PgColumn {
+	static [entityKind] = "PgEnumColumn";
+	enum = this.config.enum;
+	enumValues = this.config.enum.enumValues;
+	constructor(table, config) {
+		super(table, config);
+		this.enum = config.enum;
+	}
+	getSQLType() {
+		return this.enum.enumName;
+	}
+};
+function pgEnum(enumName, input) {
+	return Array.isArray(input) ? pgEnumWithSchema(enumName, [...input], void 0) : pgEnumObjectWithSchema(enumName, input, void 0);
+}
+function pgEnumWithSchema(enumName, values, schema) {
+	const enumInstance = Object.assign((name$1) => new PgEnumColumnBuilder(name$1 ?? "", enumInstance), {
+		enumName,
+		enumValues: values,
+		schema,
+		[isPgEnumSym]: true
+	});
+	return enumInstance;
+}
+function pgEnumObjectWithSchema(enumName, values, schema) {
+	const enumInstance = Object.assign((name$1) => new PgEnumObjectColumnBuilder(name$1 ?? "", enumInstance), {
+		enumName,
+		enumValues: Object.values(values),
+		schema,
+		[isPgEnumSym]: true
+	});
+	return enumInstance;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/subquery.js
+var Subquery = class {
+	static [entityKind] = "Subquery";
+	constructor(sql$1, fields, alias, isWith = false, usedTables = []) {
+		this._ = {
+			brand: "Subquery",
+			sql: sql$1,
+			selectedFields: fields,
+			alias,
+			isWith,
+			usedTables
+		};
+	}
+};
+var WithSubquery = class extends Subquery {
+	static [entityKind] = "WithSubquery";
+};
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/tracing.js
+const tracer = { startActiveSpan(name$1, fn) {
+	return fn();
+} };
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/view-common.js
+const ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/table.js
+const TableSchema = Symbol.for("drizzle:Schema");
+const TableColumns = 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: TableSchema,
+		OriginalName,
+		Columns: TableColumns,
+		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 */
+	[TableSchema];
+	/** @internal */
+	[TableColumns];
+	/** @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$1, schema, baseName) {
+		this[TableName] = this[OriginalName] = name$1;
+		this[TableSchema] = schema;
+		this[BaseName] = baseName;
+	}
+};
+function isTable(table) {
+	return typeof table === "object" && table !== null && IsDrizzleTable in table;
+}
+function getTableName(table) {
+	return table[TableName];
+}
+function getTableUniqueName(table) {
+	return `${table[TableSchema] ?? "public"}.${table[TableName]}`;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/sql/sql.js
+var FakePrimitiveParam = class {
+	static [entityKind] = "FakePrimitiveParam";
+};
+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, invokeSource } = 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];
+				if (invokeSource === "mssql-view-with-schemabinding") return {
+					sql: (schemaName === void 0 ? escapeName("dbo") : escapeName(schemaName)) + "." + escapeName(tableName),
+					params: []
+				};
+				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 = invokeSource === "mssql-check" ? void 0 : chunk.table[Table.Symbol.Schema];
+				return {
+					sql: chunk.isAlias ? escapeName(chunk.name) : 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" || typeof chunk === "bigint") 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 name(value) {
+	return new Name(value);
+}
+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 };
+const noopMapper = {
+	...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 param(value, encoder) {
+	return new Param(value, encoder);
+}
+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 placeholder(name2) {
+	return new Placeholder(name2);
+}
+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;
+	/** @internal */
+	get [TableName]() {
+		return this[ViewBaseConfig].name;
+	}
+	/** @internal */
+	get [TableSchema]() {
+		return this[ViewBaseConfig].schema;
+	}
+	/** @internal */
+	get [IsAlias]() {
+		return this[ViewBaseConfig].isAlias;
+	}
+	/** @internal */
+	get [OriginalName]() {
+		return this[ViewBaseConfig].originalName;
+	}
+	/** @internal */
+	get [TableColumns]() {
+		return this[ViewBaseConfig].selectedFields;
+	}
+	constructor({ name: name2, schema, selectedFields, query }) {
+		this[ViewBaseConfig] = {
+			name: name2,
+			originalName: name2,
+			schema,
+			selectedFields,
+			query,
+			isExisting: !query,
+			isAlias: false
+		};
+	}
+};
+function isView(view) {
+	return typeof view === "object" && view !== null && IsDrizzleView in view;
+}
+function getViewName(view) {
+	return view[ViewBaseConfig].name;
+}
+Column.prototype.getSQL = function() {
+	return new SQL([this]);
+};
+Subquery.prototype.getSQL = function() {
+	return new SQL([this]);
+};
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/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$1, field]) => {
+		if (typeof name$1 !== "string") return result;
+		const newPath = pathPrefix ? [...pathPrefix, name$1] : [name$1];
+		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$1 of Object.getOwnPropertyNames(extendedClass.prototype)) {
+		if (name$1 === "constructor") continue;
+		Object.defineProperty(baseClass.prototype, name$1, Object.getOwnPropertyDescriptor(extendedClass.prototype, name$1) || /* @__PURE__ */ Object.create(null));
+	}
+}
+function getTableColumns(table) {
+	return table[Table.Symbol.Columns];
+}
+function getViewSelectedFields(view) {
+	return view[ViewBaseConfig].selectedFields;
+}
+function getColumns(table) {
+	return is(table, Table) ? table[Table.Symbol.Columns] : is(table, View) ? table[ViewBaseConfig].selectedFields : table._.selectedFields;
+}
+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 ("relations" in data) {
+		const type = typeof data["relations"];
+		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/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/int.common.js
+var PgIntColumnBaseBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgIntColumnBaseBuilder";
+	generatedAlwaysAsIdentity(sequence) {
+		if (sequence) {
+			const { name: name$1, ...options } = sequence;
+			this.config.generatedIdentity = {
+				type: "always",
+				sequenceName: name$1,
+				sequenceOptions: options
+			};
+		} else this.config.generatedIdentity = { type: "always" };
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+		return this;
+	}
+	generatedByDefaultAsIdentity(sequence) {
+		if (sequence) {
+			const { name: name$1, ...options } = sequence;
+			this.config.generatedIdentity = {
+				type: "byDefault",
+				sequenceName: name$1,
+				sequenceOptions: options
+			};
+		} else this.config.generatedIdentity = { type: "byDefault" };
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+		return this;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/bigint.js
+var PgBigInt53Builder = class extends PgIntColumnBaseBuilder {
+	static [entityKind] = "PgBigInt53Builder";
+	constructor(name$1) {
+		super(name$1, "number int53", "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$1) {
+		super(name$1, "bigint int64", "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);
+	}
+};
+var PgBigIntStringBuilder = class extends PgIntColumnBaseBuilder {
+	static [entityKind] = "PgBigIntStringBuilder";
+	constructor(name$1) {
+		super(name$1, "string int64", "PgBigIntString");
+	}
+	/** @internal */
+	build(table) {
+		return new PgBigIntString(table, this.config);
+	}
+};
+var PgBigIntString = class extends PgColumn {
+	static [entityKind] = "PgBigIntString";
+	getSQLType() {
+		return "bigint";
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") return value;
+		return String(value);
+	}
+};
+function bigint(a, b) {
+	const { name: name$1, config } = getColumnNameAndConfig(a, b);
+	if (config.mode === "number") return new PgBigInt53Builder(name$1);
+	if (config.mode === "string") return new PgBigIntStringBuilder(name$1);
+	return new PgBigInt64Builder(name$1);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/bigserial.js
+var PgBigSerial53Builder = class extends PgColumnBuilder {
+	static [entityKind] = "PgBigSerial53Builder";
+	constructor(name$1) {
+		super(name$1, "number int53", "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$1) {
+		super(name$1, "bigint int64", "PgBigSerial64");
+		this.config.hasDefault = true;
+		this.config.notNull = 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: name$1, config } = getColumnNameAndConfig(a, b);
+	if (config.mode === "number") return new PgBigSerial53Builder(name$1);
+	return new PgBigSerial64Builder(name$1);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/boolean.js
+var PgBooleanBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgBooleanBuilder";
+	constructor(name$1) {
+		super(name$1, "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$1) {
+	return new PgBooleanBuilder(name$1 ?? "");
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/char.js
+var PgCharBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgCharBuilder";
+	constructor(name$1, config) {
+		super(name$1, config.enum?.length ? "string enum" : "string", "PgChar");
+		this.config.length = config.length ?? 1;
+		this.config.setLength = config.length !== void 0;
+		this.config.enumValues = config.enum;
+	}
+	/** @internal */
+	build(table) {
+		return new PgChar(table, this.config);
+	}
+};
+var PgChar = class extends PgColumn {
+	static [entityKind] = "PgChar";
+	enumValues = this.config.enumValues;
+	getSQLType() {
+		return this.config.setLength ? `char(${this.length})` : `char`;
+	}
+};
+function char(a, b = {}) {
+	const { name: name$1, config } = getColumnNameAndConfig(a, b);
+	return new PgCharBuilder(name$1, config);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/cidr.js
+var PgCidrBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgCidrBuilder";
+	constructor(name$1) {
+		super(name$1, "string cidr", "PgCidr");
+	}
+	/** @internal */
+	build(table) {
+		return new PgCidr(table, this.config);
+	}
+};
+var PgCidr = class extends PgColumn {
+	static [entityKind] = "PgCidr";
+	getSQLType() {
+		return "cidr";
+	}
+};
+function cidr(name$1) {
+	return new PgCidrBuilder(name$1 ?? "");
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/custom.js
+var PgCustomColumnBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgCustomColumnBuilder";
+	constructor(name$1, fieldConfig, customTypeParams) {
+		super(name$1, "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;
+	mapJson;
+	forJsonSelect;
+	constructor(table, config) {
+		super(table, config);
+		this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
+		this.mapTo = config.customTypeParams.toDriver;
+		this.mapFrom = config.customTypeParams.fromDriver;
+		this.mapJson = config.customTypeParams.fromJson;
+		this.forJsonSelect = config.customTypeParams.forJsonSelect;
+	}
+	getSQLType() {
+		return this.sqlName;
+	}
+	mapFromDriverValue(value) {
+		return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
+	}
+	mapFromJsonValue(value) {
+		return typeof this.mapJson === "function" ? this.mapJson(value) : this.mapFromDriverValue(value);
+	}
+	jsonSelectIdentifier(identifier, sql$1, arrayDimensions) {
+		if (typeof this.forJsonSelect === "function") return this.forJsonSelect(identifier, sql$1, arrayDimensions);
+		const rawType = this.getSQLType().toLowerCase();
+		const parenPos = rawType.indexOf("(");
+		switch (parenPos + 1 ? rawType.slice(0, parenPos) : rawType) {
+			case "bytea":
+			case "geometry":
+			case "timestamp":
+			case "numeric":
+			case "bigint": {
+				const arrVal = "[]".repeat(arrayDimensions ?? 0);
+				return sql$1`${identifier}::text${sql$1.raw(arrVal).if(arrayDimensions)}`;
+			}
+			default: return identifier;
+		}
+	}
+	mapToDriverValue(value) {
+		return typeof this.mapTo === "function" ? this.mapTo(value) : value;
+	}
+};
+function customType(customTypeParams) {
+	return (a, b) => {
+		const { name: name$1, config } = getColumnNameAndConfig(a, b);
+		return new PgCustomColumnBuilder(name$1, config, customTypeParams);
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/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/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/date.js
+var PgDateBuilder = class extends PgDateColumnBaseBuilder {
+	static [entityKind] = "PgDateBuilder";
+	constructor(name$1) {
+		super(name$1, "object 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) {
+		if (typeof value === "string") return value;
+		return value.toISOString();
+	}
+};
+var PgDateStringBuilder = class extends PgDateColumnBaseBuilder {
+	static [entityKind] = "PgDateStringBuilder";
+	constructor(name$1) {
+		super(name$1, "string date", "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);
+	}
+	mapToDriverValue(value) {
+		if (typeof value === "string") return value;
+		return value.toISOString();
+	}
+};
+function date(a, b) {
+	const { name: name$1, config } = getColumnNameAndConfig(a, b);
+	if (config?.mode === "date") return new PgDateBuilder(name$1);
+	return new PgDateStringBuilder(name$1);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/double-precision.js
+var PgDoublePrecisionBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgDoublePrecisionBuilder";
+	constructor(name$1) {
+		super(name$1, "number double", "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$1) {
+	return new PgDoublePrecisionBuilder(name$1 ?? "");
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/inet.js
+var PgInetBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgInetBuilder";
+	constructor(name$1) {
+		super(name$1, "string inet", "PgInet");
+	}
+	/** @internal */
+	build(table) {
+		return new PgInet(table, this.config);
+	}
+};
+var PgInet = class extends PgColumn {
+	static [entityKind] = "PgInet";
+	getSQLType() {
+		return "inet";
+	}
+};
+function inet(name$1) {
+	return new PgInetBuilder(name$1 ?? "");
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/integer.js
+var PgIntegerBuilder = class extends PgIntColumnBaseBuilder {
+	static [entityKind] = "PgIntegerBuilder";
+	constructor(name$1) {
+		super(name$1, "number int32", "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$1) {
+	return new PgIntegerBuilder(name$1 ?? "");
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/interval.js
+var PgIntervalBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgIntervalBuilder";
+	constructor(name$1, intervalConfig) {
+		super(name$1, "string interval", "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: name$1, config } = getColumnNameAndConfig(a, b);
+	return new PgIntervalBuilder(name$1, config);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/json.js
+var PgJsonBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgJsonBuilder";
+	constructor(name$1) {
+		super(name$1, "object 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$1) {
+	return new PgJsonBuilder(name$1 ?? "");
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/jsonb.js
+var PgJsonbBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgJsonbBuilder";
+	constructor(name$1) {
+		super(name$1, "object 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$1) {
+	return new PgJsonbBuilder(name$1 ?? "");
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/line.js
+var PgLineBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgLineBuilder";
+	constructor(name$1) {
+		super(name$1, "array line", "PgLine");
+	}
+	/** @internal */
+	build(table) {
+		return new PgLineTuple(table, this.config);
+	}
+};
+var PgLineTuple = class extends PgColumn {
+	static [entityKind] = "PgLine";
+	mode = "tuple";
+	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$1) {
+		super(name$1, "object line", "PgLineABC");
+	}
+	/** @internal */
+	build(table) {
+		return new PgLineABC(table, this.config);
+	}
+};
+var PgLineABC = class extends PgColumn {
+	static [entityKind] = "PgLineABC";
+	mode = "abc";
+	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: name$1, config } = getColumnNameAndConfig(a, b);
+	if (!config?.mode || config.mode === "tuple") return new PgLineBuilder(name$1);
+	return new PgLineABCBuilder(name$1);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/macaddr.js
+var PgMacaddrBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgMacaddrBuilder";
+	constructor(name$1) {
+		super(name$1, "string macaddr", "PgMacaddr");
+	}
+	/** @internal */
+	build(table) {
+		return new PgMacaddr(table, this.config);
+	}
+};
+var PgMacaddr = class extends PgColumn {
+	static [entityKind] = "PgMacaddr";
+	getSQLType() {
+		return "macaddr";
+	}
+};
+function macaddr(name$1) {
+	return new PgMacaddrBuilder(name$1 ?? "");
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/macaddr8.js
+var PgMacaddr8Builder = class extends PgColumnBuilder {
+	static [entityKind] = "PgMacaddr8Builder";
+	constructor(name$1) {
+		super(name$1, "string macaddr8", "PgMacaddr8");
+	}
+	/** @internal */
+	build(table) {
+		return new PgMacaddr8(table, this.config);
+	}
+};
+var PgMacaddr8 = class extends PgColumn {
+	static [entityKind] = "PgMacaddr8";
+	getSQLType() {
+		return "macaddr8";
+	}
+};
+function macaddr8(name$1) {
+	return new PgMacaddr8Builder(name$1 ?? "");
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/numeric.js
+var PgNumericBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgNumericBuilder";
+	constructor(name$1, precision, scale) {
+		super(name$1, "string numeric", "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$1, precision, scale) {
+		super(name$1, "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$1, precision, scale) {
+		super(name$1, "bigint int64", "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: name$1, config } = getColumnNameAndConfig(a, b);
+	const mode = config?.mode;
+	return mode === "number" ? new PgNumericNumberBuilder(name$1, config?.precision, config?.scale) : mode === "bigint" ? new PgNumericBigIntBuilder(name$1, config?.precision, config?.scale) : new PgNumericBuilder(name$1, config?.precision, config?.scale);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/point.js
+var PgPointTupleBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgPointTupleBuilder";
+	constructor(name$1) {
+		super(name$1, "array point", "PgPointTuple");
+	}
+	/** @internal */
+	build(table) {
+		return new PgPointTuple(table, this.config);
+	}
+};
+var PgPointTuple = class extends PgColumn {
+	static [entityKind] = "PgPointTuple";
+	mode = "tuple";
+	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$1) {
+		super(name$1, "object point", "PgPointObject");
+	}
+	/** @internal */
+	build(table) {
+		return new PgPointObject(table, this.config);
+	}
+};
+var PgPointObject = class extends PgColumn {
+	static [entityKind] = "PgPointObject";
+	mode = "xy";
+	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: name$1, config } = getColumnNameAndConfig(a, b);
+	if (!config?.mode || config.mode === "tuple") return new PgPointTupleBuilder(name$1);
+	return new PgPointObjectBuilder(name$1);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/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 buffer = /* @__PURE__ */ new ArrayBuffer(8);
+	const view = new DataView(buffer);
+	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;
+	let srid;
+	if (geomType & 536870912) {
+		srid = 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 {
+			srid,
+			point: [x, y]
+		};
+	}
+	throw new Error("Unsupported geometry type");
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/postgis_extension/geometry.js
+var PgGeometryBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgGeometryBuilder";
+	constructor(name$1, srid) {
+		super(name$1, "array geometry", "PgGeometry");
+		this.config.srid = srid;
+	}
+	/** @internal */
+	build(table) {
+		return new PgGeometry(table, this.config);
+	}
+};
+var PgGeometry = class extends PgColumn {
+	static [entityKind] = "PgGeometry";
+	srid = this.config.srid;
+	mode = "tuple";
+	getSQLType() {
+		return `geometry(point${this.srid === void 0 ? "" : `,${this.srid}`})`;
+	}
+	mapFromDriverValue(value) {
+		if (typeof value !== "string") return value;
+		return parseEWKB(value).point;
+	}
+	mapToDriverValue(value) {
+		return `point(${value[0]} ${value[1]})`;
+	}
+};
+var PgGeometryObjectBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgGeometryObjectBuilder";
+	constructor(name$1, srid) {
+		super(name$1, "object geometry", "PgGeometryObject");
+		this.config.srid = srid;
+	}
+	/** @internal */
+	build(table) {
+		return new PgGeometryObject(table, this.config);
+	}
+};
+var PgGeometryObject = class extends PgColumn {
+	static [entityKind] = "PgGeometryObject";
+	srid = this.config.srid;
+	mode = "object";
+	getSQLType() {
+		return `geometry(point${this.srid === void 0 ? "" : `,${this.srid}`})`;
+	}
+	mapFromDriverValue(value) {
+		const parsed = parseEWKB(value);
+		return {
+			x: parsed.point[0],
+			y: parsed.point[1]
+		};
+	}
+	mapToDriverValue(value) {
+		return `point(${value.x} ${value.y})`;
+	}
+};
+function geometry(a, b) {
+	const { name: name$1, config } = getColumnNameAndConfig(a, b);
+	if (!config?.mode || config.mode === "tuple") return new PgGeometryBuilder(name$1, config?.srid);
+	return new PgGeometryObjectBuilder(name$1, config?.srid);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/real.js
+var PgRealBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgRealBuilder";
+	constructor(name$1, length) {
+		super(name$1, "number float", "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$1) {
+	return new PgRealBuilder(name$1 ?? "");
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/serial.js
+var PgSerialBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgSerialBuilder";
+	constructor(name$1) {
+		super(name$1, "number int32", "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$1) {
+	return new PgSerialBuilder(name$1 ?? "");
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/smallint.js
+var PgSmallIntBuilder = class extends PgIntColumnBaseBuilder {
+	static [entityKind] = "PgSmallIntBuilder";
+	constructor(name$1) {
+		super(name$1, "number int16", "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$1) {
+	return new PgSmallIntBuilder(name$1 ?? "");
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/smallserial.js
+var PgSmallSerialBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgSmallSerialBuilder";
+	constructor(name$1) {
+		super(name$1, "number int16", "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$1) {
+	return new PgSmallSerialBuilder(name$1 ?? "");
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/text.js
+var PgTextBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgTextBuilder";
+	constructor(name$1, config) {
+		super(name$1, config.enum?.length ? "string enum" : "string", "PgText");
+		this.config.enumValues = config.enum;
+	}
+	/** @internal */
+	build(table) {
+		return new PgText(table, this.config, this.config.enumValues);
+	}
+};
+var PgText = class extends PgColumn {
+	static [entityKind] = "PgText";
+	enumValues;
+	constructor(table, config, enumValues) {
+		super(table, config);
+		this.enumValues = enumValues;
+	}
+	getSQLType() {
+		return "text";
+	}
+};
+function text(a, b = {}) {
+	const { name: name$1, config } = getColumnNameAndConfig(a, b);
+	return new PgTextBuilder(name$1, config);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/time.js
+var PgTimeBuilder = class extends PgDateColumnBaseBuilder {
+	constructor(name$1, withTimezone, precision) {
+		super(name$1, "string time", "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: name$1, config } = getColumnNameAndConfig(a, b);
+	return new PgTimeBuilder(name$1, config.withTimezone ?? false, config.precision);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/timestamp.js
+var PgTimestampBuilder = class extends PgDateColumnBaseBuilder {
+	static [entityKind] = "PgTimestampBuilder";
+	constructor(name$1, withTimezone, precision) {
+		super(name$1, "object 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) {
+		if (typeof value === "string") return value;
+		return value.toISOString();
+	}
+};
+var PgTimestampStringBuilder = class extends PgDateColumnBaseBuilder {
+	static [entityKind] = "PgTimestampStringBuilder";
+	constructor(name$1, withTimezone, precision) {
+		super(name$1, "string timestamp", "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;
+	}
+	mapToDriverValue(value) {
+		if (typeof value === "string") return value;
+		return value.toISOString();
+	}
+};
+function timestamp(a, b = {}) {
+	const { name: name$1, config } = getColumnNameAndConfig(a, b);
+	if (config?.mode === "string") return new PgTimestampStringBuilder(name$1, config.withTimezone ?? false, config.precision);
+	return new PgTimestampBuilder(name$1, config?.withTimezone ?? false, config?.precision);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/uuid.js
+var PgUUIDBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgUUIDBuilder";
+	constructor(name$1) {
+		super(name$1, "string uuid", "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$1) {
+	return new PgUUIDBuilder(name$1 ?? "");
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/varchar.js
+var PgVarcharBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgVarcharBuilder";
+	constructor(name$1, config) {
+		super(name$1, config.enum?.length ? "string enum" : "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";
+	enumValues = this.config.enumValues;
+	getSQLType() {
+		return this.length === void 0 ? `varchar` : `varchar(${this.length})`;
+	}
+};
+function varchar(a, b = {}) {
+	const { name: name$1, config } = getColumnNameAndConfig(a, b);
+	return new PgVarcharBuilder(name$1, config);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/vector_extension/bit.js
+var PgBinaryVectorBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgBinaryVectorBuilder";
+	constructor(name$1, config) {
+		super(name$1, "string binary", "PgBinaryVector");
+		this.config.length = config.dimensions;
+		this.config.isLengthExact = true;
+	}
+	/** @internal */
+	build(table) {
+		return new PgBinaryVector(table, this.config);
+	}
+};
+var PgBinaryVector = class extends PgColumn {
+	static [entityKind] = "PgBinaryVector";
+	getSQLType() {
+		return `bit(${this.length})`;
+	}
+};
+function bit(a, b) {
+	const { name: name$1, config } = getColumnNameAndConfig(a, b);
+	return new PgBinaryVectorBuilder(name$1, config);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/vector_extension/halfvec.js
+var PgHalfVectorBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgHalfVectorBuilder";
+	constructor(name$1, config) {
+		super(name$1, "array halfvector", "PgHalfVector");
+		this.config.length = config.dimensions;
+		this.config.isLengthExact = true;
+	}
+	/** @internal */
+	build(table) {
+		return new PgHalfVector(table, this.config);
+	}
+};
+var PgHalfVector = class extends PgColumn {
+	static [entityKind] = "PgHalfVector";
+	getSQLType() {
+		return `halfvec(${this.length})`;
+	}
+	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: name$1, config } = getColumnNameAndConfig(a, b);
+	return new PgHalfVectorBuilder(name$1, config);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/vector_extension/sparsevec.js
+var PgSparseVectorBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgSparseVectorBuilder";
+	constructor(name$1, config) {
+		super(name$1, "string sparsevec", "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: name$1, config } = getColumnNameAndConfig(a, b);
+	return new PgSparseVectorBuilder(name$1, config);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/pg-core/columns/vector_extension/vector.js
+var PgVectorBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgVectorBuilder";
+	constructor(name$1, config) {
+		super(name$1, "array vector", "PgVector");
+		this.config.length = config.dimensions;
+		this.config.isLengthExact = true;
+	}
+	/** @internal */
+	build(table) {
+		return new PgVector(table, this.config);
+	}
+};
+var PgVector = class extends PgColumn {
+	static [entityKind] = "PgVector";
+	getSQLType() {
+		return `vector(${this.length})`;
+	}
+	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: name$1, config } = getColumnNameAndConfig(a, b);
+	return new PgVectorBuilder(name$1, config);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/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/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/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$1, columns, extraConfig, schema, baseName = name$1) {
+	const rawTable = new PgTable(name$1, 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 pgTableInternal = (name$1, columns, extraConfig) => {
+	return pgTableWithSchema(name$1, columns, extraConfig, void 0);
+};
+const pgTableWithRLS = (name$1, columns, extraConfig) => {
+	const table = pgTableWithSchema(name$1, columns, extraConfig, void 0);
+	table[EnableRLS] = true;
+	return table;
+};
+const pgTable = Object.assign(pgTableInternal, { withRLS: pgTableWithRLS });
+function pgTableCreator(customizeTableName) {
+	const fn = (name$1, columns, extraConfig) => {
+		return pgTableWithSchema(customizeTableName(name$1), columns, extraConfig, void 0, name$1);
+	};
+	return Object.assign(fn, { withRLS: ((name$1, columns, extraConfig) => {
+		const table = pgTableWithSchema(customizeTableName(name$1), columns, extraConfig, void 0, name$1);
+		table[EnableRLS] = true;
+		return table;
+	}) });
+}
+
+//#endregion
+export { ExtraConfigColumns as $, orderSelectedFields as A, is as At, getViewName as B, getTableColumns as C, TableName as Ct, isConfig as D, getColumnTable as Dt, haveSameKeys as E, Column as Et, Placeholder as F, noopDecoder as G, isSQLWrapper as H, SQL as I, param as J, noopEncoder as K, StringChunk as L, FakePrimitiveParam as M, Name as N, mapResultRow as O, entityKind as Ot, Param as P, ExtraConfigBuilder as Q, View as R, getColumns as S, ForeignKeyBuilder as St, getViewSelectedFields as T, extractExtendedColumnType as Tt, isView as U, isDriverValueEncoder as V, name as W, sql as X, placeholder as Y, BaseName as Z, PgJson as _, PgArray as _t, pgTableWithSchema as a, getTableName as at, applyMixins as b, parsePgNestedArray as bt, PgTimestamp as c, ViewBaseConfig as ct, smallserial as d, WithSubquery as dt, IsAlias as et, smallint as f, isPgEnum as ft, PgJsonb as g, IndexedColumn as gt, numeric as h, pgEnumWithSchema as ht, pgTableCreator as i, TableSchema as it, textDecoder as j, OriginalColumn as jt, mapUpdateSet as k, hasOwnEntityKind as kt, PgTimestampString as l, tracer as lt, PgNumeric as m, pgEnumObjectWithSchema as mt, PgTable as n, Table as nt, sparsevec as o, getTableUniqueName as ot, serial as p, pgEnum as pt, noopMapper as q, pgTable as r, TableColumns as rt, PgUUID as s, isTable as st, EnableRLS as t, OriginalName as tt, PgTime as u, Subquery as ut, PgDate as v, PgColumn as vt, getTableLikeName as w, ColumnBuilder as wt, getColumnNameAndConfig as x, iife as xt, PgDateString as y, parsePgArray as yt, fillPlaceholders as z };