appos 0.3.5-0 → 0.3.6-0

package/dist/exports/cli/auth-schema-CNuOqPi-.mjs

@@ -0,0 +1,2813 @@
+//#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;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.bun/drizzle-orm@1.0.0-beta.2-f9236e3+94f63afaebaec8a7/node_modules/drizzle-orm/column-builder.js
+var ColumnBuilder = class {
+	static [entityKind] = "ColumnBuilder";
+	/** @internal */
+	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/.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, 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;
+	name;
+	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`;
+	}
+	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, 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, 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, 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, length) {
+		super(name, "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, enumInstance) {
+		super(name, "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, enumInstance) {
+		super(name, "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;
+	}
+};
+
+//#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, 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, schema, baseName) {
+		this[TableName] = this[OriginalName] = name;
+		this[TableSchema] = schema;
+		this[BaseName] = baseName;
+	}
+};
+
+//#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 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 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]);
+	}
+};
+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
+		};
+	}
+};
+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 getColumnNameAndConfig(a, b) {
+	return {
+		name: typeof a === "string" && a.length > 0 ? a : "",
+		config: typeof a === "object" ? a : b
+	};
+}
+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, ...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/.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) {
+		super(name, "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) {
+		super(name, "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) {
+		super(name, "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, config } = getColumnNameAndConfig(a, b);
+	if (config.mode === "number") return new PgBigInt53Builder(name);
+	if (config.mode === "string") return new PgBigIntStringBuilder(name);
+	return new PgBigInt64Builder(name);
+}
+
+//#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) {
+		super(name, "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) {
+		super(name, "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, config } = getColumnNameAndConfig(a, b);
+	if (config.mode === "number") return new PgBigSerial53Builder(name);
+	return new PgBigSerial64Builder(name);
+}
+
+//#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) {
+		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/.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, config) {
+		super(name, 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, config } = getColumnNameAndConfig(a, b);
+	return new PgCharBuilder(name, 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) {
+		super(name, "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) {
+	return new PgCidrBuilder(name ?? "");
+}
+
+//#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, 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;
+	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, config } = getColumnNameAndConfig(a, b);
+		return new PgCustomColumnBuilder(name, 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) {
+		super(name, "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) {
+		super(name, "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, config } = getColumnNameAndConfig(a, b);
+	if (config?.mode === "date") return new PgDateBuilder(name);
+	return new PgDateStringBuilder(name);
+}
+
+//#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) {
+		super(name, "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) {
+	return new PgDoublePrecisionBuilder(name ?? "");
+}
+
+//#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) {
+		super(name, "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) {
+	return new PgInetBuilder(name ?? "");
+}
+
+//#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) {
+		super(name, "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) {
+	return new PgIntegerBuilder(name ?? "");
+}
+
+//#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, intervalConfig) {
+		super(name, "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, config } = getColumnNameAndConfig(a, b);
+	return new PgIntervalBuilder(name, 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) {
+		super(name, "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) {
+	return new PgJsonBuilder(name ?? "");
+}
+
+//#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) {
+		super(name, "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) {
+	return new PgJsonbBuilder(name ?? "");
+}
+
+//#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) {
+		super(name, "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) {
+		super(name, "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, config } = getColumnNameAndConfig(a, b);
+	if (!config?.mode || config.mode === "tuple") return new PgLineBuilder(name);
+	return new PgLineABCBuilder(name);
+}
+
+//#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) {
+		super(name, "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) {
+	return new PgMacaddrBuilder(name ?? "");
+}
+
+//#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) {
+		super(name, "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) {
+	return new PgMacaddr8Builder(name ?? "");
+}
+
+//#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, precision, scale) {
+		super(name, "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, 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 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, 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/.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) {
+		super(name, "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) {
+		super(name, "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, config } = getColumnNameAndConfig(a, b);
+	if (!config?.mode || config.mode === "tuple") return new PgPointTupleBuilder(name);
+	return new PgPointObjectBuilder(name);
+}
+
+//#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, srid) {
+		super(name, "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, srid) {
+		super(name, "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, config } = getColumnNameAndConfig(a, b);
+	if (!config?.mode || config.mode === "tuple") return new PgGeometryBuilder(name, config?.srid);
+	return new PgGeometryObjectBuilder(name, 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, length) {
+		super(name, "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) {
+	return new PgRealBuilder(name ?? "");
+}
+
+//#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) {
+		super(name, "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) {
+	return new PgSerialBuilder(name ?? "");
+}
+
+//#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) {
+		super(name, "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) {
+	return new PgSmallIntBuilder(name ?? "");
+}
+
+//#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) {
+		super(name, "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) {
+	return new PgSmallSerialBuilder(name ?? "");
+}
+
+//#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, config) {
+		super(name, 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, config } = getColumnNameAndConfig(a, b);
+	return new PgTextBuilder(name, 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, withTimezone, precision) {
+		super(name, "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, config } = getColumnNameAndConfig(a, b);
+	return new PgTimeBuilder(name, 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, withTimezone, precision) {
+		super(name, "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, withTimezone, precision) {
+		super(name, "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, 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/.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) {
+		super(name, "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) {
+	return new PgUUIDBuilder(name ?? "");
+}
+
+//#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, config) {
+		super(name, 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, config } = getColumnNameAndConfig(a, b);
+	return new PgVarcharBuilder(name, 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, config) {
+		super(name, "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, config } = getColumnNameAndConfig(a, b);
+	return new PgBinaryVectorBuilder(name, 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, config) {
+		super(name, "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, config } = getColumnNameAndConfig(a, b);
+	return new PgHalfVectorBuilder(name, 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, config) {
+		super(name, "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, config } = getColumnNameAndConfig(a, b);
+	return new PgSparseVectorBuilder(name, 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, config) {
+		super(name, "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, config } = getColumnNameAndConfig(a, b);
+	return new PgVectorBuilder(name, 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, 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 pgTableInternal = (name, columns, extraConfig) => {
+	return pgTableWithSchema(name, columns, extraConfig, void 0);
+};
+const pgTableWithRLS = (name, columns, extraConfig) => {
+	const table = pgTableWithSchema(name, columns, extraConfig, void 0);
+	table[EnableRLS] = true;
+	return table;
+};
+const pgTable = Object.assign(pgTableInternal, { withRLS: pgTableWithRLS });
+
+//#endregion
+//#region src/api/auth-schema.ts
+/**
+* Defines the authentication schema for the application.
+*
+* @returns An object containing the schema and relations for the authentication tables.
+*/
+function defineAuthSchema() {
+	const accounts = pgTable("accounts", (t) => ({
+		id: t.text("id").primaryKey().default(sql`uuidv7()`),
+		accessToken: t.text("access_token"),
+		accessTokenExpiresAt: t.timestamp("access_token_expires_at", {
+			mode: "string",
+			withTimezone: true
+		}),
+		accountId: t.text("account_id").notNull(),
+		createdAt: t.timestamp("created_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull(),
+		idToken: t.text("id_token"),
+		providerId: t.text("provider_id").notNull(),
+		password: t.text("password"),
+		userId: t.text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+		refreshToken: t.text("refresh_token"),
+		refreshTokenExpiresAt: t.timestamp("refresh_token_expires_at", {
+			mode: "string",
+			withTimezone: true
+		}),
+		scope: t.text("scope"),
+		updatedAt: t.timestamp("updated_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull()
+	}), (t) => []);
+	const apiKeys = pgTable("api_keys", (t) => ({
+		id: t.text("id").primaryKey().default(sql`uuidv7()`),
+		name: t.text("name"),
+		enabled: t.boolean("enabled").default(true),
+		expiresAt: t.timestamp("expires_at", {
+			mode: "string",
+			withTimezone: true
+		}),
+		key: t.text("key").notNull(),
+		lastRefillAt: t.timestamp("last_refill_at", {
+			mode: "string",
+			withTimezone: true
+		}),
+		lastRequest: t.timestamp("last_request", {
+			mode: "string",
+			withTimezone: true
+		}),
+		lastUsedAt: t.timestamp("last_used_at", {
+			mode: "string",
+			withTimezone: true
+		}),
+		metadata: t.text("metadata"),
+		permissions: t.text("permissions"),
+		prefix: t.text("prefix"),
+		rateLimitEnabled: t.boolean("rate_limit_enabled").default(true),
+		rateLimitTimeWindow: t.integer("rate_limit_time_window").default(864e5),
+		rateLimitMax: t.integer("rate_limit_max").default(10),
+		refillInterval: t.integer("refill_interval"),
+		refillAmount: t.integer("refill_amount"),
+		requestCount: t.integer("request_count"),
+		remaining: t.integer("remaining"),
+		start: t.text("start"),
+		userId: t.text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+		createdAt: t.timestamp("created_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull(),
+		updatedAt: t.timestamp("updated_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull()
+	}), (t) => []);
+	const invitations = pgTable("invitations", (t) => ({
+		id: t.text("id").primaryKey().default(sql`uuidv7()`),
+		email: t.text("email").notNull(),
+		expiresAt: t.timestamp("expires_at", {
+			mode: "string",
+			withTimezone: true
+		}).notNull(),
+		inviterId: t.text("inviter_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+		organizationId: t.text("organization_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+		role: t.text("role"),
+		status: t.text("status").default("pending").notNull(),
+		teamId: t.text("team_id"),
+		createdAt: t.timestamp("created_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull(),
+		updatedAt: t.timestamp("updated_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull()
+	}), (t) => []);
+	const members = pgTable("members", (t) => ({
+		id: t.text("id").primaryKey().default(sql`uuidv7()`),
+		organizationId: t.text("organization_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+		role: t.text("role").default("member").notNull(),
+		userId: t.text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+		createdAt: t.timestamp("created_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull()
+	}), (t) => []);
+	const organizations = pgTable("organizations", (t) => ({
+		id: t.text("id").primaryKey().default(sql`uuidv7()`),
+		name: t.text("name").notNull(),
+		slug: t.text("slug").unique(),
+		logo: t.text("logo"),
+		createdAt: t.timestamp("created_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull(),
+		updatedAt: t.timestamp("updated_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull(),
+		metadata: t.text("metadata")
+	}), (t) => []);
+	const sessions = pgTable("sessions", (t) => ({
+		id: t.text("id").primaryKey().default(sql`uuidv7()`),
+		activeOrganizationId: t.text("active_organization_id").references(() => organizations.id, { onDelete: "set null" }),
+		activeTeamId: t.text("active_team_id"),
+		createdAt: t.timestamp("created_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull(),
+		expiresAt: t.timestamp("expires_at", {
+			mode: "string",
+			withTimezone: true
+		}).notNull(),
+		impersonatedBy: t.text("impersonated_by").references(() => users.id, { onDelete: "set null" }),
+		ipAddress: t.text("ip_address"),
+		token: t.text("token").notNull().unique(),
+		updatedAt: t.timestamp("updated_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull(),
+		userAgent: t.text("user_agent"),
+		userId: t.text("user_id").notNull().references(() => users.id, { onDelete: "cascade" })
+	}), (t) => []);
+	const ssoProviders = pgTable("sso_providers", (t) => ({
+		id: t.text("id").primaryKey().default(sql`uuidv7()`),
+		domain: t.text("domain").notNull(),
+		issuer: t.text("issuer").notNull(),
+		oidcConfig: t.text("oidc_config"),
+		organizationId: t.text("organization_id").references(() => organizations.id, { onDelete: "cascade" }),
+		providerId: t.text("provider_id").notNull().unique(),
+		samlConfig: t.text("saml_config"),
+		userId: t.text("user_id").references(() => users.id, { onDelete: "cascade" })
+	}), (t) => []);
+	const users = pgTable("users", (t) => ({
+		id: t.text("id").primaryKey().default(sql`uuidv7()`),
+		banExpires: t.timestamp("ban_expires", {
+			mode: "string",
+			withTimezone: true
+		}),
+		banReason: t.text("ban_reason"),
+		banned: t.boolean("banned").default(false),
+		createdAt: t.timestamp("created_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull(),
+		displayUsername: t.text("display_username"),
+		email: t.text("email").notNull().unique(),
+		emailVerified: t.boolean("email_verified").default(false).notNull(),
+		image: t.text("image"),
+		isAnonymous: t.boolean("is_anonymous"),
+		lastLoginMethod: t.text("last_login_method"),
+		name: t.text("name").notNull(),
+		phoneNumber: t.text("phone_number").unique(),
+		phoneNumberVerified: t.boolean("phone_number_verified"),
+		role: t.text("role"),
+		twoFactorEnabled: t.boolean("two_factor_enabled").default(false),
+		updatedAt: t.timestamp("updated_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull(),
+		username: t.text("username").unique()
+	}), (t) => []);
+	const teams = pgTable("teams", (t) => ({
+		id: t.text("id").primaryKey().default(sql`uuidv7()`),
+		name: t.text("name").notNull(),
+		organizationId: t.text("organization_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+		createdAt: t.timestamp("created_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull(),
+		updatedAt: t.timestamp("updated_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull()
+	}), (t) => []);
+	const teamMembers = pgTable("team_members", (t) => ({
+		id: t.text("id").primaryKey().default(sql`uuidv7()`),
+		teamId: t.text("team_id").notNull().references(() => teams.id, { onDelete: "cascade" }),
+		userId: t.text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+		createdAt: t.timestamp("created_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull()
+	}), (t) => []);
+	const twoFactors = pgTable("two_factors", (t) => ({
+		id: t.text("id").primaryKey().default(sql`uuidv7()`),
+		secret: t.text("secret").notNull(),
+		backupCodes: t.text("backup_codes").notNull(),
+		userId: t.text("user_id").notNull().references(() => users.id, { onDelete: "cascade" })
+	}), (t) => []);
+	const verifications = pgTable("verifications", (t) => ({
+		id: t.text("id").primaryKey().default(sql`uuidv7()`),
+		createdAt: t.timestamp("created_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull(),
+		expiresAt: t.timestamp("expires_at", {
+			mode: "string",
+			withTimezone: true
+		}).notNull(),
+		identifier: t.text("identifier").notNull(),
+		updatedAt: t.timestamp("updated_at", {
+			mode: "string",
+			withTimezone: true
+		}).default(sql`NOW()`).notNull(),
+		value: t.text("value").notNull()
+	}), (t) => []);
+	return {
+		tables: {
+			accounts,
+			apiKeys,
+			auditLogs: pgTable("audit_logs", (t) => ({
+				id: t.text("id").primaryKey().default(sql`uuidv7()`),
+				tableName: t.text("table_name"),
+				action: t.text("action").notNull(),
+				customAction: t.text("custom_action"),
+				oldData: t.jsonb("old_data"),
+				newData: t.jsonb("new_data"),
+				metadata: t.jsonb("metadata"),
+				organizationId: t.text("organization_id").references(() => organizations.id, { onDelete: "set null" }),
+				userId: t.text("user_id").references(() => users.id, { onDelete: "set null" }),
+				sessionId: t.text("session_id").references(() => sessions.id, { onDelete: "set null" }),
+				requestId: t.text("request_id"),
+				createdAt: t.timestamp("created_at", {
+					mode: "string",
+					withTimezone: true
+				}).default(sql`NOW()`).notNull()
+			}), (t) => []),
+			invitations,
+			members,
+			organizations,
+			sessions,
+			ssoProviders,
+			teams,
+			teamMembers,
+			twoFactors,
+			users,
+			verifications
+		},
+		relations: (r) => ({
+			users: {
+				sessions: r.many.sessions({
+					from: r.users.id,
+					to: r.sessions.userId
+				}),
+				accounts: r.many.accounts({
+					from: r.users.id,
+					to: r.accounts.userId
+				}),
+				apiKeys: r.many.apiKeys({
+					from: r.users.id,
+					to: r.apiKeys.userId
+				}),
+				memberships: r.many.members({
+					from: r.users.id,
+					to: r.members.userId
+				}),
+				invitations: r.many.invitations({
+					from: r.users.id,
+					to: r.invitations.inviterId
+				}),
+				ssoProvider: r.one.ssoProviders({
+					from: r.users.id,
+					to: r.ssoProviders.userId
+				}),
+				twoFactor: r.one.twoFactors({
+					from: r.users.id,
+					to: r.twoFactors.userId
+				})
+			},
+			sessions: { user: r.one.users({
+				from: r.sessions.userId,
+				to: r.users.id
+			}) },
+			accounts: { user: r.one.users({
+				from: r.accounts.userId,
+				to: r.users.id
+			}) },
+			apiKeys: { user: r.one.users({
+				from: r.apiKeys.userId,
+				to: r.users.id
+			}) },
+			organizations: {
+				members: r.many.members({
+					from: r.organizations.id,
+					to: r.members.organizationId
+				}),
+				invitations: r.many.invitations({
+					from: r.organizations.id,
+					to: r.invitations.organizationId
+				}),
+				teams: r.many.teams({
+					from: r.organizations.id,
+					to: r.teams.organizationId
+				})
+			},
+			members: {
+				organization: r.one.organizations({
+					from: r.members.organizationId,
+					to: r.organizations.id
+				}),
+				user: r.one.users({
+					from: r.members.userId,
+					to: r.users.id
+				})
+			},
+			invitations: {
+				organization: r.one.organizations({
+					from: r.invitations.organizationId,
+					to: r.organizations.id
+				}),
+				inviter: r.one.users({
+					from: r.invitations.inviterId,
+					to: r.users.id
+				})
+			},
+			teams: { organization: r.one.organizations({
+				from: r.teams.organizationId,
+				to: r.organizations.id
+			}) },
+			ssoProviders: { user: r.one.users({
+				from: r.ssoProviders.userId,
+				to: r.users.id
+			}) },
+			verifications: {},
+			twoFactors: { user: r.one.users({
+				from: r.twoFactors.userId,
+				to: r.users.id
+			}) },
+			auditLogs: {
+				organization: r.one.organizations({
+					from: r.auditLogs.organizationId,
+					to: r.organizations.id
+				}),
+				user: r.one.users({
+					from: r.auditLogs.userId,
+					to: r.users.id
+				}),
+				session: r.one.sessions({
+					from: r.auditLogs.sessionId,
+					to: r.sessions.id
+				})
+			}
+		})
+	};
+}
+
+//#endregion
+export { isDriverValueEncoder as a, Table as c, View as i, Column as l, Param as n, isSQLWrapper as o, Placeholder as r, sql as s, defineAuthSchema as t, is as u };