@h3ravel/arquebus 0.3.5 → 0.4.0

package/dist/inspector/index.cjs

@@ -0,0 +1,4885 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let radashi = require("radashi");
+radashi = __toESM(radashi);
+let dayjs_plugin_advancedFormat_js = require("dayjs/plugin/advancedFormat.js");
+dayjs_plugin_advancedFormat_js = __toESM(dayjs_plugin_advancedFormat_js);
+let dayjs = require("dayjs");
+dayjs = __toESM(dayjs);
+let collect_js = require("collect.js");
+collect_js = __toESM(collect_js);
+let knex = require("knex");
+knex = __toESM(knex);
+let path = require("path");
+path = __toESM(path);
+let fs = require("fs");
+fs = __toESM(fs);
+let pluralize = require("pluralize");
+pluralize = __toESM(pluralize);
+require("@h3ravel/shared");
+require("node:fs/promises");
+require("fs/promises");
+require("escalade/sync");
+require("resolve-from");
+
+//#region src/inspector/utils/strip-quotes.ts
+/**
+* Strip leading/trailing quotes from a string and handle null values.
+*/
+function stripQuotes(value) {
+	if (value === null || value === void 0) return null;
+	const trimmed = value.trim();
+	if (trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith("\"") && trimmed.endsWith("\"")) return trimmed.slice(1, -1);
+	return value;
+}
+
+//#endregion
+//#region src/inspector/dialects/cockroachdb.ts
+/**
+* Converts CockroachDB default value to JS
+* Eg `'example'::character varying` => `example`
+*/
+function parseDefaultValue$5(value) {
+	if (value === null) return null;
+	if (value.startsWith("nextval(")) return value;
+	value = value.split("::")[0];
+	return stripQuotes(value);
+}
+var CockroachDB = class {
+	knex;
+	schema;
+	explodedSchema;
+	constructor(knex$1) {
+		this.knex = knex$1;
+		const config = knex$1.client.config;
+		if (!config.searchPath) {
+			this.schema = "public";
+			this.explodedSchema = [this.schema];
+		} else if (typeof config.searchPath === "string") {
+			this.schema = config.searchPath;
+			this.explodedSchema = [config.searchPath];
+		} else {
+			this.schema = config.searchPath[0];
+			this.explodedSchema = config.searchPath;
+		}
+	}
+	/**
+	* Set the schema to be used in other methods
+	*/
+	withSchema(schema) {
+		this.schema = schema;
+		this.explodedSchema = [this.schema];
+		return this;
+	}
+	/**
+	* List all existing tables in the current schema/database
+	*/
+	async tables() {
+		return (await this.knex.select("tablename").from("pg_catalog.pg_tables").whereIn("schemaname", this.explodedSchema)).map(({ tablename }) => tablename);
+	}
+	async tableInfo(table) {
+		const query = this.knex.select("table_name", "table_schema", this.knex.select(this.knex.raw("obj_description(oid)")).from("pg_class").where({ relkind: "r" }).andWhere({ relname: "table_name" }).as("table_comment")).from("information_schema.tables").whereIn("table_schema", this.explodedSchema).andWhereRaw("\"table_catalog\" = current_database()").andWhere({ table_type: "BASE TABLE" }).orderBy("table_name", "asc");
+		if (table) {
+			const rawTable = await query.andWhere({ table_name: table }).limit(1).first();
+			return {
+				name: rawTable.table_name,
+				schema: rawTable.table_schema,
+				comment: rawTable.table_comment
+			};
+		}
+		return (await query).map((rawTable) => {
+			return {
+				name: rawTable.table_name,
+				schema: rawTable.table_schema,
+				comment: rawTable.table_comment
+			};
+		});
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasTable(table) {
+		const subquery = this.knex.select().from("information_schema.tables").whereIn("table_schema", this.explodedSchema).andWhere({ table_name: table });
+		const record = await this.knex.select(this.knex.raw("exists (?)", [subquery])).first();
+		return (record === null || record === void 0 ? void 0 : record.exists) || false;
+	}
+	/**
+	* Get all the available columns in the current schema/database. Can be filtered to a specific table
+	*/
+	async columns(table) {
+		const query = this.knex.select("table_name", "column_name").from("information_schema.columns").whereIn("table_schema", this.explodedSchema);
+		if (table) query.andWhere({ table_name: table });
+		return (await query).map(({ table_name, column_name }) => ({
+			table: table_name,
+			column: column_name
+		}));
+	}
+	async columnInfo(table, column) {
+		const { knex: knex$1 } = this;
+		const bindings = [];
+		if (table) bindings.push(table);
+		if (column) bindings.push(column);
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		const [columns, constraints] = await Promise.all([knex$1.raw(`
+         SELECT *, CASE WHEN res.is_generated THEN (
+          SELECT
+            generation_expression
+          FROM
+            information_schema.columns
+          WHERE
+            table_schema = res.schema 
+            AND table_name = res.table 
+            AND column_name = res.name
+          ) ELSE NULL END AS generation_expression
+         FROM (
+         SELECT
+           att.attname AS name,
+           rel.relname AS table,
+           rel.relnamespace::regnamespace::text AS schema,
+           format_type(att.atttypid, null) AS data_type,
+           NOT att.attnotnull AS is_nullable,
+           CASE WHEN att.attgenerated = '' THEN pg_get_expr(ad.adbin, ad.adrelid) ELSE null END AS default_value,
+           att.attgenerated = 's' AS is_generated,
+           CASE
+             WHEN att.atttypid IN (1042, 1043) THEN (att.atttypmod - 4)::int4
+             WHEN att.atttypid IN (1560, 1562) THEN (att.atttypmod)::int4
+             ELSE NULL
+           END AS max_length,
+           des.description AS comment,
+           CASE att.atttypid
+             WHEN 21 THEN 16
+             WHEN 23 THEN 32
+             WHEN 20 THEN 64
+             WHEN 1700 THEN
+               CASE WHEN atttypmod = -1 THEN NULL
+                 ELSE (((atttypmod - 4) >> 16) & 65535)::int4
+               END
+             WHEN 700 THEN 24
+             WHEN 701 THEN 53
+             ELSE NULL
+           END AS numeric_precision,
+           CASE
+             WHEN atttypid IN (21, 23, 20) THEN 0
+             WHEN atttypid = 1700 THEN
+               CASE
+                 WHEN atttypmod = -1 THEN NULL
+                 ELSE ((atttypmod - 4) & 65535)::int4
+               END
+             ELSE null
+           END AS numeric_scale
+         FROM
+           pg_attribute att
+           LEFT JOIN pg_class rel ON att.attrelid = rel.oid
+           LEFT JOIN pg_attrdef ad ON (att.attrelid, att.attnum) = (ad.adrelid, ad.adnum)
+           LEFT JOIN pg_description des ON (att.attrelid, att.attnum) = (des.objoid, des.objsubid)
+         WHERE
+           rel.relnamespace IN (${schemaIn})
+           ${table ? "AND rel.relname = ?" : ""}
+           ${column ? "AND att.attname = ?" : ""}
+           AND rel.relkind = 'r'
+           AND att.attnum > 0
+           AND NOT att.attisdropped
+         ORDER BY rel.relname, att.attnum) res;
+       `, bindings), knex$1.raw(`
+         SELECT
+           con.contype AS type,
+           rel.relname AS table,
+           att.attname AS column,
+           frel.relnamespace::regnamespace::text AS foreign_key_schema,
+           frel.relname AS foreign_key_table,
+           fatt.attname AS foreign_key_column
+         FROM
+           pg_constraint con
+         LEFT JOIN pg_class rel ON con.conrelid = rel.oid
+         LEFT JOIN pg_class frel ON con.confrelid = frel.oid
+         LEFT JOIN pg_attribute att ON att.attrelid = con.conrelid AND att.attnum = con.conkey[1]
+         LEFT JOIN pg_attribute fatt ON fatt.attrelid = con.confrelid AND fatt.attnum = con.confkey[1]
+         WHERE con.connamespace IN (${schemaIn})
+           AND array_length(con.conkey, 1) <= 1
+           AND (con.confkey IS NULL OR array_length(con.confkey, 1) = 1)
+           ${table ? "AND rel.relname = ?" : ""}
+           ${column ? "AND att.attname = ?" : ""}
+         `, bindings)]);
+		const parsedColumms = columns.rows.map((col) => {
+			var _col$default_value;
+			const constraintsForColumn = constraints.rows.filter((constraint) => constraint.table === col.table && constraint.column === col.name);
+			const foreignKeyConstraint = constraintsForColumn.find((constraint) => constraint.type === "f");
+			return {
+				...col,
+				is_unique: constraintsForColumn.some((constraint) => ["u", "p"].includes(constraint.type)),
+				is_primary_key: constraintsForColumn.some((constraint) => constraint.type === "p"),
+				has_auto_increment: ["integer", "bigint"].includes(col.data_type) && (((_col$default_value = col.default_value) === null || _col$default_value === void 0 ? void 0 : _col$default_value.startsWith("nextval(")) ?? false),
+				default_value: parseDefaultValue$5(col.default_value),
+				foreign_key_schema: (foreignKeyConstraint === null || foreignKeyConstraint === void 0 ? void 0 : foreignKeyConstraint.foreign_key_schema) ?? null,
+				foreign_key_table: (foreignKeyConstraint === null || foreignKeyConstraint === void 0 ? void 0 : foreignKeyConstraint.foreign_key_table) ?? null,
+				foreign_key_column: (foreignKeyConstraint === null || foreignKeyConstraint === void 0 ? void 0 : foreignKeyConstraint.foreign_key_column) ?? null
+			};
+		});
+		if (table && column) return parsedColumms[0];
+		return parsedColumms;
+	}
+	/**
+	* Check if the given table contains the given column
+	*/
+	async hasColumn(table, column) {
+		const subquery = this.knex.select().from("information_schema.columns").whereIn("table_schema", this.explodedSchema).andWhere({
+			table_name: table,
+			column_name: column
+		});
+		const record = await this.knex.select(this.knex.raw("exists (?)", [subquery])).first();
+		return (record === null || record === void 0 ? void 0 : record.exists) || false;
+	}
+	/**
+	* Get the primary key column for the given table
+	*/
+	async primary(table) {
+		const result = await this.knex.select("information_schema.key_column_usage.column_name").from("information_schema.key_column_usage").leftJoin("information_schema.table_constraints", function() {
+			this.on("information_schema.table_constraints.constraint_name", "=", "information_schema.key_column_usage.constraint_name").andOn("information_schema.table_constraints.table_name", "=", "information_schema.key_column_usage.table_name");
+		}).whereIn("information_schema.table_constraints.table_schema", this.explodedSchema).andWhere({
+			"information_schema.table_constraints.constraint_type": "PRIMARY KEY",
+			"information_schema.table_constraints.table_name": table
+		});
+		return result.length > 0 ? result.length === 1 ? result[0].column_name : result.map((r) => r.column_name) : null;
+	}
+	async foreignKeys(table) {
+		const rowsWithoutQuotes = (await this.knex.raw(`
+      SELECT
+        c.conrelid::regclass::text AS "table",
+        (
+          SELECT
+            STRING_AGG(a.attname, ','
+            ORDER BY
+              t.seq)
+          FROM (
+            SELECT
+              ROW_NUMBER() OVER (ROWS UNBOUNDED PRECEDING) AS seq,
+              attnum
+            FROM
+              UNNEST(c.conkey) AS t (attnum)) AS t
+          INNER JOIN pg_attribute AS a ON a.attrelid = c.conrelid
+            AND a.attnum = t.attnum) AS "column",
+        tt.name AS foreign_key_table,
+        (
+          SELECT
+            STRING_AGG(QUOTE_IDENT(a.attname), ','
+            ORDER BY
+              t.seq)
+          FROM (
+            SELECT
+              ROW_NUMBER() OVER (ROWS UNBOUNDED PRECEDING) AS seq,
+              attnum
+            FROM
+              UNNEST(c.confkey) AS t (attnum)) AS t
+        INNER JOIN pg_attribute AS a ON a.attrelid = c.confrelid
+          AND a.attnum = t.attnum) AS foreign_key_column,
+        tt.schema AS foreign_key_schema,
+        c.conname AS constraint_name,
+        CASE confupdtype
+        WHEN 'r' THEN
+          'RESTRICT'
+        WHEN 'c' THEN
+          'CASCADE'
+        WHEN 'n' THEN
+          'SET NULL'
+        WHEN 'd' THEN
+          'SET DEFAULT'
+        WHEN 'a' THEN
+          'NO ACTION'
+        ELSE
+          NULL
+        END AS on_update,
+        CASE confdeltype
+        WHEN 'r' THEN
+          'RESTRICT'
+        WHEN 'c' THEN
+          'CASCADE'
+        WHEN 'n' THEN
+          'SET NULL'
+        WHEN 'd' THEN
+          'SET DEFAULT'
+        WHEN 'a' THEN
+          'NO ACTION'
+        ELSE
+          NULL
+        END AS
+        on_delete
+      FROM
+        pg_catalog.pg_constraint AS c
+        INNER JOIN (
+          SELECT
+            pg_class.oid,
+            QUOTE_IDENT(pg_namespace.nspname) AS SCHEMA,
+            QUOTE_IDENT(pg_class.relname) AS name
+          FROM
+            pg_class
+            INNER JOIN pg_namespace ON pg_class.relnamespace = pg_namespace.oid) AS tf ON tf.oid = c.conrelid
+        INNER JOIN (
+          SELECT
+            pg_class.oid,
+            QUOTE_IDENT(pg_namespace.nspname) AS SCHEMA,
+            QUOTE_IDENT(pg_class.relname) AS name
+          FROM
+            pg_class
+            INNER JOIN pg_namespace ON pg_class.relnamespace = pg_namespace.oid) AS tt ON tt.oid = c.confrelid
+      WHERE
+        c.contype = 'f';
+    `)).rows.map(stripRowQuotes);
+		if (table) return rowsWithoutQuotes.filter((row) => row.table === table);
+		return rowsWithoutQuotes;
+		function stripRowQuotes(row) {
+			return Object.fromEntries(Object.entries(row).map(([key, value]) => {
+				return [key, stripQuotes(value)];
+			}));
+		}
+	}
+};
+
+//#endregion
+//#region src/inspector/dialects/mssql.ts
+function rawColumnToColumn$2(rawColumn) {
+	return {
+		...rawColumn,
+		default_value: parseDefaultValue$4(rawColumn.default_value),
+		generation_expression: rawColumn.generation_expression || null,
+		is_generated: !!rawColumn.is_generated,
+		is_unique: rawColumn.is_unique === true,
+		is_primary_key: rawColumn.is_primary_key === true,
+		is_nullable: rawColumn.is_nullable === "YES",
+		has_auto_increment: rawColumn.has_auto_increment === "YES",
+		numeric_precision: rawColumn.numeric_precision || null,
+		numeric_scale: rawColumn.numeric_scale || null,
+		max_length: parseMaxLength(rawColumn)
+	};
+	function parseMaxLength(rawColumn$1) {
+		const max_length = Number(rawColumn$1.max_length);
+		if (Number.isNaN(max_length) || rawColumn$1.max_length === null || rawColumn$1.max_length === void 0) return null;
+		if ([
+			"nvarchar",
+			"nchar",
+			"ntext"
+		].includes(rawColumn$1.data_type)) return max_length === -1 ? max_length : max_length / 2;
+		return max_length;
+	}
+}
+function parseDefaultValue$4(value) {
+	if (value === null) return null;
+	while (value.startsWith("(") && value.endsWith(")")) value = value.slice(1, -1);
+	if (value.trim().toLowerCase() === "null") return null;
+	return stripQuotes(value);
+}
+var MSSQL = class {
+	knex;
+	_schema;
+	constructor(knex$1) {
+		this.knex = knex$1;
+	}
+	/**
+	* Set the schema to be used in other methods
+	*/
+	withSchema(schema) {
+		this.schema = schema;
+		return this;
+	}
+	get schema() {
+		return this._schema || "dbo";
+	}
+	set schema(value) {
+		this._schema = value;
+	}
+	/**
+	* List all existing tables in the current schema/database
+	*/
+	async tables() {
+		return (await this.knex.select("TABLE_NAME").from("INFORMATION_SCHEMA.TABLES").where({
+			TABLE_TYPE: "BASE TABLE",
+			TABLE_CATALOG: this.knex.client.database(),
+			TABLE_SCHEMA: this.schema
+		})).map(({ TABLE_NAME }) => TABLE_NAME);
+	}
+	async tableInfo(table) {
+		const query = this.knex.select("TABLE_NAME", "TABLE_SCHEMA", "TABLE_CATALOG", "TABLE_TYPE").from("INFORMATION_SCHEMA.TABLES").where({
+			TABLE_CATALOG: this.knex.client.database(),
+			TABLE_TYPE: "BASE TABLE",
+			TABLE_SCHEMA: this.schema
+		});
+		if (table) {
+			const rawTable = await query.andWhere({ table_name: table }).first();
+			return {
+				name: rawTable.TABLE_NAME,
+				schema: rawTable.TABLE_SCHEMA,
+				catalog: rawTable.TABLE_CATALOG
+			};
+		}
+		return (await query).map((rawTable) => {
+			return {
+				name: rawTable.TABLE_NAME,
+				schema: rawTable.TABLE_SCHEMA,
+				catalog: rawTable.TABLE_CATALOG
+			};
+		});
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasTable(table) {
+		const result = await this.knex.count({ count: "*" }).from("INFORMATION_SCHEMA.TABLES").where({
+			TABLE_CATALOG: this.knex.client.database(),
+			table_name: table,
+			TABLE_SCHEMA: this.schema
+		}).first();
+		return result && result.count === 1 || false;
+	}
+	/**
+	* Get all the available columns in the current schema/database. Can be filtered to a specific table
+	*/
+	async columns(table) {
+		const query = this.knex.select("TABLE_NAME", "COLUMN_NAME").from("INFORMATION_SCHEMA.COLUMNS").where({
+			TABLE_CATALOG: this.knex.client.database(),
+			TABLE_SCHEMA: this.schema
+		});
+		if (table) query.andWhere({ TABLE_NAME: table });
+		return (await query).map(({ TABLE_NAME, COLUMN_NAME }) => ({
+			table: TABLE_NAME,
+			column: COLUMN_NAME
+		}));
+	}
+	async columnInfo(table, column) {
+		const dbName = this.knex.client.database();
+		const query = this.knex.select(this.knex.raw(`
+        [o].[name] AS [table],
+        [c].[name] AS [name],
+        [t].[name] AS [data_type],
+        [c].[max_length] AS [max_length],
+        [c].[precision] AS [numeric_precision],
+        [c].[scale] AS [numeric_scale],
+        CASE WHEN [c].[is_nullable] = 0 THEN
+          'NO'
+        ELSE
+          'YES'
+        END AS [is_nullable],
+        object_definition ([c].[default_object_id]) AS [default_value],
+        [i].[is_primary_key],
+        [i].[is_unique],
+        CASE [c].[is_identity]
+        WHEN 1 THEN
+          'YES'
+        ELSE
+          'NO'
+        END AS [has_auto_increment],
+        OBJECT_NAME ([fk].[referenced_object_id]) AS [foreign_key_table],
+        COL_NAME ([fk].[referenced_object_id],
+          [fk].[referenced_column_id]) AS [foreign_key_column],
+        [cc].[is_computed] as [is_generated],
+        [cc].[definition] as [generation_expression]`)).from(this.knex.raw("??.[sys].[columns] [c]", [dbName])).joinRaw("JOIN [sys].[types] [t] ON [c].[user_type_id] = [t].[user_type_id]").joinRaw("JOIN [sys].[tables] [o] ON [o].[object_id] = [c].[object_id]").joinRaw("JOIN [sys].[schemas] [s] ON [s].[schema_id] = [o].[schema_id]").joinRaw("LEFT JOIN [sys].[computed_columns] AS [cc] ON [cc].[object_id] = [c].[object_id] AND [cc].[column_id] = [c].[column_id]").joinRaw("LEFT JOIN [sys].[foreign_key_columns] AS [fk] ON [fk].[parent_object_id] = [c].[object_id] AND [fk].[parent_column_id] = [c].[column_id]").joinRaw(`LEFT JOIN (
+          SELECT
+            [ic].[object_id],
+            [ic].[column_id],
+            [ix].[is_unique],
+            [ix].[is_primary_key],
+            MAX([ic].[index_column_id]) OVER(partition by [ic].[index_id], [ic].[object_id]) AS index_column_count,
+            ROW_NUMBER() OVER (
+              PARTITION BY [ic].[object_id], [ic].[column_id]
+              ORDER BY [ix].[is_primary_key] DESC, [ix].[is_unique] DESC
+            ) AS index_priority
+          FROM
+            [sys].[index_columns] [ic]
+          JOIN [sys].[indexes] AS [ix] ON [ix].[object_id] = [ic].[object_id]
+            AND [ix].[index_id] = [ic].[index_id]
+        ) AS [i]
+        ON [i].[object_id] = [c].[object_id]
+        AND [i].[column_id] = [c].[column_id]
+        AND ISNULL([i].[index_column_count], 1) = 1
+        AND ISNULL([i].[index_priority], 1) = 1`).where({ "s.name": this.schema });
+		if (table) query.andWhere({ "o.name": table });
+		if (column) {
+			const rawColumn = await query.andWhere({ "c.name": column }).first();
+			return rawColumnToColumn$2(rawColumn);
+		}
+		return (await query).map(rawColumnToColumn$2);
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasColumn(table, column) {
+		const result = await this.knex.count({ count: "*" }).from("INFORMATION_SCHEMA.COLUMNS").where({
+			TABLE_CATALOG: this.knex.client.database(),
+			TABLE_NAME: table,
+			COLUMN_NAME: column,
+			TABLE_SCHEMA: this.schema
+		}).first();
+		return result && result.count === 1 || false;
+	}
+	/**
+	* Get the primary key column for the given table
+	*/
+	async primary(table) {
+		const results = await this.knex.raw(`SELECT
+         Col.Column_Name
+       FROM
+         INFORMATION_SCHEMA.TABLE_CONSTRAINTS Tab,
+         INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE Col
+       WHERE
+         Col.Constraint_Name = Tab.Constraint_Name
+         AND Col.Table_Name = Tab.Table_Name
+         AND Constraint_Type = 'PRIMARY KEY'
+         AND Col.Table_Name = ?
+         AND Tab.CONSTRAINT_SCHEMA = ?`, [table, this.schema]);
+		return results.length > 0 ? results.length === 1 ? results[0]["Column_Name"] : results.map((row) => row["Column_Name"]) : null;
+	}
+	async foreignKeys(table) {
+		const result = await this.knex.raw(`
+      SELECT
+        OBJECT_NAME (fc.parent_object_id) AS "table",
+          COL_NAME (fc.parent_object_id, fc.parent_column_id) AS "column",
+          OBJECT_SCHEMA_NAME (f.referenced_object_id) AS foreign_key_schema,
+          OBJECT_NAME (f.referenced_object_id) AS foreign_key_table,
+          COL_NAME (fc.referenced_object_id, fc.referenced_column_id) AS foreign_key_column,
+          f.name AS constraint_name,
+          REPLACE(f.update_referential_action_desc, '_', ' ') AS on_update,
+          REPLACE(f.delete_referential_action_desc, '_', ' ') AS on_delete
+      FROM
+        sys.foreign_keys AS f
+        INNER JOIN sys.foreign_key_columns AS fc ON f.OBJECT_ID = fc.constraint_object_id
+      WHERE
+        OBJECT_SCHEMA_NAME (f.parent_object_id) = ?;
+    `, [this.schema]);
+		if (table) return result === null || result === void 0 ? void 0 : result.filter((row) => row.table === table);
+		return result;
+	}
+};
+
+//#endregion
+//#region src/inspector/dialects/mysql.ts
+function rawColumnToColumn$1(rawColumn) {
+	var _rawColumn$EXTRA;
+	let dataType = rawColumn.COLUMN_TYPE.replace(/\(.*?\)/, "");
+	if (rawColumn.COLUMN_TYPE.startsWith("tinyint(1)")) dataType = "boolean";
+	return {
+		name: rawColumn.COLUMN_NAME,
+		table: rawColumn.TABLE_NAME,
+		collation: rawColumn.COLLATION_NAME,
+		data_type: dataType,
+		default_value: parseDefaultValue$3(rawColumn.COLUMN_DEFAULT),
+		generation_expression: rawColumn.GENERATION_EXPRESSION || null,
+		max_length: rawColumn.CHARACTER_MAXIMUM_LENGTH,
+		numeric_precision: rawColumn.NUMERIC_PRECISION,
+		numeric_scale: rawColumn.NUMERIC_SCALE,
+		is_generated: !!((_rawColumn$EXTRA = rawColumn.EXTRA) === null || _rawColumn$EXTRA === void 0 ? void 0 : _rawColumn$EXTRA.endsWith("GENERATED")),
+		is_nullable: rawColumn.IS_NULLABLE === "YES",
+		is_unique: rawColumn.COLUMN_KEY === "UNI",
+		is_primary_key: rawColumn.CONSTRAINT_NAME === "PRIMARY" || rawColumn.COLUMN_KEY === "PRI",
+		has_auto_increment: rawColumn.EXTRA === "auto_increment",
+		foreign_key_column: rawColumn.REFERENCED_COLUMN_NAME,
+		foreign_key_table: rawColumn.REFERENCED_TABLE_NAME,
+		comment: rawColumn.COLUMN_COMMENT
+	};
+}
+function parseDefaultValue$3(value) {
+	if (value === null || value.trim().toLowerCase() === "null") return null;
+	return stripQuotes(value);
+}
+var MySQL = class {
+	knex;
+	constructor(knex$1) {
+		this.knex = knex$1;
+	}
+	/**
+	* List all existing tables in the current schema/database
+	*/
+	async tables() {
+		return (await this.knex.select("TABLE_NAME").from("INFORMATION_SCHEMA.TABLES").where({
+			TABLE_TYPE: "BASE TABLE",
+			TABLE_SCHEMA: this.knex.client.database()
+		})).map(({ TABLE_NAME }) => TABLE_NAME);
+	}
+	async tableInfo(table) {
+		const query = this.knex.select("TABLE_NAME", "ENGINE", "TABLE_SCHEMA", "TABLE_COLLATION", "TABLE_COMMENT").from("information_schema.tables").where({
+			table_schema: this.knex.client.database(),
+			table_type: "BASE TABLE"
+		});
+		if (table) {
+			const rawTable = await query.andWhere({ table_name: table }).first();
+			return {
+				name: rawTable.TABLE_NAME,
+				schema: rawTable.TABLE_SCHEMA,
+				comment: rawTable.TABLE_COMMENT,
+				collation: rawTable.TABLE_COLLATION,
+				engine: rawTable.ENGINE
+			};
+		}
+		return (await query).map((rawTable) => {
+			return {
+				name: rawTable.TABLE_NAME,
+				schema: rawTable.TABLE_SCHEMA,
+				comment: rawTable.TABLE_COMMENT,
+				collation: rawTable.TABLE_COLLATION,
+				engine: rawTable.ENGINE
+			};
+		});
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasTable(table) {
+		const result = await this.knex.count({ count: "*" }).from("information_schema.tables").where({
+			table_schema: this.knex.client.database(),
+			table_name: table
+		}).first();
+		return result && result.count === 1 || false;
+	}
+	/**
+	* Get all the available columns in the current schema/database. Can be filtered to a specific table
+	*/
+	async columns(table) {
+		const query = this.knex.select("TABLE_NAME", "COLUMN_NAME").from("INFORMATION_SCHEMA.COLUMNS").where({ TABLE_SCHEMA: this.knex.client.database() });
+		if (table) query.andWhere({ TABLE_NAME: table });
+		return (await query).map(({ TABLE_NAME, COLUMN_NAME }) => ({
+			table: TABLE_NAME,
+			column: COLUMN_NAME
+		}));
+	}
+	async columnInfo(table, column) {
+		const query = this.knex.select("c.TABLE_NAME", "c.COLUMN_NAME", "c.COLUMN_DEFAULT", "c.COLUMN_TYPE", "c.CHARACTER_MAXIMUM_LENGTH", "c.IS_NULLABLE", "c.COLUMN_KEY", "c.EXTRA", "c.COLLATION_NAME", "c.COLUMN_COMMENT", "c.NUMERIC_PRECISION", "c.NUMERIC_SCALE", "c.GENERATION_EXPRESSION", "fk.REFERENCED_TABLE_NAME", "fk.REFERENCED_COLUMN_NAME", "fk.CONSTRAINT_NAME", "rc.UPDATE_RULE", "rc.DELETE_RULE", "rc.MATCH_OPTION").from("INFORMATION_SCHEMA.COLUMNS as c").leftJoin("INFORMATION_SCHEMA.KEY_COLUMN_USAGE as fk", function() {
+			this.on("c.TABLE_NAME", "=", "fk.TABLE_NAME").andOn("fk.COLUMN_NAME", "=", "c.COLUMN_NAME").andOn("fk.CONSTRAINT_SCHEMA", "=", "c.TABLE_SCHEMA");
+		}).leftJoin("INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS as rc", function() {
+			this.on("rc.TABLE_NAME", "=", "fk.TABLE_NAME").andOn("rc.CONSTRAINT_NAME", "=", "fk.CONSTRAINT_NAME").andOn("rc.CONSTRAINT_SCHEMA", "=", "fk.CONSTRAINT_SCHEMA");
+		}).where({ "c.TABLE_SCHEMA": this.knex.client.database() });
+		if (table) query.andWhere({ "c.TABLE_NAME": table });
+		if (column) {
+			const rawColumn = await query.andWhere({ "c.column_name": column }).first();
+			return rawColumnToColumn$1(rawColumn);
+		}
+		return (await query).map(rawColumnToColumn$1).sort((column$1) => +!column$1.foreign_key_column).filter((column$1, index, records) => {
+			return records.findIndex((_column) => {
+				return column$1.name === _column.name && column$1.table === _column.table;
+			}) === index;
+		});
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasColumn(table, column) {
+		const result = await this.knex.count("*", { as: "count" }).from("information_schema.columns").where({
+			table_schema: this.knex.client.database(),
+			table_name: table,
+			column_name: column
+		}).first();
+		return !!(result && result.count);
+	}
+	/**
+	* Get the primary key column for the given table
+	*/
+	async primary(table) {
+		const results = await this.knex.raw("SHOW KEYS FROM ?? WHERE Key_name = 'PRIMARY'", table);
+		if (results && results.length && results[0].length) {
+			if (results[0].length === 1) return results[0][0]["Column_name"];
+			return results[0].map((row) => row["Column_name"]);
+		}
+		return null;
+	}
+	async foreignKeys(table) {
+		const query = this.knex.select("rc.TABLE_NAME AS table", "kcu.COLUMN_NAME AS column", "rc.REFERENCED_TABLE_NAME AS foreign_key_table", "kcu.REFERENCED_COLUMN_NAME AS foreign_key_column", "rc.CONSTRAINT_NAME AS constraint_name", "rc.UPDATE_RULE AS on_update", "rc.DELETE_RULE AS on_delete").from("information_schema.referential_constraints AS rc").leftJoin("information_schema.key_column_usage AS kcu ", function() {
+			this.on("rc.CONSTRAINT_NAME", "=", "kcu.CONSTRAINT_NAME").andOn("kcu.CONSTRAINT_SCHEMA", "=", "rc.CONSTRAINT_SCHEMA");
+		}).where({ "rc.CONSTRAINT_SCHEMA": this.knex.client.database() });
+		if (table) query.andWhere({ "rc.TABLE_NAME": table });
+		return await query;
+	}
+	async uniqueConstraints(table) {
+		const { knex: knex$1 } = this;
+		const query = knex$1.select("stat.table_name AS table_name", "stat.index_name AS constraint_name", knex$1.raw("group_concat(stat.column_name ORDER BY stat.seq_in_index separator ', ') AS columns")).from("information_schema.statistics stat").join("information_schema.table_constraints tco", function() {
+			this.on("stat.table_schema", "=", "tco.table_schema").andOn("stat.table_name", "=", "tco.table_name").andOn("stat.index_name", "=", "tco.constraint_name");
+		}).where("stat.non_unique", "=", 0).andWhere("tco.constraint_type", "=", "UNIQUE").andWhere("stat.table_schema", knex$1.client.database()).groupBy([
+			"stat.table_name",
+			"stat.index_name",
+			"tco.constraint_type"
+		]);
+		if (table) query.andWhere("stat.table_name", "=", table);
+		return (await query).map((v) => ({
+			table: v.table_name,
+			constraint_name: v.constraint_name,
+			columns: v.columns
+		}));
+	}
+};
+
+//#endregion
+//#region src/inspector/dialects/oracledb.ts
+/**
+* NOTE: Use previous optimizer for better data dictionary performance.
+*/
+const OPTIMIZER_FEATURES = "11.2.0.4";
+function rawColumnToColumn(rawColumn) {
+	const is_generated = rawColumn.VIRTUAL_COLUMN === "YES";
+	const default_value = parseDefaultValue$2(rawColumn.DATA_DEFAULT);
+	return {
+		name: rawColumn.COLUMN_NAME,
+		table: rawColumn.TABLE_NAME,
+		data_type: rawColumn.DATA_TYPE,
+		default_value: !is_generated ? default_value : null,
+		generation_expression: is_generated ? default_value : null,
+		max_length: rawColumn.DATA_LENGTH,
+		numeric_precision: rawColumn.DATA_PRECISION,
+		numeric_scale: rawColumn.DATA_SCALE,
+		is_generated: rawColumn.VIRTUAL_COLUMN === "YES",
+		is_nullable: rawColumn.NULLABLE === "Y",
+		is_unique: rawColumn.CONSTRAINT_TYPE === "U",
+		is_primary_key: rawColumn.CONSTRAINT_TYPE === "P",
+		has_auto_increment: rawColumn.IDENTITY_COLUMN === "YES",
+		foreign_key_column: rawColumn.REFERENCED_COLUMN_NAME,
+		foreign_key_table: rawColumn.REFERENCED_TABLE_NAME,
+		comment: rawColumn.COLUMN_COMMENT
+	};
+}
+function parseDefaultValue$2(value) {
+	if (value === null || value.trim().toLowerCase() === "null") return null;
+	if (value === "CURRENT_TIMESTAMP ") return "CURRENT_TIMESTAMP";
+	return stripQuotes(value);
+}
+var oracleDB = class {
+	knex;
+	constructor(knex$1) {
+		this.knex = knex$1;
+	}
+	/**
+	* List all existing tables in the current schema/database
+	*/
+	async tables() {
+		return (await this.knex.select(this.knex.raw(`
+          /*+ OPTIMIZER_FEATURES_ENABLE('${OPTIMIZER_FEATURES}') */
+            "TABLE_NAME" "name"
+        `)).from("USER_TABLES")).map(({ name }) => name);
+	}
+	async tableInfo(table) {
+		const query = this.knex.select(this.knex.raw(`
+          /*+ OPTIMIZER_FEATURES_ENABLE('${OPTIMIZER_FEATURES}') */
+            "TABLE_NAME" "name"
+        `)).from("USER_TABLES");
+		if (table) return await query.andWhere({ TABLE_NAME: table }).first();
+		return await query;
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasTable(table) {
+		const result = await this.knex.select(this.knex.raw(`
+          /*+ OPTIMIZER_FEATURES_ENABLE('${OPTIMIZER_FEATURES}') */
+            COUNT(*) "count"
+        `)).from("USER_TABLES").where({ TABLE_NAME: table }).first();
+		return !!(result === null || result === void 0 ? void 0 : result.count);
+	}
+	/**
+	* Get all the available columns in the current schema/database. Can be filtered to a specific table
+	*/
+	async columns(table) {
+		const query = this.knex.select(this.knex.raw(`
+          /*+ OPTIMIZER_FEATURES_ENABLE('${OPTIMIZER_FEATURES}') NO_QUERY_TRANSFORMATION */
+            "TABLE_NAME" "table",
+            "COLUMN_NAME" "column"
+        `)).from("USER_TAB_COLS").where({ HIDDEN_COLUMN: "NO" });
+		if (table) query.andWhere({ TABLE_NAME: table });
+		return await query;
+	}
+	async columnInfo(table, column) {
+		/**
+		* NOTE: Keep in mind, this query is optimized for speed.
+		*/
+		const query = this.knex.with("uc", this.knex.raw(`
+          SELECT /*+ MATERIALIZE */
+            "uc"."TABLE_NAME",
+            "ucc"."COLUMN_NAME",
+            "uc"."CONSTRAINT_NAME",
+            "uc"."CONSTRAINT_TYPE",
+            "uc"."R_CONSTRAINT_NAME",
+            COUNT(*) OVER(
+              PARTITION BY
+                "uc"."CONSTRAINT_NAME"
+            ) "CONSTRAINT_COUNT", 
+            ROW_NUMBER() OVER(
+              PARTITION BY
+                "uc"."TABLE_NAME", 
+                "ucc"."COLUMN_NAME" 
+              ORDER BY 
+                "uc"."CONSTRAINT_TYPE"
+            ) "CONSTRAINT_PRIORITY"
+          FROM "USER_CONSTRAINTS" "uc"
+          INNER JOIN "USER_CONS_COLUMNS" "ucc"
+            ON "uc"."CONSTRAINT_NAME" = "ucc"."CONSTRAINT_NAME"
+          WHERE "uc"."CONSTRAINT_TYPE" IN ('P', 'U', 'R')
+      `)).select(this.knex.raw(`
+          /*+ OPTIMIZER_FEATURES_ENABLE('${OPTIMIZER_FEATURES}') */
+            "c"."TABLE_NAME", 
+            "c"."COLUMN_NAME", 
+            "c"."DATA_DEFAULT", 
+            "c"."DATA_TYPE", 
+            "c"."DATA_LENGTH", 
+            "c"."DATA_PRECISION", 
+            "c"."DATA_SCALE", 
+            "c"."NULLABLE", 
+            "c"."IDENTITY_COLUMN", 
+            "c"."VIRTUAL_COLUMN", 
+            "cm"."COMMENTS" "COLUMN_COMMENT", 
+            "ct"."CONSTRAINT_TYPE",
+            "fk"."TABLE_NAME" "REFERENCED_TABLE_NAME",
+            "fk"."COLUMN_NAME" "REFERENCED_COLUMN_NAME"
+          FROM "USER_TAB_COLS" "c" 
+          LEFT JOIN "USER_COL_COMMENTS" "cm"
+            ON "c"."TABLE_NAME" = "cm"."TABLE_NAME" 
+            AND "c"."COLUMN_NAME" = "cm"."COLUMN_NAME" 
+          LEFT JOIN "uc" "ct"
+            ON "c"."TABLE_NAME" = "ct"."TABLE_NAME" 
+            AND "c"."COLUMN_NAME" = "ct"."COLUMN_NAME"
+            AND "ct"."CONSTRAINT_COUNT" = 1 
+            AND "ct"."CONSTRAINT_PRIORITY" = 1
+          LEFT JOIN "uc" "fk"
+            ON "ct"."R_CONSTRAINT_NAME" = "fk"."CONSTRAINT_NAME"
+        `)).where({ "c.HIDDEN_COLUMN": "NO" });
+		if (table) query.andWhere({ "c.TABLE_NAME": table });
+		if (column) {
+			const rawColumn = await query.andWhere({ "c.COLUMN_NAME": column }).first();
+			return rawColumnToColumn(rawColumn);
+		}
+		return (await query).map(rawColumnToColumn);
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasColumn(table, column) {
+		const result = await this.knex.select(this.knex.raw(`
+          /*+ OPTIMIZER_FEATURES_ENABLE('${OPTIMIZER_FEATURES}') NO_QUERY_TRANSFORMATION */
+            COUNT(*) "count"
+        `)).from("USER_TAB_COLS").where({
+			TABLE_NAME: table,
+			COLUMN_NAME: column,
+			HIDDEN_COLUMN: "NO"
+		}).first();
+		return !!(result === null || result === void 0 ? void 0 : result.count);
+	}
+	/**
+	* Get the primary key column for the given table
+	*/
+	async primary(table) {
+		/**
+		* NOTE: Keep in mind, this query is optimized for speed.
+		*/
+		const result = await this.knex.with("uc", this.knex.select(this.knex.raw("/*+ MATERIALIZE */ \"CONSTRAINT_NAME\"")).from("USER_CONSTRAINTS").where({
+			TABLE_NAME: table,
+			CONSTRAINT_TYPE: "P"
+		})).select(this.knex.raw(`
+          /*+ OPTIMIZER_FEATURES_ENABLE('${OPTIMIZER_FEATURES}') */
+            "ucc"."COLUMN_NAME"
+          FROM "USER_CONS_COLUMNS" "ucc"
+          INNER JOIN "uc" "pk"
+            ON "ucc"."CONSTRAINT_NAME" = "pk"."CONSTRAINT_NAME"
+        `));
+		return result.length > 0 ? result.length === 1 ? result[0].COLUMN_NAME : result.map((r) => r.COLUMN_NAME) : null;
+	}
+	async foreignKeys(table) {
+		/**
+		* NOTE: Keep in mind, this query is optimized for speed.
+		*/
+		const query = this.knex.with("ucc", this.knex.raw(`
+          SELECT /*+ MATERIALIZE */
+            "TABLE_NAME",
+            "COLUMN_NAME",
+            "CONSTRAINT_NAME"
+          FROM "USER_CONS_COLUMNS"
+        `)).select(this.knex.raw(`
+          /*+ OPTIMIZER_FEATURES_ENABLE('${OPTIMIZER_FEATURES}') */
+            "uc"."TABLE_NAME" "table", 
+            "fcc"."COLUMN_NAME" "column", 
+            "rcc"."TABLE_NAME" AS "foreign_key_table",
+            "rcc"."COLUMN_NAME" AS "foreign_key_column",
+            "uc"."CONSTRAINT_NAME" "constraint_name", 
+            NULL as "on_update", 
+            "uc"."DELETE_RULE" "on_delete" 
+          FROM "USER_CONSTRAINTS" "uc" 
+          INNER JOIN "ucc" "fcc"
+            ON "uc"."CONSTRAINT_NAME" = "fcc"."CONSTRAINT_NAME"
+          INNER JOIN "ucc" "rcc"
+            ON "uc"."R_CONSTRAINT_NAME" = "rcc"."CONSTRAINT_NAME"
+      `)).where({ "uc.CONSTRAINT_TYPE": "R" });
+		if (table) query.andWhere({ "uc.TABLE_NAME": table });
+		return await query;
+	}
+};
+
+//#endregion
+//#region src/inspector/dialects/postgres.ts
+/**
+* Converts Postgres default value to JS
+* Eg `'example'::character varying` => `example`
+*/
+function parseDefaultValue$1(value) {
+	if (value === null) return null;
+	if (value.startsWith("nextval(")) return value;
+	value = value.split("::")[0];
+	if (value.trim().toLowerCase() === "null") return null;
+	return stripQuotes(value);
+}
+var Postgres = class {
+	knex;
+	schema;
+	explodedSchema;
+	constructor(knex$1) {
+		this.knex = knex$1;
+		const config = knex$1.client.config;
+		if (!config.searchPath) {
+			this.schema = "public";
+			this.explodedSchema = [this.schema];
+		} else if (typeof config.searchPath === "string") {
+			this.schema = config.searchPath;
+			this.explodedSchema = [config.searchPath];
+		} else {
+			this.schema = config.searchPath[0];
+			this.explodedSchema = config.searchPath;
+		}
+	}
+	/**
+	* Set the schema to be used in other methods
+	*/
+	withSchema(schema) {
+		this.schema = schema;
+		this.explodedSchema = [this.schema];
+		return this;
+	}
+	/**
+	* List all existing tables in the current schema/database
+	*/
+	async tables() {
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		return (await this.knex.raw(`
+      SELECT
+        rel.relname AS name
+      FROM
+        pg_class rel
+      WHERE
+        rel.relnamespace IN (${schemaIn})
+        AND rel.relkind = 'r'
+      ORDER BY rel.relname
+    `)).rows.map((row) => row.name);
+	}
+	async tableInfo(table) {
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		const bindings = [];
+		if (table) bindings.push(table);
+		const result = await this.knex.raw(`
+      SELECT
+        rel.relnamespace::regnamespace::text AS schema,
+        rel.relname AS name,
+        des.description AS comment
+      FROM
+        pg_class rel
+      LEFT JOIN pg_description des ON rel.oid = des.objoid AND des.objsubid = 0
+      WHERE
+        rel.relnamespace IN (${schemaIn})
+        ${table ? "AND rel.relname = ?" : ""}
+        AND rel.relkind = 'r'
+      ORDER BY rel.relname
+    `, bindings);
+		if (table) return result.rows[0];
+		return result.rows;
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasTable(table) {
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		return (await this.knex.raw(`
+      SELECT
+        rel.relname AS name
+      FROM
+        pg_class rel
+      WHERE
+        rel.relnamespace IN (${schemaIn})
+        AND rel.relkind = 'r'
+        AND rel.relname = ?
+      ORDER BY rel.relname
+    `, [table])).rows.length > 0;
+	}
+	/**
+	* Get all the available columns in the current schema/database. Can be filtered to a specific table
+	*/
+	async columns(table) {
+		const bindings = [];
+		if (table) bindings.push(table);
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		return (await this.knex.raw(`
+      SELECT
+        att.attname AS column,
+        rel.relname AS table
+      FROM
+        pg_attribute att
+        LEFT JOIN pg_class rel ON att.attrelid = rel.oid
+      WHERE
+        rel.relnamespace IN (${schemaIn})
+        ${table ? "AND rel.relname = ?" : ""}
+        AND rel.relkind = 'r'
+        AND att.attnum > 0
+        AND NOT att.attisdropped;
+    `, bindings)).rows;
+	}
+	async columnInfo(table, column) {
+		var _versionResponse$rows;
+		const { knex: knex$1 } = this;
+		const bindings = [];
+		if (table) bindings.push(table);
+		if (column) bindings.push(column);
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		const majorVersion = ((_versionResponse$rows = (await this.knex.raw("SHOW server_version")).rows) === null || _versionResponse$rows === void 0 || (_versionResponse$rows = _versionResponse$rows[0]) === null || _versionResponse$rows === void 0 || (_versionResponse$rows = _versionResponse$rows.server_version) === null || _versionResponse$rows === void 0 || (_versionResponse$rows = _versionResponse$rows.split(".")) === null || _versionResponse$rows === void 0 ? void 0 : _versionResponse$rows[0]) ?? 10;
+		let generationSelect = `
+      NULL AS generation_expression,
+      pg_get_expr(ad.adbin, ad.adrelid) AS default_value,
+      FALSE AS is_generated,
+    `;
+		if (Number(majorVersion) >= 12) generationSelect = `
+        CASE WHEN att.attgenerated = 's' THEN pg_get_expr(ad.adbin, ad.adrelid) ELSE null END AS generation_expression,
+        CASE WHEN att.attgenerated = '' THEN pg_get_expr(ad.adbin, ad.adrelid) ELSE null END AS default_value,
+        att.attgenerated = 's' AS is_generated,
+      `;
+		const [columns, constraints] = await Promise.all([knex$1.raw(`
+        SELECT
+        	att.attname AS name,
+          rel.relname AS table,
+          rel.relnamespace::regnamespace::text as schema,
+          att.atttypid::regtype::text AS data_type,
+          NOT att.attnotnull AS is_nullable,
+          ${generationSelect}
+          CASE
+            WHEN att.atttypid IN (1042, 1043) THEN (att.atttypmod - 4)::int4
+            WHEN att.atttypid IN (1560, 1562) THEN (att.atttypmod)::int4
+            ELSE NULL
+          END AS max_length,
+          des.description AS comment,
+          CASE att.atttypid
+            WHEN 21 THEN 16
+            WHEN 23 THEN 32
+            WHEN 20 THEN 64
+            WHEN 1700 THEN
+              CASE WHEN atttypmod = -1 THEN NULL
+                ELSE (((atttypmod - 4) >> 16) & 65535)::int4
+              END
+            WHEN 700 THEN 24
+            WHEN 701 THEN 53
+            ELSE NULL
+          END AS numeric_precision,
+          CASE
+            WHEN atttypid IN (21, 23, 20) THEN 0
+            WHEN atttypid = 1700 THEN
+              CASE
+                WHEN atttypmod = -1 THEN NULL
+                ELSE ((atttypmod - 4) & 65535)::int4
+              END
+            ELSE null
+          END AS numeric_scale
+        FROM
+          pg_attribute att
+          LEFT JOIN pg_class rel ON att.attrelid = rel.oid
+          LEFT JOIN pg_attrdef ad ON (att.attrelid, att.attnum) = (ad.adrelid, ad.adnum)
+          LEFT JOIN pg_description des ON (att.attrelid, att.attnum) = (des.objoid, des.objsubid)
+        WHERE
+          rel.relnamespace IN (${schemaIn})
+          ${table ? "AND rel.relname = ?" : ""}
+          ${column ? "AND att.attname = ?" : ""}
+          AND rel.relkind = 'r'
+          AND att.attnum > 0
+          AND NOT att.attisdropped
+        ORDER BY rel.relname, att.attnum;
+      `, bindings), knex$1.raw(`
+        SELECT
+          con.contype AS type,
+          rel.relname AS table,
+          att.attname AS column,
+          frel.relnamespace::regnamespace::text AS foreign_key_schema,
+          frel.relname AS foreign_key_table,
+          fatt.attname AS foreign_key_column,
+          CASE
+            WHEN con.contype = 'p' THEN pg_get_serial_sequence(att.attrelid::regclass::text, att.attname) != ''
+            ELSE NULL
+          END AS has_auto_increment
+        FROM
+          pg_constraint con
+        LEFT JOIN pg_class rel ON con.conrelid = rel.oid
+        LEFT JOIN pg_class frel ON con.confrelid = frel.oid
+        LEFT JOIN pg_attribute att ON att.attrelid = con.conrelid AND att.attnum = con.conkey[1]
+        LEFT JOIN pg_attribute fatt ON fatt.attrelid = con.confrelid AND fatt.attnum = con.confkey[1]
+        WHERE con.connamespace IN (${schemaIn})
+          AND array_length(con.conkey, 1) <= 1
+          AND (con.confkey IS NULL OR array_length(con.confkey, 1) = 1)
+          ${table ? "AND rel.relname = ?" : ""}
+          ${column ? "AND att.attname = ?" : ""}
+        `, bindings)]);
+		const parsedColumms = columns.rows.map((col) => {
+			const constraintsForColumn = constraints.rows.filter((constraint) => constraint.table === col.table && constraint.column === col.name);
+			const foreignKeyConstraint = constraintsForColumn.find((constraint) => constraint.type === "f");
+			return {
+				...col,
+				is_unique: constraintsForColumn.some((constraint) => ["u", "p"].includes(constraint.type)),
+				is_primary_key: constraintsForColumn.some((constraint) => constraint.type === "p"),
+				has_auto_increment: constraintsForColumn.some((constraint) => constraint.has_auto_increment),
+				default_value: parseDefaultValue$1(col.default_value),
+				foreign_key_schema: (foreignKeyConstraint === null || foreignKeyConstraint === void 0 ? void 0 : foreignKeyConstraint.foreign_key_schema) ?? null,
+				foreign_key_table: (foreignKeyConstraint === null || foreignKeyConstraint === void 0 ? void 0 : foreignKeyConstraint.foreign_key_table) ?? null,
+				foreign_key_column: (foreignKeyConstraint === null || foreignKeyConstraint === void 0 ? void 0 : foreignKeyConstraint.foreign_key_column) ?? null
+			};
+		});
+		if (table && column) return parsedColumms[0];
+		return parsedColumms;
+	}
+	/**
+	* Check if the given table contains the given column
+	*/
+	async hasColumn(table, column) {
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		return (await this.knex.raw(`
+      SELECT
+        att.attname AS column,
+        rel.relname AS table
+      FROM
+        pg_attribute att
+        LEFT JOIN pg_class rel ON att.attrelid = rel.oid
+      WHERE
+        rel.relnamespace IN (${schemaIn})
+        AND rel.relname = ?
+        AND att.attname = ?
+        AND rel.relkind = 'r'
+        AND att.attnum > 0
+        AND NOT att.attisdropped;
+    `, [table, column])).rows;
+	}
+	/**
+	* Get the primary key column for the given table
+	*/
+	async primary(table) {
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		const result = await this.knex.raw(`
+      SELECT
+          att.attname AS column
+        FROM
+          pg_constraint con
+        LEFT JOIN pg_class rel ON con.conrelid = rel.oid
+        LEFT JOIN pg_attribute att ON att.attrelid = con.conrelid AND att.attnum = ANY(con.conkey)
+        WHERE con.connamespace IN (${schemaIn})
+          AND con.contype = 'p'
+          AND rel.relname = ?
+    `, [table]);
+		return result.rows.length !== 0 ? result.rows.length === 1 ? result.rows[0].column : result.rows.map((r) => r.column) : null;
+	}
+	async foreignKeys(table) {
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		const bindings = [];
+		if (table) bindings.push(table);
+		return (await this.knex.raw(`
+       SELECT
+          con.conname AS constraint_name,
+          rel.relname AS table,
+          att.attname AS column,
+          frel.relnamespace::regnamespace::text AS foreign_key_schema,
+          frel.relname AS foreign_key_table,
+          fatt.attname AS foreign_key_column,
+          CASE con.confupdtype
+            WHEN 'r' THEN
+              'RESTRICT'
+            WHEN 'c' THEN
+              'CASCADE'
+            WHEN 'n' THEN
+              'SET NULL'
+            WHEN 'd' THEN
+              'SET DEFAULT'
+            WHEN 'a' THEN
+              'NO ACTION'
+            ELSE
+              NULL
+          END AS on_update,
+          CASE con.confdeltype
+            WHEN 'r' THEN
+              'RESTRICT'
+            WHEN 'c' THEN
+              'CASCADE'
+            WHEN 'n' THEN
+              'SET NULL'
+            WHEN 'd' THEN
+              'SET DEFAULT'
+            WHEN 'a' THEN
+              'NO ACTION'
+            ELSE
+              NULL
+          END AS on_delete
+        FROM
+          pg_constraint con
+        LEFT JOIN pg_class rel ON con.conrelid = rel.oid
+        LEFT JOIN pg_class frel ON con.confrelid = frel.oid
+        LEFT JOIN pg_attribute att ON att.attrelid = con.conrelid AND att.attnum = con.conkey[1]
+        LEFT JOIN pg_attribute fatt ON fatt.attrelid = con.confrelid AND fatt.attnum = con.confkey[1]
+        WHERE con.connamespace IN (${schemaIn})
+          AND array_length(con.conkey, 1) <= 1
+          AND (con.confkey IS NULL OR array_length(con.confkey, 1) = 1)
+          AND con.contype = 'f'
+          ${table ? "AND rel.relname = ?" : ""}
+    `, bindings)).rows;
+	}
+	async uniqueConstraints(table) {
+		const { knex: knex$1 } = this;
+		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
+		const bindings = [];
+		if (table) bindings.push(table);
+		return (await knex$1.raw(`
+      SELECT
+        con.conrelid::regclass AS table_name,
+        con.conname AS constraint_name,
+        array_agg(a.attname ORDER BY k.n) AS columns
+      FROM
+        pg_constraint AS con
+      CROSS JOIN LATERAL unnest(con.conkey) WITH ORDINALITY AS k(con,n)
+      LEFT JOIN pg_class rel ON con.conrelid = rel.oid
+      JOIN pg_attribute AS a ON a.attnum = k.con AND a.attrelid = con.conrelid
+      WHERE con.contype = 'u'
+        AND con.connamespace IN (${schemaIn})
+        ${table ? "AND rel.relname = ?" : ""}
+      GROUP BY con.oid, con.conrelid, con.conname;
+      `, bindings)).rows.map((v) => {
+			const columns = Array.isArray(v.columns) ? v.columns : v.columns.substring(1, v.columns.length - 1).split(",");
+			return {
+				table: v.table_name,
+				constraint_name: v.constraint_name,
+				columns
+			};
+		});
+	}
+};
+
+//#endregion
+//#region src/inspector/utils/extract-max-length.ts
+/**
+* Extracts the length value out of a given datatype
+* For example: `varchar(32)` => 32
+*/
+function extractMaxLength(type) {
+	const matches = /\(([^)]+)\)/.exec(type);
+	if (matches && matches.length > 0 && matches[1]) return Number(matches[1]);
+	return null;
+}
+
+//#endregion
+//#region src/inspector/utils/extract-type.ts
+/**
+* Extracts the type out of a given datatype
+* For example: `varchar(32)` => varchar
+*/
+function extractType(type) {
+	return type.replace(/[^a-zA-Z]/g, "").toLowerCase();
+}
+
+//#endregion
+//#region src/casts/attribute.ts
+var Attribute = class Attribute {
+	get;
+	set;
+	withCaching = false;
+	withObjectCaching = true;
+	constructor({ get: get$1 = null, set: set$1 = null }) {
+		this.get = get$1;
+		this.set = set$1;
+	}
+	static make({ get: get$1 = null, set: set$1 = null }) {
+		return new Attribute({
+			get: get$1,
+			set: set$1
+		});
+	}
+	static get(get$1) {
+		return new Attribute({ get: get$1 });
+	}
+	static set(set$1) {
+		return new Attribute({ set: set$1 });
+	}
+	withoutObjectCaching() {
+		this.withObjectCaching = false;
+		return this;
+	}
+	shouldCache() {
+		this.withCaching = true;
+		return this;
+	}
+};
+var attribute_default = Attribute;
+
+//#endregion
+//#region src/errors.ts
+var BaseError = class extends Error {
+	constructor(message, _entity) {
+		super(message);
+		Error.captureStackTrace(this, this.constructor);
+		this.name = this.constructor.name;
+		this.message = message;
+	}
+};
+var ModelNotFoundError = class extends BaseError {
+	model;
+	ids = [];
+	constructor() {
+		super("");
+	}
+	setModel(model, ids = []) {
+		this.model = model;
+		this.ids = (0, radashi.isArray)(ids) ? ids : [ids];
+		this.message = `No query results for model [${model}]`;
+		if (this.ids.length > 0) this.message += " " + this.ids.join(", ");
+		else this.message += ".";
+		return this;
+	}
+	getModel() {
+		return this.model;
+	}
+	getIds() {
+		return this.ids;
+	}
+};
+var RelationNotFoundError = class extends BaseError {};
+var InvalidArgumentError = class extends BaseError {};
+
+//#endregion
+//#region src/mixin.ts
+var mixin_exports = /* @__PURE__ */ __export({ compose: () => compose$1 });
+/**
+* Compose function that merges multiple classes and mixins
+* 
+* @example
+* const SomePlugin = <TBase extends new (...args: any[]) => TGeneric> (Base: TBase) => {
+*     return class extends Base {
+*         pluginAttribtue = 'plugin'
+*         pluginMethod () {
+*             return this.pluginAttribtue
+*         }
+*     }
+* }
+*
+* // Base class
+* class Model {
+*     make () {
+*         console.log('make')
+*     }
+*     pluginMethod (id: string) {
+*     }
+* }
+*
+* class User extends compose(
+*     Model,
+*     SomePlugin,
+* ) {
+*     relationPosts () {
+*         return 'hasMany Posts'
+*     }
+* }
+*
+* const user = new User()
+* user.make() // from Model
+* user.pluginMethod() // from SomePlugin
+* user.relationPosts() // from User
+*
+* console.log(user.pluginMethod('w')) // "plugin"
+* console.log(user.pluginMethod()) // "plugin"
+* console.log(user.relationPosts()) // "hasMany Posts"
+* 
+* @param Base 
+* @param mixins 
+* @returns 
+*/
+function compose$1(Base, ...mixins) {
+	/**
+	* Apply each mixin or class in sequence
+	*/
+	return mixins.reduce((acc, mixin) => {
+		if (typeof mixin === "function" && mixin.prototype)
+ /**
+		* If it's a class constructor, extend it
+		*/
+		return class extends acc {
+			constructor(...args) {
+				super(...args);
+				/**
+				* Copy instance properties from mixin prototype
+				*/
+				Object.getOwnPropertyNames(mixin.prototype).forEach((name) => {
+					if (name !== "constructor") Object.defineProperty(this, name, Object.getOwnPropertyDescriptor(mixin.prototype, name));
+				});
+			}
+		};
+		else if (typeof mixin === "function")
+ /**
+		* If it's a mixin function, call it with current class
+		*/
+		return mixin(acc);
+		return acc;
+	}, Base);
+}
+
+//#endregion
+//#region src/utils.ts
+dayjs.default.extend(dayjs_plugin_advancedFormat_js.default);
+const getRelationName = (relationMethod) => {
+	return (0, radashi.snake)(relationMethod.substring(8));
+};
+const getRelationMethod = (relation) => {
+	return (0, radashi.camel)(`relation_${relation}`);
+};
+const getScopeMethod = (scope) => {
+	return (0, radashi.camel)(`scope_${scope}`);
+};
+const getAttrMethod = (attr) => {
+	return (0, radashi.camel)(`attribute_${attr}`);
+};
+const getGetterMethod = (attr) => {
+	return (0, radashi.camel)(`get_${attr}_attribute`);
+};
+const getSetterMethod = (attr) => {
+	return (0, radashi.camel)(`set_${attr}_attribute`);
+};
+/**
+* Tap into a model a collection instance
+* 
+* @param instance 
+* @param callback 
+* @returns 
+*/
+const tap = (instance, callback) => {
+	const result = callback(instance);
+	return result instanceof Promise ? result.then(() => instance) : instance;
+};
+const { compose } = mixin_exports;
+const flatten = (arr) => arr.flat();
+const flattenDeep = (arr) => Array.isArray(arr) ? arr.reduce((a, b) => a.concat(flattenDeep(b)), []) : [arr];
+const snakeCase = (str) => (0, radashi.trim)((0, radashi.snake)(str.replace(/[^a-zA-Z0-9_-]/g, "-")), "_-");
+
+//#endregion
+//#region src/relations/relation.ts
+var Relation = class {
+	query;
+	parent;
+	related;
+	eagerKeysWereEmpty = false;
+	static constraints = true;
+	static selfJoinCount = 0;
+	constructor(query, parent) {
+		this.query = query;
+		this.parent = parent;
+		this.related = this.query.model;
+	}
+	static extend(trait) {
+		for (const methodName in trait) this.prototype[methodName] = trait[methodName];
+	}
+	static noConstraints(callback) {
+		const previous = this.constraints;
+		this.constraints = false;
+		try {
+			return callback();
+		} finally {
+			this.constraints = previous;
+		}
+	}
+	asProxy() {
+		return new Proxy(this, { get: function(target, prop) {
+			if (typeof target[prop] !== "undefined") return target[prop];
+			if (typeof prop === "string") {
+				if (typeof target.query[prop] === "function") return (...args) => {
+					target.query[prop](...args);
+					return target.asProxy();
+				};
+			}
+		} });
+	}
+	getRelated() {
+		return this.related;
+	}
+	getKeys(models, key) {
+		return models.map((model) => key ? model.attributes[key] : model.getKey()).sort();
+	}
+	getRelationQuery() {
+		return this.query;
+	}
+	whereInEager(whereIn, key, modelKeys, query = null) {
+		(query || this.query)[whereIn](key, modelKeys);
+		if (modelKeys.length === 0) this.eagerKeysWereEmpty = true;
+	}
+	whereInMethod(model, key) {
+		return "whereIn";
+	}
+	getEager() {
+		return this.eagerKeysWereEmpty ? this.query.getModel().newCollection() : this.get();
+	}
+	async get(columns = ["*"]) {
+		return await this.query.get(columns);
+	}
+	async first(columns = ["*"]) {
+		return await this.query.first(columns);
+	}
+	async paginate(...args) {
+		return await this.query.paginate(...args);
+	}
+	async count(...args) {
+		return await this.query.clearSelect().count(...args);
+	}
+	toSql() {
+		return this.query.toSql();
+	}
+	addConstraints() {}
+	getRelationCountHash(incrementJoinCount = true) {
+		return "arquebus_reserved_" + (incrementJoinCount ? this.constructor.selfJoinCount++ : this.constructor.selfJoinCount);
+	}
+	getRelationExistenceQuery(query, parentQuery, columns = ["*"]) {
+		return query.select(columns).whereColumn(this.getQualifiedParentKeyName(), "=", this.getExistenceCompareKey());
+	}
+	getRelationExistenceCountQuery(query, parentQuery) {
+		const db = this.related.getConnection();
+		return this.getRelationExistenceQuery(query, parentQuery, db.raw("count(*)"));
+	}
+	getQualifiedParentKeyName() {
+		return this.parent.getQualifiedKeyName();
+	}
+	getExistenceCompareKey() {
+		var _this$getQualifiedFor;
+		return (_this$getQualifiedFor = this.getQualifiedForeignKeyName) === null || _this$getQualifiedFor === void 0 ? void 0 : _this$getQualifiedFor.call(this);
+	}
+};
+var relation_default = Relation;
+
+//#endregion
+//#region src/relations/concerns/supports-default-models.ts
+const SupportsDefaultModels = (Relation$1) => {
+	return class extends Relation$1 {
+		_withDefault;
+		withDefault(callback = true) {
+			this._withDefault = callback;
+			return this;
+		}
+		getDefaultFor(parent) {
+			if (!this._withDefault) return null;
+			const instance = this.newRelatedInstanceFor(parent);
+			if (typeof this._withDefault === "function") return this._withDefault(instance, parent) || instance;
+			if (typeof this._withDefault === "object") for (const key in this._withDefault) instance.setAttribute(key, this._withDefault[key]);
+			return instance;
+		}
+	};
+};
+var supports_default_models_default = SupportsDefaultModels;
+
+//#endregion
+//#region src/relations/belongs-to.ts
+var BelongsTo = class extends compose(relation_default, supports_default_models_default) {
+	foreignKey;
+	ownerKey;
+	child;
+	relationName;
+	constructor(query, child, foreignKey, ownerKey, relationName) {
+		super(query, child);
+		this.foreignKey = foreignKey;
+		this.ownerKey = ownerKey;
+		this.child = child;
+		this.relationName = relationName;
+		this.addConstraints();
+		return this.asProxy();
+	}
+	async getResults() {
+		if (this.child[this.foreignKey] === null) return this.getDefaultFor(this.parent);
+		return await this.query.first() || this.getDefaultFor(this.parent);
+	}
+	match(models, results, relation) {
+		const foreign = this.foreignKey;
+		const owner = this.ownerKey;
+		const dictionary = {};
+		results.map((result) => {
+			const attribute = result.attributes[owner];
+			dictionary[attribute] = result;
+		});
+		models.map((model) => {
+			const attribute = model[foreign];
+			if (dictionary[attribute] !== void 0) model.setRelation(relation, dictionary[attribute]);
+		});
+		return models;
+	}
+	getQualifiedForeignKeyName() {
+		return this.child.qualifyColumn(this.foreignKey);
+	}
+	getRelationExistenceQuery(query, parentQuery, columns = ["*"]) {
+		if (parentQuery.getQuery()._single.table === query.getQuery()._single.table) return this.getRelationExistenceQueryForSelfRelation(query, parentQuery, columns);
+		return query.select(columns).whereColumn(this.getQualifiedForeignKeyName(), "=", query.qualifyColumn(this.ownerKey));
+	}
+	getRelationExistenceQueryForSelfRelation(query, parentQuery, columns = ["*"]) {
+		const hash = this.getRelationCountHash();
+		query.select(columns).from(query.getModel().getTable() + " as " + hash);
+		query.getModel().setTable(hash);
+		return query.whereColumn(`${hash}.${this.ownerKey}`, "=", this.getQualifiedForeignKeyName());
+	}
+	initRelation(models, relation) {
+		models.forEach((model) => {
+			model.setRelation(relation, this.getDefaultFor(model));
+		});
+		return models;
+	}
+	addEagerConstraints(models) {
+		const key = `${this.related.getTable()}.${this.ownerKey}`;
+		this.query.whereIn(key, this.getEagerModelKeys(models));
+	}
+	getEagerModelKeys(models) {
+		const keys = [];
+		models.forEach((model) => {
+			const value = model[this.foreignKey];
+			if (value !== null && value !== void 0) keys.push(value);
+		});
+		keys.sort();
+		return [...new Set(keys)];
+	}
+	associate(model) {
+		const ownerKey = model instanceof Model ? model.attributes[this.ownerKey] : model;
+		this.child[this.foreignKey] = ownerKey;
+		if (model instanceof Model) this.child.setRelation(this.relationName, model);
+		else this.child.unsetRelation(this.relationName);
+		return this.child;
+	}
+	dissociate() {
+		this.child[this.foreignKey] = null;
+		return this.child.setRelation(this.relationName, null);
+	}
+	addConstraints() {
+		if (this.constructor.constraints) {
+			const table = this.related.getTable();
+			this.query.where(`${table}.${this.ownerKey}`, "=", this.child[this.foreignKey]);
+		}
+	}
+	newRelatedInstanceFor(_parent) {
+		return this.related.newInstance();
+	}
+};
+var belongs_to_default = BelongsTo;
+
+//#endregion
+//#region src/casts-attributes.ts
+var CastsAttributes = class CastsAttributes {
+	constructor() {
+		if (this.constructor === CastsAttributes) throw new Error("CastsAttributes cannot be instantiated");
+	}
+	static get(_model, _key, _value, _attributes) {
+		throw new Error("get not implemented");
+	}
+	static set(_model, _key, _value, _attributes) {
+		throw new Error("set not implemented");
+	}
+};
+var casts_attributes_default = CastsAttributes;
+
+//#endregion
+//#region src/concerns/has-attributes.ts
+const HasAttributes = (Model$1) => {
+	return class extends Model$1 {
+		static castTypeCache = {};
+		attributes = {};
+		original = {};
+		casts = {};
+		changes = {};
+		appends = [];
+		setAppends(appends) {
+			this.appends = appends;
+			return this;
+		}
+		append(...keys) {
+			const appends = flattenDeep(keys);
+			this.appends = [...this.appends, ...appends];
+			return this;
+		}
+		normalizeCastClassResponse(key, value) {
+			var _value$constructor;
+			return (value === null || value === void 0 || (_value$constructor = value.constructor) === null || _value$constructor === void 0 ? void 0 : _value$constructor.name) === "Object" ? value : { [key]: value };
+		}
+		syncOriginal() {
+			this.original = this.getAttributes();
+			return this;
+		}
+		syncChanges() {
+			this.changes = this.getDirty();
+			return this;
+		}
+		syncOriginalAttribute(attribute) {
+			this.syncOriginalAttributes(attribute);
+		}
+		syncOriginalAttributes(...attributes) {
+			attributes = flattenDeep(attributes);
+			const modelAttributes = this.getAttributes();
+			for (const attribute of attributes) this.original[attribute] = modelAttributes[attribute];
+			return this;
+		}
+		isDirty(...attributes) {
+			const changes = this.getDirty();
+			attributes = flattenDeep(attributes);
+			if (attributes.length === 0) return Object.keys(changes).length > 0;
+			for (const attribute of attributes) if (attribute in changes) return true;
+			return false;
+		}
+		getDirty() {
+			const dirty = {};
+			const attributes = this.getAttributes();
+			for (const key in attributes) {
+				const value = attributes[key];
+				if (!this.originalIsEquivalent(key)) dirty[key] = value;
+			}
+			return dirty;
+		}
+		originalIsEquivalent(key) {
+			if (this.original[key] === void 0) return false;
+			const attribute = this.attributes[key];
+			const original = this.original[key];
+			if (attribute === original) return true;
+			else return false;
+		}
+		setAttributes(attributes) {
+			this.attributes = { ...attributes };
+		}
+		setRawAttributes(attributes, sync = false) {
+			this.attributes = attributes;
+			if (sync) this.syncOriginal();
+			return this;
+		}
+		getAttributes() {
+			return { ...this.attributes };
+		}
+		setAttribute(key, value) {
+			const setterMethod = getSetterMethod(key);
+			if (typeof this[setterMethod] === "function") {
+				this[setterMethod](value);
+				return this;
+			}
+			const attrMethod = getAttrMethod(key);
+			if (typeof this[attrMethod] === "function") {
+				const callback = this[attrMethod]().set || ((value$1) => {
+					this.attributes[key] = value$1;
+				});
+				this.attributes = {
+					...this.attributes,
+					...this.normalizeCastClassResponse(key, callback(value, this.attributes))
+				};
+				return this;
+			}
+			const castType = this.getCasts()[key];
+			if (this.isCustomCast(castType) && typeof castType !== "string") value = castType.set(this, key, value, this.attributes) ?? "";
+			if (castType === "json") value = JSON.stringify(value);
+			if (castType === "collection") value = JSON.stringify(value);
+			if (value !== null && this.isDateAttribute(key)) value = this.fromDateTime(value);
+			this.attributes[key] = value;
+			return this;
+		}
+		getAttribute(key) {
+			if (!key) return;
+			const getterMethod = getGetterMethod(key);
+			if (typeof this[getterMethod] === "function") return this[getterMethod](this.attributes[key], this.attributes);
+			const attrMethod = getAttrMethod(key);
+			if (typeof this[attrMethod] === "function") return this[attrMethod]().get(this.attributes[key], this.attributes);
+			if (key in this.attributes) {
+				if (this.hasCast(key)) return this.castAttribute(key, this.attributes[key]);
+				if (this.getDates().includes(key)) return this.asDateTime(this.attributes[key]);
+				return this.attributes[key];
+			}
+			if (key in this.relations) return this.relations[key];
+		}
+		castAttribute(key, value) {
+			const castType = this.getCastType(key);
+			if (!castType) return value;
+			if (value === null) return value;
+			switch (castType) {
+				case "int":
+				case "integer": return parseInt(value);
+				case "real":
+				case "float":
+				case "double": return parseFloat(value);
+				case "decimal": return this.asDecimal(value, castType.split(":")[1]);
+				case "string": return String(value);
+				case "bool":
+				case "boolean": return Boolean(value);
+				case "object":
+				case "json": try {
+					return JSON.parse(value);
+				} catch {
+					return null;
+				}
+				case "collection": try {
+					return (0, collect_js.default)(JSON.parse(value));
+				} catch {
+					return (0, collect_js.default)([]);
+				}
+				case "date": return this.asDate(value);
+				case "datetime":
+				case "custom_datetime": return this.asDateTime(value);
+				case "timestamp": return this.asTimestamp(value);
+			}
+			if (this.isCustomCast(castType)) return castType.get(this, key, value, this.attributes);
+			return value;
+		}
+		attributesToData() {
+			let attributes = { ...this.attributes };
+			for (const key in attributes) {
+				if (this.hidden.includes(key)) attributes = (0, radashi.omit)(attributes, [key]);
+				if (this.visible.length > 0 && this.visible.includes(key) === false) attributes = (0, radashi.omit)(attributes, [key]);
+			}
+			for (const key of this.getDates()) {
+				if (attributes[key] === void 0) continue;
+				attributes[key] = this.serializeDate(this.asDateTime(attributes[key]));
+			}
+			const casts = this.getCasts();
+			for (const key in casts) {
+				const value = casts[key];
+				if (key in attributes === false) continue;
+				attributes[key] = this.castAttribute(key, attributes[key]);
+				if (key in attributes && ["date", "datetime"].includes(String(value))) attributes[key] = this.serializeDate(attributes[key]);
+				if (key in attributes && this.isCustomDateTimeCast(value)) attributes[key] = (0, dayjs.default)(attributes[key]).format(String(value).split(":")[1]);
+			}
+			for (const key of this.appends) attributes[key] = this.mutateAttribute(key, null);
+			return attributes;
+		}
+		mutateAttribute(key, value) {
+			if (typeof this[getGetterMethod(key)] === "function") return this[getGetterMethod(key)](value);
+			else if (typeof this[getAttrMethod(key)] === "function") return this[getAttrMethod(key)]().get(key, this.attributes);
+			else if (key in this) return this[key];
+			return value;
+		}
+		mutateAttributeForArray(_key, _value) {}
+		isDateAttribute(key) {
+			return this.getDates().includes(key) || this.isDateCastable(key);
+		}
+		serializeDate(date) {
+			return date ? (0, dayjs.default)(date).toISOString() : null;
+		}
+		getDates() {
+			return this.usesTimestamps() ? [this.getCreatedAtColumn(), this.getUpdatedAtColumn()] : [];
+		}
+		getCasts() {
+			if (this.getIncrementing()) return {
+				[this.getKeyName()]: this.getKeyType(),
+				...this.casts
+			};
+			return this.casts;
+		}
+		getCastType(key) {
+			const castType = this.getCasts()[key];
+			let castTypeCacheKey;
+			if (typeof castType === "string") castTypeCacheKey = castType;
+			else if (new castType() instanceof casts_attributes_default) castTypeCacheKey = castType.name;
+			if (castTypeCacheKey && this.getConstructor().castTypeCache[castTypeCacheKey] !== void 0) return this.getConstructor().castTypeCache[castTypeCacheKey];
+			let convertedCastType;
+			if (this.isCustomDateTimeCast(castType)) convertedCastType = "custom_datetime";
+			else if (this.isDecimalCast(castType)) convertedCastType = "decimal";
+			else if (this.isCustomCast(castType)) convertedCastType = castType;
+			else convertedCastType = String(castType).toLocaleLowerCase().trim();
+			return this.getConstructor()[castTypeCacheKey] = convertedCastType;
+		}
+		hasCast(key, types = []) {
+			if (key in this.casts) {
+				types = (0, radashi.flat)(types);
+				return types.length > 0 ? types.includes(this.getCastType(key)) : true;
+			}
+			return false;
+		}
+		withDayjs(date) {
+			return (0, dayjs.default)(date);
+		}
+		isCustomCast(cast) {
+			return typeof cast === "function" && new cast() instanceof casts_attributes_default;
+		}
+		isCustomDateTimeCast(cast) {
+			if (typeof cast !== "string") return false;
+			return cast.startsWith("date:") || cast.startsWith("datetime:");
+		}
+		isDecimalCast(cast) {
+			if (typeof cast !== "string") return false;
+			return cast.startsWith("decimal:");
+		}
+		isDateCastable(key) {
+			return this.hasCast(key, ["date", "datetime"]);
+		}
+		fromDateTime(value) {
+			return (0, dayjs.default)(this.asDateTime(value)).format(this.getDateFormat());
+		}
+		getDateFormat() {
+			return this.dateFormat || "YYYY-MM-DD HH:mm:ss";
+		}
+		asDecimal(value, decimals) {
+			return parseFloat(value).toFixed(decimals);
+		}
+		asDateTime(value) {
+			if (value === null) return null;
+			if (value instanceof Date) return value;
+			if (typeof value === "number") return /* @__PURE__ */ new Date(value * 1e3);
+			return new Date(value);
+		}
+		asDate(value) {
+			const date = this.asDateTime(value);
+			return (0, dayjs.default)(date).startOf("day").toDate();
+		}
+	};
+};
+var has_attributes_default = HasAttributes;
+
+//#endregion
+//#region src/scope.ts
+var Scope = class Scope {
+	constructor() {
+		if (this.constructor === Scope) throw new Error("Scope cannot be instantiated");
+	}
+	apply(_builder, _model) {
+		throw new Error("apply not implemented");
+	}
+};
+var scope_default = Scope;
+
+//#endregion
+//#region src/concerns/has-global-scopes.ts
+const HasGlobalScopes = (Model$1) => {
+	return class extends Model$1 {
+		static globalScopes;
+		static addGlobalScope(scope, implementation = null) {
+			if (typeof scope === "string" && implementation instanceof scope_default) {
+				this.globalScopes = (0, radashi.set)(this.globalScopes ?? {}, this.name + "." + scope, implementation);
+				return implementation;
+			} else if (scope instanceof scope_default) {
+				this.globalScopes = (0, radashi.set)(this.globalScopes ?? {}, this.name + "." + scope.constructor.name, scope);
+				return scope;
+			}
+			throw new InvalidArgumentError("Global scope must be an instance of Scope.");
+		}
+		static hasGlobalScope(scope) {
+			return this.getGlobalScope(scope) !== null;
+		}
+		static getGlobalScope(scope) {
+			if (typeof scope === "string") return (0, radashi.get)(this.globalScopes, this.name + "." + scope);
+			return (0, radashi.get)(this.globalScopes, this.name + "." + scope.constructor.name);
+		}
+		static getAllGlobalScopes() {
+			return this.globalScopes;
+		}
+		static setAllGlobalScopes(scopes) {
+			this.globalScopes = scopes;
+		}
+		getGlobalScopes() {
+			return (0, radashi.get)(this.constructor.globalScopes, this.constructor.name, {});
+		}
+	};
+};
+var has_global_scopes_default = HasGlobalScopes;
+
+//#endregion
+//#region src/hooks.ts
+var Hooks = class {
+	hooks = {
+		creating: [],
+		created: [],
+		updating: [],
+		updated: [],
+		saving: [],
+		saved: [],
+		deleting: [],
+		deleted: [],
+		restoring: [],
+		restored: [],
+		trashed: [],
+		forceDeleting: [],
+		forceDeleted: []
+	};
+	add(hook, callback) {
+		this.hooks[hook].push(callback);
+	}
+	async exec(hook, data) {
+		const callbacks = this.hooks[hook] ?? [];
+		for (const callback of callbacks) await callback(...data);
+		return true;
+	}
+};
+var hooks_default = Hooks;
+
+//#endregion
+//#region src/concerns/has-hooks.ts
+const HasHooks = (Model$1) => {
+	return class extends Model$1 {
+		static hooks = null;
+		static addHook(hook, callback) {
+			if (this.hooks instanceof hooks_default === false) this.hooks = new hooks_default();
+			this.hooks.add(hook, callback);
+		}
+		static creating(callback) {
+			this.addHook("creating", callback);
+		}
+		static created(callback) {
+			this.addHook("created", callback);
+		}
+		static updating(callback) {
+			this.addHook("updating", callback);
+		}
+		static updated(callback) {
+			this.addHook("updated", callback);
+		}
+		static saving(callback) {
+			this.addHook("saving", callback);
+		}
+		static saved(callback) {
+			this.addHook("saved", callback);
+		}
+		static deleting(callback) {
+			this.addHook("deleting", callback);
+		}
+		static deleted(callback) {
+			this.addHook("deleted", callback);
+		}
+		static restoring(callback) {
+			this.addHook("restoring", callback);
+		}
+		static restored(callback) {
+			this.addHook("restored", callback);
+		}
+		static trashed(callback) {
+			this.addHook("trashed", callback);
+		}
+		static forceDeleted(callback) {
+			this.addHook("forceDeleted", callback);
+		}
+		async execHooks(hook, options) {
+			if (this.constructor.hooks instanceof hooks_default === false) return;
+			return await this.constructor.hooks.exec(hook, [this, options]);
+		}
+	};
+};
+var has_hooks_default = HasHooks;
+
+//#endregion
+//#region src/relations/has-one-or-many.ts
+const HasOneOrMany = (Relation$1) => {
+	return class extends Relation$1 {
+		getRelationValue(dictionary, key, type) {
+			const value = dictionary[key];
+			return type === "one" ? value[0] : new collection_default(value);
+		}
+		matchOneOrMany(models, results, relation, type) {
+			const dictionary = this.buildDictionary(results);
+			models.map((model) => {
+				const key = model.attributes[this.localKey];
+				if (dictionary[key] !== void 0) model.setRelation(relation, this.getRelationValue(dictionary, key, type));
+			});
+			return models;
+		}
+		buildDictionary(results) {
+			const foreign = this.getForeignKeyName();
+			return (0, collect_js.default)(results).mapToDictionary((result) => [result[foreign], result]).all();
+		}
+		async save(model) {
+			this.setForeignAttributesForCreate(model);
+			return await model.save() ? model : false;
+		}
+		async saveMany(models) {
+			await Promise.all(models.map(async (model) => {
+				await this.save(model);
+			}));
+			return models instanceof collection_default ? models : new collection_default(models);
+		}
+		async create(attributes = {}) {
+			return await tap(this.related.constructor.init(attributes), async (instance) => {
+				this.setForeignAttributesForCreate(instance);
+				await instance.save();
+			});
+		}
+		async createMany(records) {
+			const instances = await Promise.all(records.map(async (record) => {
+				return await this.create(record);
+			}));
+			return instances instanceof collection_default ? instances : new collection_default(instances);
+		}
+		setForeignAttributesForCreate(model) {
+			model[this.getForeignKeyName()] = this.getParentKey();
+		}
+		getForeignKeyName() {
+			const segments = this.getQualifiedForeignKeyName().split(".");
+			return segments[segments.length - 1];
+		}
+		getParentKey() {
+			return this.parent.attributes[this.localKey];
+		}
+		getQualifiedForeignKeyName() {
+			return this.foreignKey;
+		}
+		getExistenceCompareKey() {
+			return this.getQualifiedForeignKeyName();
+		}
+		addConstraints() {
+			if (this.constructor.constraints) {
+				const query = this.getRelationQuery();
+				query.where(this.foreignKey, "=", this.getParentKey());
+				query.whereNotNull(this.foreignKey);
+			}
+		}
+	};
+};
+var has_one_or_many_default = HasOneOrMany;
+
+//#endregion
+//#region src/relations/has-many.ts
+var HasMany = class extends compose(relation_default, has_one_or_many_default) {
+	foreignKey;
+	localKey;
+	constructor(query, parent, foreignKey, localKey) {
+		super(query, parent);
+		this.foreignKey = foreignKey;
+		this.localKey = localKey;
+		this.addConstraints();
+		return this.asProxy();
+	}
+	initRelation(models, relation) {
+		models.map((model) => {
+			model.setRelation(relation, new collection_default([]));
+		});
+		return models;
+	}
+	async getResults() {
+		return this.getParentKey() !== null ? await this.query.get() : new collection_default([]);
+	}
+	getForeignKeyName() {
+		var _this$foreignKey;
+		const segments = (_this$foreignKey = this.foreignKey) === null || _this$foreignKey === void 0 ? void 0 : _this$foreignKey.split(".");
+		return segments === null || segments === void 0 ? void 0 : segments.pop();
+	}
+	buildDictionary(results) {
+		const foreign = this.getForeignKeyName();
+		return (0, collect_js.collect)(results).mapToDictionary((result) => [result[foreign], result]).all();
+	}
+	match(models, results, relation) {
+		return this.matchOneOrMany(models, results, relation, "many");
+	}
+	addEagerConstraints(models) {
+		this.query.whereIn(this.foreignKey, this.getKeys(models, this.localKey));
+	}
+};
+var has_many_default = HasMany;
+
+//#endregion
+//#region src/relations/has-one.ts
+var HasOne = class extends compose(relation_default, has_one_or_many_default, supports_default_models_default) {
+	foreignKey;
+	localKey;
+	constructor(query, parent, foreignKey, localKey) {
+		super(query, parent);
+		this.foreignKey = foreignKey;
+		this.localKey = localKey;
+		this.addConstraints();
+		return this.asProxy();
+	}
+	initRelation(models, relation) {
+		models.map((model) => {
+			model.setRelation(relation, this.getDefaultFor(model));
+		});
+		return models;
+	}
+	matchOne(models, results, relation) {
+		return this.matchOneOrMany(models, results, relation, "one");
+	}
+	getForeignKeyName() {
+		var _this$foreignKey;
+		const segments = (_this$foreignKey = this.foreignKey) === null || _this$foreignKey === void 0 ? void 0 : _this$foreignKey.split(".");
+		return segments === null || segments === void 0 ? void 0 : segments.pop();
+	}
+	async getResults() {
+		if (this.getParentKey() === null) return this.getDefaultFor(this.parent);
+		return await this.query.first() || this.getDefaultFor(this.parent);
+	}
+	match(models, results, relation) {
+		return this.matchOneOrMany(models, results, relation, "one");
+	}
+	addEagerConstraints(models) {
+		this.query.whereIn(this.foreignKey, this.getKeys(models, this.localKey));
+	}
+	newRelatedInstanceFor(parent) {
+		return this.related.newInstance().setAttribute(this.getForeignKeyName(), parent[this.localKey]);
+	}
+};
+var has_one_default = HasOne;
+
+//#endregion
+//#region src/relations/has-many-through.ts
+var HasManyThrough = class extends relation_default {
+	throughParent;
+	farParent;
+	firstKey;
+	secondKey;
+	localKey;
+	secondLocalKey;
+	constructor(query, farParent, throughParent, firstKey, secondKey, localKey, secondLocalKey) {
+		super(query, throughParent);
+		this.localKey = localKey;
+		this.firstKey = firstKey;
+		this.secondKey = secondKey;
+		this.farParent = farParent;
+		this.throughParent = throughParent;
+		this.secondLocalKey = secondLocalKey;
+		return this.asProxy();
+	}
+	addConstraints() {
+		const localValue = this.farParent[this.localKey];
+		this.performJoin();
+		if (this.constructor.constraints) this.query.where(this.getQualifiedFirstKeyName(), "=", localValue);
+	}
+	performJoin(query = null) {
+		query = query || this.query;
+		const farKey = this.getQualifiedFarKeyName();
+		query.join(this.throughParent.getTable(), this.getQualifiedParentKeyName(), "=", farKey);
+		if (this.throughParentSoftDeletes()) query.withGlobalScope("SoftDeletableHasManyThrough", (query$1) => {
+			query$1.whereNull(this.throughParent.getQualifiedDeletedAtColumn());
+		});
+	}
+	getQualifiedParentKeyName() {
+		return this.parent.qualifyColumn(this.secondLocalKey);
+	}
+	throughParentSoftDeletes() {
+		return this.throughParent.pluginInitializers["SoftDeletes"] !== void 0;
+	}
+	withTrashedParents() {
+		this.query.withoutGlobalScope("SoftDeletableHasManyThrough");
+		return this;
+	}
+	addEagerConstraints(models) {
+		const whereIn = this.whereInMethod(this.farParent, this.localKey);
+		this.whereInEager(whereIn, this.getQualifiedFirstKeyName(), this.getKeys(models, this.localKey));
+	}
+	initRelation(models, relation) {
+		for (const model of models) model.setRelation(relation, this.related.newCollection());
+		return models;
+	}
+	match(models, results, relation) {
+		const dictionary = this.buildDictionary(results);
+		for (const model of models) {
+			const key = this.getDictionaryKey(model.getAttribute(this.localKey));
+			if (dictionary[key] !== void 0) model.setRelation(relation, this.related.newCollection(dictionary[key]));
+		}
+		return models;
+	}
+	buildDictionary(results) {
+		const dictionary = {};
+		for (const result of results) {
+			if (dictionary[result.laravel_through_key] === void 0) dictionary[result.laravel_through_key] = [];
+			dictionary[result.laravel_through_key].push(result);
+		}
+		return dictionary;
+	}
+	async firstOrNew(attributes) {
+		return await this.where(attributes).first() || this.related.newInstance(attributes);
+	}
+	async updateOrCreate(attributes, values = {}) {
+		return tap(await this.firstOrCreate(attributes, values), async (instance) => {
+			if (!instance.wasRecentlyCreated) await instance.fill(values).save();
+		});
+	}
+	async firstWhere(column, operator = null, value = null, boolean = "and") {
+		return await this.where(column, operator, value, boolean).first();
+	}
+	async first(columns = ["*"]) {
+		const results = await this.take(1).get(columns);
+		return results.count() > 0 ? results.first() : null;
+	}
+	async firstOrFail(columns = ["*"]) {
+		const model = await this.first(columns);
+		if (model) return model;
+		throw new ModelNotFoundError().setModel(this.related.constructor);
+	}
+	async firstOr(columns = ["*"], callback = null) {
+		if (typeof columns === "function") {
+			callback = columns;
+			columns = ["*"];
+		}
+		const model = await this.first(columns);
+		if (model) return model;
+		return callback === null || callback === void 0 ? void 0 : callback();
+	}
+	async find(id, columns = ["*"]) {
+		if ((0, radashi.isArray)(id)) return await this.findMany(id, columns);
+		return await this.where(this.getRelated().getQualifiedKeyName(), "=", id).first(columns);
+	}
+	async findMany(ids, columns = ["*"]) {
+		if (ids.length === 0) return this.getRelated().newCollection();
+		return await this.whereIn(this.getRelated().getQualifiedKeyName(), ids).get(columns);
+	}
+	async findOrFail(id, columns = ["*"]) {
+		const result = await this.find(id, columns);
+		if (Array.isArray(id)) {
+			if (result.count() === id.length) return result;
+		} else if (result) return result;
+		throw new ModelNotFoundError().setModel(this.related.constructor, id);
+	}
+	async getResults() {
+		return this.farParent[this.localKey] ? await this.get() : this.related.newCollection();
+	}
+	async get(columns = ["*"]) {
+		const builder = this.prepareQueryBuilder(columns);
+		let models = await builder.getModels();
+		if (models.count() > 0) models = await builder.eagerLoadRelations(models);
+		return this.related.newCollection(models);
+	}
+	async paginate(perPage = null, columns = ["*"], pageName = "page", page = null) {
+		this.query.addSelect(this.shouldSelect(columns));
+		return await this.query.paginate(perPage, columns, pageName, page);
+	}
+	shouldSelect(columns = ["*"]) {
+		if ((columns === null || columns === void 0 ? void 0 : columns.at(0)) == "*") columns = [this.related.getTable() + ".*"];
+		return [...columns, this.getQualifiedFirstKeyName() + " as laravel_through_key"];
+	}
+	async chunk(count, callback) {
+		return await this.prepareQueryBuilder().chunk(count, callback);
+	}
+	prepareQueryBuilder(columns = ["*"]) {
+		const builder = this.query.applyScopes();
+		return builder.addSelect(this.shouldSelect(builder.getQuery().columns ? [] : columns));
+	}
+	getRelationExistenceQuery(query, parentQuery, columns = ["*"]) {
+		if (parentQuery.getQuery().from === query.getQuery().from) return this.getRelationExistenceQueryForSelfRelation(query, parentQuery, columns);
+		if (parentQuery.getQuery().from === this.throughParent.getTable()) return this.getRelationExistenceQueryForThroughSelfRelation(query, parentQuery, columns);
+		this.performJoin(query);
+		return query.select(columns).where(this.getQualifiedLocalKeyName(), "=", this.getQualifiedFirstKeyName());
+	}
+	getRelationExistenceQueryForSelfRelation(query, parentQuery, columns = ["*"]) {
+		const hash = this.getRelationCountHash();
+		query.from(query.getModel().getTable() + " as " + hash);
+		query.join(this.throughParent.getTable(), this.getQualifiedParentKeyName(), "=", hash + "." + this.secondKey);
+		if (this.throughParentSoftDeletes()) query.whereNull(this.throughParent.getQualifiedDeletedAtColumn());
+		query.getModel().setTable(hash);
+		return query.select(columns).whereColumn(parentQuery.getQuery().from + "." + this.localKey, "=", this.getQualifiedFirstKeyName());
+	}
+	getRelationExistenceQueryForThroughSelfRelation(query, parentQuery, columns = ["*"]) {
+		const hash = this.getRelationCountHash();
+		const table = this.throughParent.getTable() + " as " + hash;
+		query.join(table, hash + "." + this.secondLocalKey, "=", this.getQualifiedFarKeyName());
+		if (this.throughParentSoftDeletes()) query.whereNull(hash + "." + this.throughParent.getDeletedAtColumn());
+		return query.select(columns).where(parentQuery.getQuery().from + "." + this.localKey, "=", hash + "." + this.firstKey);
+	}
+	getQualifiedFarKeyName() {
+		return this.getQualifiedForeignKeyName();
+	}
+	getFirstKeyName() {
+		return this.firstKey;
+	}
+	getQualifiedFirstKeyName() {
+		return this.throughParent.qualifyColumn(this.firstKey);
+	}
+	getForeignKeyName() {
+		return this.secondKey;
+	}
+	getQualifiedForeignKeyName() {
+		return this.related.qualifyColumn(this.secondKey);
+	}
+	getLocalKeyName() {
+		return this.localKey;
+	}
+	getQualifiedLocalKeyName() {
+		return this.farParent.qualifyColumn(this.localKey);
+	}
+	getSecondLocalKeyName() {
+		return this.secondLocalKey;
+	}
+};
+var has_many_through_default = HasManyThrough;
+
+//#endregion
+//#region src/relations/has-one-through.ts
+var HasOneThrough = class extends compose(has_many_through_default, supports_default_models_default) {
+	async getResults() {
+		return await this.first() || this.getDefaultFor(this.farParent);
+	}
+	initRelation(models, relation) {
+		for (const model of models) model.setRelation(relation, this.getDefaultFor(model));
+		return models;
+	}
+	match(models, results, relation) {
+		const dictionary = this.buildDictionary(results);
+		for (const model of models) {
+			const key = this.getDictionaryKey(model.getAttribute(this.localKey));
+			if (dictionary[key] !== void 0) {
+				const value = dictionary[key];
+				model.setRelation(relation, value[0]);
+			}
+		}
+		return models;
+	}
+	newRelatedInstanceFor(_parent) {
+		return this.related.newInstance();
+	}
+};
+var has_one_through_default = HasOneThrough;
+
+//#endregion
+//#region src/concerns/has-relations.ts
+const HasRelations = (Model$1) => {
+	return class extends Model$1 {
+		relations = {};
+		getRelation(relation) {
+			return this.relations[relation];
+		}
+		setRelation(relation, value) {
+			this.relations[relation] = value;
+			return this;
+		}
+		unsetRelation(relation) {
+			this.relations = (0, radashi.omit)(this.relations, [relation]);
+			return this;
+		}
+		relationLoaded(relation) {
+			return this.relations[relation] !== void 0;
+		}
+		related(relation) {
+			if (typeof this[getRelationMethod(relation)] !== "function") {
+				const message = `Model [${this.constructor.name}]'s relation [${relation}] doesn't exist.`;
+				throw new RelationNotFoundError(message);
+			}
+			return this[getRelationMethod(relation)]();
+		}
+		async getRelated(relation) {
+			return await this.related(relation).getResults();
+		}
+		relationsToData() {
+			const data = {};
+			for (const key in this.relations) {
+				if (this.hidden.includes(key)) continue;
+				if (this.visible.length > 0 && this.visible.includes(key) === false) continue;
+				data[key] = this.relations[key] instanceof Array ? this.relations[key].map((item) => item.toData()) : this.relations[key] === null ? null : this.relations[key].toData();
+			}
+			return data;
+		}
+		guessBelongsToRelation() {
+			const functionName = (/* @__PURE__ */ new Error()).stack.split("\n")[2].split(" ")[5];
+			return getRelationName(functionName);
+		}
+		joiningTable(related, instance = null) {
+			return [instance ? instance.joiningTableSegment() : snakeCase(related.name), this.joiningTableSegment()].sort().join("_").toLocaleLowerCase();
+		}
+		joiningTableSegment() {
+			return snakeCase(this.constructor.name);
+		}
+		hasOne(related, foreignKey = null, localKey = null) {
+			const query = related.query();
+			const instance = new related();
+			foreignKey = foreignKey || this.getForeignKey();
+			localKey = localKey || this.getKeyName();
+			return new has_one_default(query, this, instance.getTable() + "." + foreignKey, localKey);
+		}
+		hasMany(related, foreignKey = null, localKey = null) {
+			const query = related.query();
+			const instance = new related();
+			foreignKey = foreignKey || this.getForeignKey();
+			localKey = localKey || this.getKeyName();
+			return new has_many_default(query, this, instance.getTable() + "." + foreignKey, localKey);
+		}
+		belongsTo(related, foreignKey = null, ownerKey = null, relation = null) {
+			const query = related.query();
+			const instance = new related();
+			foreignKey = foreignKey || instance.getForeignKey();
+			ownerKey = ownerKey || instance.getKeyName();
+			relation = relation || this.guessBelongsToRelation();
+			return new belongs_to_default(query, this, foreignKey, ownerKey, relation);
+		}
+		belongsToMany(related, table = null, foreignPivotKey = null, relatedPivotKey = null, parentKey = null, relatedKey = null) {
+			const query = related.query();
+			const instance = new related();
+			table = table || this.joiningTable(related, instance);
+			foreignPivotKey = foreignPivotKey || this.getForeignKey();
+			relatedPivotKey = relatedPivotKey || instance.getForeignKey();
+			parentKey = parentKey || this.getKeyName();
+			relatedKey = relatedKey || instance.getKeyName();
+			return new belongs_to_many_default(query, this, table, foreignPivotKey, relatedPivotKey, parentKey, relatedKey);
+		}
+		hasOneThrough(related, through, firstKey = null, secondKey = null, localKey = null, secondLocalKey = null) {
+			through = new through();
+			const query = related.query();
+			firstKey = firstKey || this.getForeignKey();
+			secondKey = secondKey || through.getForeignKey();
+			return new has_one_through_default(query, this, through, firstKey, secondKey, localKey || this.getKeyName(), secondLocalKey || through.getKeyName());
+		}
+		hasManyThrough(related, through, firstKey = null, secondKey = null, localKey = null, secondLocalKey = null) {
+			through = new through();
+			const query = related.query();
+			firstKey = firstKey || this.getForeignKey();
+			secondKey = secondKey || through.getForeignKey();
+			return new has_many_through_default(query, this, through, firstKey, secondKey, localKey || this.getKeyName(), secondLocalKey || through.getKeyName());
+		}
+	};
+};
+var has_relations_default = HasRelations;
+
+//#endregion
+//#region src/concerns/has-timestamps.ts
+const HasTimestamps = (Model$1) => {
+	return class extends Model$1 {
+		static CREATED_AT = "created_at";
+		static UPDATED_AT = "updated_at";
+		static DELETED_AT = "deleted_at";
+		timestamps = true;
+		dateFormat = "YYYY-MM-DD HH:mm:ss";
+		usesTimestamps() {
+			return this.timestamps;
+		}
+		updateTimestamps() {
+			const time = this.freshTimestampString();
+			const updatedAtColumn = this.getUpdatedAtColumn();
+			if (updatedAtColumn && !this.isDirty(updatedAtColumn)) this.setUpdatedAt(time);
+			const createdAtColumn = this.getCreatedAtColumn();
+			if (!this.exists && createdAtColumn && !this.isDirty(createdAtColumn)) this.setCreatedAt(time);
+			return this;
+		}
+		getCreatedAtColumn() {
+			return this.constructor.CREATED_AT;
+		}
+		getUpdatedAtColumn() {
+			return this.constructor.UPDATED_AT;
+		}
+		setCreatedAt(value) {
+			this.attributes[this.getCreatedAtColumn()] = value;
+			return this;
+		}
+		setUpdatedAt(value) {
+			this.attributes[this.getUpdatedAtColumn()] = value;
+			return this;
+		}
+		freshTimestamp() {
+			const time = /* @__PURE__ */ new Date();
+			time.setMilliseconds(0);
+			return time;
+		}
+		freshTimestampString() {
+			return this.fromDateTime(this.freshTimestamp());
+		}
+	};
+};
+var has_timestamps_default = HasTimestamps;
+
+//#endregion
+//#region src/concerns/hides-attributes.ts
+const HidesAttributes = (Model$1) => {
+	return class extends Model$1 {
+		hidden = [];
+		visible = [];
+		makeVisible(...keys) {
+			const visible = flattenDeep(keys);
+			if (this.visible.length > 0) this.visible = [...this.visible, ...visible];
+			this.hidden = (0, radashi.diff)(this.hidden, visible);
+			return this;
+		}
+		makeHidden(key, ...keys) {
+			const hidden = flattenDeep([...key, ...keys]);
+			if (this.hidden.length > 0) this.hidden = [...this.hidden, ...hidden];
+			return this;
+		}
+		getHidden() {
+			return this.hidden;
+		}
+		getVisible() {
+			return this.visible;
+		}
+		setHidden(hidden) {
+			this.hidden = hidden;
+			return this;
+		}
+		setVisible(visible) {
+			this.visible = visible;
+			return this;
+		}
+	};
+};
+var hides_attributes_default = HidesAttributes;
+
+//#endregion
+//#region src/concerns/unique-ids.ts
+const UniqueIds = (Model$1) => {
+	return class extends Model$1 {
+		useUniqueIds = false;
+		usesUniqueIds() {
+			return this.useUniqueIds;
+		}
+		uniqueIds() {
+			return [];
+		}
+		newUniqueId() {
+			return null;
+		}
+		setUniqueIds() {
+			const uniqueIds = this.uniqueIds();
+			for (const column of uniqueIds) if (this[column] === null || this[column] === void 0) this[column] = this.newUniqueId();
+		}
+	};
+};
+var unique_ids_default = UniqueIds;
+
+//#endregion
+//#region src/paginator.ts
+var Paginator = class {
+	static formatter;
+	_items;
+	_total;
+	_perPage;
+	_lastPage;
+	_currentPage;
+	hasMore = false;
+	options = {};
+	static setFormatter(formatter) {
+		if (typeof formatter !== "function" && formatter !== null && formatter !== void 0) throw new Error("Paginator formatter must be a function or null");
+		this.formatter = formatter;
+	}
+	constructor(items, total, perPage, currentPage = 1, options = {}) {
+		this.options = options;
+		for (const key in options) this[key] = options[key];
+		this._items = new collection_default([]);
+		this._total = total;
+		this._perPage = parseInt(String(perPage));
+		this._lastPage = Math.max(Math.ceil(total / perPage), 1);
+		this._currentPage = currentPage;
+		this.setItems(items);
+	}
+	setItems(items) {
+		this._items = items instanceof collection_default ? items : new collection_default(items);
+		this.hasMore = this._items.count() > this._perPage;
+		this._items = this._items.slice(0, this._perPage);
+	}
+	firstItem() {
+		return this.count() > 0 ? (this._currentPage - 1) * this._perPage + 1 : null;
+	}
+	lastItem() {
+		return this.count() > 0 ? (this.firstItem() ?? 0) + this.count() - 1 : null;
+	}
+	hasMorePages() {
+		return this._currentPage < this._lastPage;
+	}
+	get(index) {
+		return this._items.get(index);
+	}
+	count() {
+		return this._items.count();
+	}
+	items() {
+		return this._items;
+	}
+	map(callback) {
+		return this._items.map(callback);
+	}
+	currentPage() {
+		return this._currentPage;
+	}
+	onFirstPage() {
+		return this._currentPage === 1;
+	}
+	perPage() {
+		return this._perPage;
+	}
+	lastPage() {
+		return this._lastPage;
+	}
+	total() {
+		return this._total;
+	}
+	toData() {
+		if (this.constructor.formatter && typeof this.constructor.formatter === "function") return this.constructor.formatter(this);
+		return {
+			current_page: this._currentPage,
+			data: this._items.toData(),
+			per_page: this._perPage,
+			total: this._total,
+			last_page: this._lastPage,
+			count: this.count()
+		};
+	}
+	toJSON() {
+		return this.toData();
+	}
+	toJson(...args) {
+		return JSON.stringify(this.toData(), ...args);
+	}
+};
+var paginator_default = Paginator;
+
+//#endregion
+//#region src/query-builder.ts
+const Inference$1 = class {};
+var QueryBuilder = class QueryBuilder extends Inference$1 {
+	model;
+	schema;
+	connector;
+	constructor(config, connector) {
+		super();
+		this.connector = connector(config);
+		return this.asProxy();
+	}
+	asProxy() {
+		return new Proxy(this, {
+			get: function(target, prop) {
+				if (typeof target[prop] !== "undefined") return target[prop];
+				if (["destroy", "schema"].includes(prop)) return target.connector.schema;
+				if ([
+					"select",
+					"from",
+					"where",
+					"orWhere",
+					"whereColumn",
+					"whereRaw",
+					"whereNot",
+					"orWhereNot",
+					"whereIn",
+					"orWhereIn",
+					"whereNotIn",
+					"orWhereNotIn",
+					"whereNull",
+					"orWhereNull",
+					"whereNotNull",
+					"orWhereNotNull",
+					"whereExists",
+					"orWhereExists",
+					"whereNotExists",
+					"orWhereNotExists",
+					"whereBetween",
+					"orWhereBetween",
+					"whereNotBetween",
+					"orWhereNotBetween",
+					"whereLike",
+					"orWhereLike",
+					"whereILike",
+					"orWhereILike",
+					"whereJsonObject",
+					"whereJsonPath",
+					"whereJsonSupersetOf",
+					"whereJsonSubsetOf",
+					"join",
+					"joinRaw",
+					"leftJoin",
+					"leftOuterJoin",
+					"rightJoin",
+					"rightOuterJoin",
+					"crossJoin",
+					"transacting",
+					"groupBy",
+					"groupByRaw",
+					"returning",
+					"having",
+					"havingRaw",
+					"havingBetween",
+					"limit",
+					"offset",
+					"orderBy",
+					"orderByRaw",
+					"union",
+					"insert",
+					"forUpdate",
+					"forShare",
+					"distinct",
+					"clearOrder",
+					"clear",
+					"clearSelect",
+					"clearWhere",
+					"clearHaving",
+					"clearGroup"
+				].includes(prop)) return (...args) => {
+					target.connector[prop](...args);
+					return target.asProxy();
+				};
+				return target.connector[prop];
+			},
+			set: function(target, prop, value) {
+				if (typeof target[prop] !== "undefined") {
+					target[prop] = value;
+					return target;
+				}
+				target.connector[prop] = value;
+				return target;
+			}
+		});
+	}
+	async beginTransaction() {
+		return await this.connector.transaction();
+	}
+	table(table) {
+		const c = this.connector.table(table);
+		return new QueryBuilder(null, () => c);
+	}
+	transaction(callback) {
+		if (callback) return this.connector.transaction((trx) => {
+			return callback(new QueryBuilder(null, () => trx));
+		});
+		return callback;
+	}
+	async find(id, columns = ["*"]) {
+		return await this.connector.where("id", id).first(...columns);
+	}
+	async get(_columns = ["*"]) {
+		return await this.connector;
+	}
+	async exists() {
+		return await this.connector.first() !== null;
+	}
+	skip(...args) {
+		return this.offset(...args);
+	}
+	take(...args) {
+		return this.limit(...args);
+	}
+	async chunk(count, callback) {
+		if (this.connector._statements.filter((item) => item.grouping === "order").length === 0) throw new Error("You must specify an orderBy clause when using this function.");
+		let page = 1;
+		let countResults;
+		do {
+			const results = await this.clone().forPage(page, count).get();
+			countResults = results.length;
+			if (countResults == 0) break;
+			if (await callback(results, page) === false) return false;
+			page++;
+		} while (countResults === count);
+		return true;
+	}
+	async paginate(page = 1, perPage = 15) {
+		const total = await this.clone().clearOrder().count("*");
+		let results;
+		if (total > 0) {
+			const skip = (page - 1) * perPage;
+			this.take(perPage).skip(skip);
+			results = await this.get();
+		} else results = [];
+		return new paginator_default(results, parseInt(total), perPage, page);
+	}
+	forPage(page = 1, perPage = 15) {
+		return this.offset((page - 1) * perPage).limit(perPage);
+	}
+	toSQL(...args) {
+		return this.connector.toSQL(...args);
+	}
+	async count(column) {
+		const [{ aggregate }] = await this.connector.count(column, { as: "aggregate" });
+		return Number(aggregate);
+	}
+	async min(column) {
+		const [{ aggregate }] = await this.connector.min(column, { as: "aggregate" });
+		return Number(aggregate);
+	}
+	async max(column) {
+		const [{ aggregate }] = await this.connector.max(column, { as: "aggregate" });
+		return Number(aggregate);
+	}
+	async sum(column) {
+		const [{ aggregate }] = await this.connector.sum(column, { as: "aggregate" });
+		return Number(aggregate);
+	}
+	async avg(column) {
+		const [{ aggregate }] = await this.connector.avg(column, { as: "aggregate" });
+		return Number(aggregate);
+	}
+	clone() {
+		const c = this.connector.clone();
+		return new QueryBuilder(null, () => c);
+	}
+	async delete() {
+		return await this.connector.delete();
+	}
+	async insert(...args) {
+		return await this.connector.insert(...args);
+	}
+	async update(...args) {
+		return await this.connector.update(...args);
+	}
+	destroy(...args) {
+		return this.connector.destroy(...args);
+	}
+	get _statements() {
+		return this.connector._statements;
+	}
+	get _single() {
+		return this.connector._single;
+	}
+	get from() {
+		return this.connector.from;
+	}
+};
+var query_builder_default = QueryBuilder;
+
+//#endregion
+//#region src/arquebus.ts
+var arquebus = class arquebus {
+	static connectorFactory = null;
+	static instance = null;
+	manager;
+	connections;
+	models;
+	constructor() {
+		this.manager = {};
+		this.connections = {};
+		this.models = {};
+	}
+	getConstructor() {
+		return this.constructor;
+	}
+	static getInstance() {
+		if (this.instance === null) this.instance = new arquebus();
+		return this.instance;
+	}
+	/**
+	* Initialize a new database connection 
+	* 
+	* @returns 
+	*/
+	static fire(connection = null) {
+		return this.getInstance().getConnection(connection);
+	}
+	/**
+	* Initialize a new database connection 
+	* 
+	* This is an alias of `arquebus.fire()` and will be removed in the future
+	* 
+	* @deprecated since version 0.3.0
+	* @alias fire
+	* 
+	* @returns 
+	*/
+	static connection(connection = null) {
+		return this.fire(connection);
+	}
+	static setConnectorFactory(connectorFactory) {
+		this.connectorFactory = connectorFactory;
+	}
+	static getConnectorFactory() {
+		return this.connectorFactory ?? knex.default;
+	}
+	static addConnection(config, name = "default") {
+		return this.getInstance().addConnection(config, name);
+	}
+	static beginTransaction(connection = null) {
+		return this.getInstance().beginTransaction(connection);
+	}
+	static transaction(callback, connection = null) {
+		return this.getInstance().transaction(callback, connection);
+	}
+	static table(name, connection = null) {
+		return this.getInstance().table(name, connection);
+	}
+	static schema(connection = null) {
+		return this.getInstance().schema(connection);
+	}
+	static async destroyAll() {
+		await this.getInstance().destroyAll();
+	}
+	static createModel(name, options) {
+		return this.getInstance().createModel(name, options);
+	}
+	connection(connection = null) {
+		return this.getConnection(connection);
+	}
+	getConnection(name = null) {
+		name = name || "default";
+		if (this.manager[name] === void 0) {
+			const queryBuilder = new query_builder_default(this.connections[name], arquebus.getConnectorFactory());
+			this.manager[name] = queryBuilder;
+		}
+		return this.manager[name];
+	}
+	addConnection(config, name = "default") {
+		this.connections[name] = {
+			...config,
+			connection: {
+				...config.connection,
+				dateStrings: true,
+				typeCast: function(field, next) {
+					if (field.type === "JSON") return field.string("utf8");
+					return next();
+				}
+			}
+		};
+	}
+	/**
+	* Autoload the config file
+	* 
+	* @param addConnection 
+	* @default true
+	* If set to `false` we will no attempt add the connection, we 
+	* will just go ahead and return the config
+	* 
+	* @returns 
+	*/
+	static async autoLoad(addConnection = true) {
+		let config;
+		const jsPath = path.default.resolve("arquebus.config.js");
+		const tsPath = path.default.resolve("arquebus.config.ts");
+		const instance = this.getInstance();
+		if ((0, fs.existsSync)(jsPath)) {
+			config = (await import(jsPath)).default;
+			if (addConnection) instance.addConnection(config, config.client);
+			return config;
+		}
+		if ((0, fs.existsSync)(tsPath)) if (process.env.NODE_ENV !== "production") {
+			config = (await import(tsPath)).default;
+			if (addConnection) instance.addConnection(config, config.client);
+			return config;
+		} else throw new Error("arquebus.config.ts found in production without build step");
+		return {};
+	}
+	beginTransaction(connection = null) {
+		return this.connection(connection).beginTransaction();
+	}
+	transaction(callback, connection = null) {
+		return this.connection(connection).transaction(callback);
+	}
+	table(name, connection = null) {
+		return this.connection(connection).table(name);
+	}
+	schema(connection = null) {
+		return this.connection(connection).schema;
+	}
+	async destroyAll() {
+		await Promise.all(Object.values(this.manager).map((connection) => {
+			return connection === null || connection === void 0 ? void 0 : connection.destroy();
+		}));
+	}
+	createModel(name, options = {}) {
+		let BaseModel$1 = Model;
+		if ("plugins" in options) BaseModel$1 = compose(BaseModel$1, ...options.plugins ?? []);
+		this.models = {
+			...this.models,
+			[name]: class extends BaseModel$1 {
+				table = (options === null || options === void 0 ? void 0 : options.table) ?? null;
+				connection = (options === null || options === void 0 ? void 0 : options.connection) ?? null;
+				timestamps = (options === null || options === void 0 ? void 0 : options.timestamps) ?? true;
+				primaryKey = (options === null || options === void 0 ? void 0 : options.primaryKey) ?? "id";
+				keyType = (options === null || options === void 0 ? void 0 : options.keyType) ?? "int";
+				incrementing = (options === null || options === void 0 ? void 0 : options.incrementing) ?? true;
+				with = (options === null || options === void 0 ? void 0 : options.with) ?? [];
+				casts = (options === null || options === void 0 ? void 0 : options.casts) ?? {};
+				static CREATED_AT = (options === null || options === void 0 ? void 0 : options.CREATED_AT) ?? "created_at";
+				static UPDATED_AT = (options === null || options === void 0 ? void 0 : options.UPDATED_AT) ?? "updated_at";
+				static DELETED_AT = (options === null || options === void 0 ? void 0 : options.DELETED_AT) ?? "deleted_at";
+			}
+		};
+		if ("attributes" in options) for (const attribute in options.attributes) {
+			if (options.attributes[attribute] instanceof attribute_default === false) throw new Error("Attribute must be an instance of \"Attribute\"");
+			this.models[name].prototype[getAttrMethod(attribute)] = () => {
+				var _options$attributes;
+				return (_options$attributes = options.attributes) === null || _options$attributes === void 0 ? void 0 : _options$attributes[attribute];
+			};
+		}
+		if ("relations" in options) for (const relation in options.relations) this.models[name].prototype[getRelationMethod(relation)] = function() {
+			var _options$relations;
+			return (_options$relations = options.relations) === null || _options$relations === void 0 ? void 0 : _options$relations[relation](this);
+		};
+		if ("scopes" in options) for (const scope in options.scopes) this.models[name].prototype[getScopeMethod(scope)] = options.scopes[scope];
+		this.models[name].setConnectionResolver(this);
+		return this.models[name];
+	}
+};
+var arquebus_default = arquebus;
+
+//#endregion
+//#region src/model.ts
+const BaseModel = compose(class {}, has_attributes_default, hides_attributes_default, has_relations_default, has_timestamps_default, has_hooks_default, has_global_scopes_default, unique_ids_default);
+var Model = class Model extends BaseModel {
+	primaryKey = "id";
+	builder = null;
+	table = null;
+	keyType = "int";
+	incrementing = true;
+	withCount = [];
+	perPage = 15;
+	static globalScopes = {};
+	static pluginInitializers = {};
+	static _booted = {};
+	static resolver;
+	connection = null;
+	eagerLoad = {};
+	exists = false;
+	with = [];
+	trx = null;
+	constructor(attributes = {}) {
+		super();
+		this.bootIfNotBooted();
+		this.initializePlugins();
+		this.syncOriginal();
+		this.fill(attributes);
+		return this.asProxy();
+	}
+	static query(trx = null) {
+		return new this().newQuery(trx);
+	}
+	static on(connection = null) {
+		const instance = new this();
+		instance.setConnection(connection);
+		return instance.newQuery();
+	}
+	static init(attributes = {}) {
+		return new this(attributes);
+	}
+	static extend(plugin, options) {
+		plugin(this, options);
+	}
+	static make(attributes = {}) {
+		const instance = new this();
+		for (const attribute in attributes) if (typeof instance[getRelationMethod(attribute)] !== "function") instance.setAttribute(attribute, attributes[attribute]);
+		else {
+			const relation = instance[getRelationMethod(attribute)]();
+			const related = relation.getRelated().constructor;
+			if (relation instanceof has_one_default || relation instanceof belongs_to_default) instance.setRelation(attribute, related.make(attributes[attribute]));
+			else if ((relation instanceof has_many_default || relation instanceof belongs_to_many_default) && Array.isArray(attributes[attribute])) instance.setRelation(attribute, new collection_default(attributes[attribute].map((item) => related.make(item))));
+		}
+		return instance;
+	}
+	getConstructor() {
+		return this.constructor;
+	}
+	bootIfNotBooted() {
+		if (this.constructor._booted[this.constructor.name] === void 0) {
+			this.constructor._booted[this.constructor.name] = true;
+			this.constructor.booting();
+			this.initialize();
+			this.constructor.boot();
+			this.constructor.booted();
+		}
+	}
+	static booting() {}
+	static boot() {}
+	static booted() {}
+	static setConnectionResolver(resolver) {
+		this.resolver = resolver;
+	}
+	initialize() {}
+	initializePlugins() {
+		if (typeof this.constructor.pluginInitializers[this.constructor.name] === "undefined") return;
+		for (const method of this.constructor.pluginInitializers[this.constructor.name]) this[method]();
+	}
+	addPluginInitializer(method) {
+		if (!this.constructor.pluginInitializers[this.constructor.name]) this.constructor.pluginInitializers[this.constructor.name] = [];
+		this.constructor.pluginInitializers[this.constructor.name].push(method);
+	}
+	newInstance(attributes = {}, exists = false) {
+		const model = new this.constructor();
+		model.exists = exists;
+		model.setConnection(this.getConnectionName());
+		model.setTable(this.getTable());
+		model.fill(attributes);
+		return model;
+	}
+	newFromBuilder(attributes = {}, connection = null) {
+		const model = this.newInstance({}, true);
+		model.setRawAttributes(attributes, true);
+		model.setConnection(connection || this.getConnectionName());
+		return model;
+	}
+	asProxy() {
+		return new Proxy(this, {
+			get: function(target, prop) {
+				if (target[prop] !== void 0) return target[prop];
+				if (typeof prop === "string") return target.getAttribute(prop);
+			},
+			set: function(target, prop, value) {
+				if (target[prop] !== void 0 && typeof target !== "function") {
+					target[prop] = value;
+					return target;
+				}
+				if (typeof prop === "string") return target.setAttribute(prop, value);
+				return target;
+			}
+		});
+	}
+	getKey() {
+		return this.getAttribute(this.getKeyName());
+	}
+	getKeyName() {
+		return this.primaryKey;
+	}
+	getForeignKey() {
+		return snakeCase(this.constructor.name) + "_" + this.getKeyName();
+	}
+	getConnectionName() {
+		return this.connection;
+	}
+	getTable() {
+		return this.table || (0, pluralize.default)(snakeCase(this.constructor.name));
+	}
+	getConnection() {
+		if (this.constructor.resolver) return this.constructor.resolver.getConnection(this.connection);
+		return arquebus_default.fire(this.connection);
+	}
+	setConnection(connection) {
+		this.connection = connection;
+		return this;
+	}
+	getKeyType() {
+		return this.keyType;
+	}
+	newQuery(trx = null) {
+		return this.addGlobalScopes(this.newQueryWithoutScopes(trx));
+	}
+	newQueryWithoutScopes(trx = null) {
+		return this.newModelQuery(trx).with(this.with).withCount(this.withCount);
+	}
+	newModelQuery(trx = null) {
+		return new builder_default(trx || this.getConnection()).setModel(this);
+	}
+	addGlobalScopes(builder) {
+		const globalScopes = this.getGlobalScopes();
+		for (const identifier in globalScopes) {
+			const scope = globalScopes[identifier];
+			builder.withGlobalScope(identifier, scope);
+		}
+		return builder;
+	}
+	hasNamedScope(name) {
+		const scope = getScopeMethod(name);
+		return typeof this[scope] === "function";
+	}
+	callNamedScope(scope, parameters) {
+		const scopeMethod = getScopeMethod(scope);
+		return this[scopeMethod](...parameters);
+	}
+	setTable(table) {
+		this.table = table;
+		return this;
+	}
+	newCollection(models = []) {
+		return new collection_default(models);
+	}
+	async load(...relations) {
+		await this.constructor.query().with(...relations).eagerLoadRelations([this]);
+		return this;
+	}
+	async loadAggregate(relations, column, callback = null) {
+		console.log(relations);
+		await new collection_default([this]).loadAggregate(relations, column, callback);
+		return this;
+	}
+	async loadCount(...relations) {
+		relations = flattenDeep(relations);
+		return await this.loadAggregate(relations, "*", "count");
+	}
+	async loadMax(relations, column) {
+		return await this.loadAggregate(relations, column, "max");
+	}
+	async loadMin(relations, column) {
+		return await this.loadAggregate(relations, column, "min");
+	}
+	async loadSum(relations, column) {
+		return await this.loadAggregate(relations, column, "sum");
+	}
+	async increment(column, amount = 1, extra = {}, options = {}) {
+		return await this.incrementOrDecrement(column, amount, extra, "increment", options);
+	}
+	async decrement(column, amount = 1, extra = {}, options = {}) {
+		return await this.incrementOrDecrement(column, amount, extra, "decrement", options);
+	}
+	async incrementOrDecrement(column, amount, extra, method, options) {
+		const query = this.newModelQuery(options.client);
+		if (!this.exists) return await query[method](column, amount, extra);
+		this.attributes[column] = this[column] + (method === "increment" ? amount : amount * -1);
+		for (const key in extra) this.attributes[key] = extra[key];
+		await this.execHooks("updating", options);
+		return await tap(await query.where(this.getKeyName(), this.getKey())[method](column, amount, extra), async () => {
+			this.syncChanges();
+			await this.execHooks("updated", options);
+			this.syncOriginalAttribute(column);
+		});
+	}
+	toData() {
+		return (0, radashi.assign)(this.attributesToData(), this.relationsToData());
+	}
+	toJSON() {
+		return this.toData();
+	}
+	toJson(...args) {
+		return JSON.stringify(this.toData(), ...args);
+	}
+	toString() {
+		return this.toJson();
+	}
+	fill(attributes) {
+		for (const key in attributes) this.setAttribute(key, attributes[key]);
+		return this;
+	}
+	transacting(trx) {
+		this.trx = trx;
+		return this;
+	}
+	trashed() {
+		return this[this.getDeletedAtColumn()] !== null;
+	}
+	getIncrementing() {
+		return this.incrementing;
+	}
+	setIncrementing(value) {
+		this.incrementing = value;
+		return this;
+	}
+	async save(options = {}) {
+		const query = this.newModelQuery(options.client);
+		let saved;
+		await this.execHooks("saving", options);
+		if (this.exists) if (this.isDirty() === false) saved = true;
+		else {
+			await this.execHooks("updating", options);
+			if (this.usesTimestamps()) this.updateTimestamps();
+			const dirty = this.getDirty();
+			if (Object.keys(dirty).length > 0) {
+				await query.where(this.getKeyName(), this.getKey()).query.update(dirty);
+				this.syncChanges();
+				await this.execHooks("updated", options);
+			}
+			saved = true;
+		}
+		else {
+			if (this.usesUniqueIds()) this.setUniqueIds();
+			await this.execHooks("creating", options);
+			if (this.usesTimestamps()) this.updateTimestamps();
+			const attributes = this.getAttributes();
+			if (this.getIncrementing()) {
+				var _data$;
+				const keyName = this.getKeyName();
+				const data = await query.insert([attributes], [keyName]);
+				this.setAttribute(keyName, ((_data$ = data[0]) === null || _data$ === void 0 ? void 0 : _data$[keyName]) || data[0]);
+			} else if (Object.keys(attributes).length > 0) await query.insert(attributes);
+			this.exists = true;
+			await this.execHooks("created", options);
+			saved = true;
+		}
+		if (saved) {
+			await this.execHooks("saved", options);
+			this.syncOriginal();
+		}
+		return saved;
+	}
+	async update(attributes = {}, options = {}) {
+		if (!this.exists) return false;
+		for (const key in attributes) this[key] = attributes[key];
+		return await this.save(options);
+	}
+	async delete(options = {}) {
+		await this.execHooks("deleting", options);
+		await this.performDeleteOnModel(options);
+		await this.execHooks("deleted", options);
+		return true;
+	}
+	async performDeleteOnModel(options = {}) {
+		await this.setKeysForSaveQuery(this.newModelQuery(options.client)).delete();
+		this.exists = false;
+	}
+	setKeysForSaveQuery(query) {
+		query.where(this.getKeyName(), "=", this.getKey());
+		return query;
+	}
+	async forceDelete(options = {}) {
+		return await this.delete(options);
+	}
+	fresh() {
+		if (!this.exists) return;
+		return this.constructor.query().where(this.getKeyName(), this.getKey()).first();
+	}
+	async refresh() {
+		if (!this.exists) return Promise.resolve(void 0);
+		this.attributes = { ...(await this.constructor.query().where(this.getKeyName(), this.getKey()).first()).attributes };
+		await this.load((0, collect_js.default)(this.relations).reject((relation) => {
+			return relation instanceof Pivot;
+		}).keys().all());
+		this.syncOriginal();
+		return this;
+	}
+	newPivot(parent, attributes, table, exists, using = null) {
+		return using ? using.fromRawAttributes(parent, attributes, table, exists) : Pivot.fromAttributes(parent, attributes, table, exists);
+	}
+	qualifyColumn(column) {
+		if (column.includes(".")) return column;
+		return `${this.getTable()}.${column}`;
+	}
+	getQualifiedKeyName() {
+		return this.qualifyColumn(this.getKeyName());
+	}
+	async push(options = {}) {
+		if (!await this.save(options)) return false;
+		for (const relation in this.relations) {
+			let models = this.relations[relation];
+			models = models instanceof collection_default ? models.all() : [models];
+			for (const model of models) if (!await model.push(options)) return false;
+		}
+		return true;
+	}
+	is(model) {
+		return model && model instanceof Model && this.getKey() === model.getKey() && this.getTable() === model.getTable() && this.getConnectionName() === model.getConnectionName();
+	}
+	isNot(model) {
+		return !this.is(model);
+	}
+};
+var Pivot = class extends Model {
+	incrementing = false;
+	guarded = [];
+	pivotParent = null;
+	foreignKey = null;
+	relatedKey = null;
+	setPivotKeys(foreignKey, relatedKey) {
+		this.foreignKey = foreignKey;
+		this.relatedKey = relatedKey;
+		return this;
+	}
+	static fromRawAttributes(parent, attributes, table, exists = false) {
+		const instance = this.fromAttributes(parent, {}, table, exists);
+		instance.timestamps = instance.hasTimestampAttributes(attributes);
+		instance.attributes = attributes;
+		instance.exists = exists;
+		return instance;
+	}
+	static fromAttributes(parent, attributes, table, exists = false) {
+		const instance = new this();
+		instance.timestamps = instance.hasTimestampAttributes(attributes);
+		instance.setConnection(parent.connection).setTable(table).fill(attributes).syncOriginal();
+		instance.pivotParent = parent;
+		instance.exists = exists;
+		return instance;
+	}
+	hasTimestampAttributes(attributes = null) {
+		return (attributes || this.attributes)[this.constructor.CREATED_AT] !== void 0;
+	}
+};
+var model_default = Model;
+
+//#endregion
+//#region src/collection.ts
+var Collection = class Collection extends collect_js.Collection {
+	newConstructor(...args) {
+		return new (this.getConstructor())(...args);
+	}
+	getConstructor() {
+		return this.constructor;
+	}
+	async load(...relations) {
+		if (this.isNotEmpty()) {
+			const items = await this.first().constructor.query().with(...relations).eagerLoadRelations(this.items);
+			return this.newConstructor(items);
+		}
+		return this;
+	}
+	async loadAggregate(relations, column, action = null) {
+		if (this.isEmpty()) return this;
+		const models = (await this.first().newModelQuery().whereIn(this.first().getKeyName(), this.modelKeys()).select(this.first().getKeyName()).withAggregate(relations, column, action).get()).keyBy(this.first().getKeyName());
+		const attributes = (0, radashi.diff)(Object.keys(models.first().getAttributes()), [models.first().getKeyName()]);
+		this.each((model) => {
+			const extraAttributes = (0, radashi.pick)(models.get(model.getKey()).getAttributes(), attributes);
+			model.fill(extraAttributes).syncOriginalAttributes(...attributes);
+		});
+		return this;
+	}
+	loadCount(relations) {
+		return this.loadAggregate(relations, "*", "count");
+	}
+	loadMax(relation, column) {
+		return this.loadAggregate(relation, column, "max");
+	}
+	loadMin(relation, column) {
+		return this.loadAggregate(relation, column, "min");
+	}
+	loadSum(relation, column) {
+		return this.loadAggregate(relation, column, "sum");
+	}
+	loadAvg(relation, column) {
+		return this.loadAggregate(relation, column, "avg");
+	}
+	mapThen(callback) {
+		return Promise.all(this.map(callback));
+	}
+	modelKeys() {
+		return this.all().map((item) => item.getKey());
+	}
+	contains(key, operator, value) {
+		if (arguments.length > 1) return super.contains(key, value ?? operator);
+		if (key instanceof model_default) return super.contains((model) => {
+			return model.is(key);
+		});
+		return super.contains((model) => {
+			return model.getKey() == key;
+		});
+	}
+	diff(items) {
+		const diff = new this.constructor();
+		const dictionary = this.getDictionary(items);
+		this.items.map((item) => {
+			if (dictionary[item.getKey()] === void 0) diff.add(item);
+		});
+		return diff;
+	}
+	except(keys) {
+		const dictionary = (0, radashi.omit)(this.getDictionary(), keys);
+		return new this.constructor(Object.values(dictionary));
+	}
+	intersect(items) {
+		const intersect = new this.constructor();
+		if ((0, radashi.isEmpty)(items)) return intersect;
+		const dictionary = this.getDictionary(items);
+		for (const item of this.items) if (dictionary[item.getKey()] !== void 0) intersect.add(item);
+		return intersect;
+	}
+	unique(key, _strict = false) {
+		if (key) return super.unique(key);
+		return new this.constructor(Object.values(this.getDictionary()));
+	}
+	find(key, defaultValue = null) {
+		if (key instanceof model_default) key = key.getKey();
+		if ((0, radashi.isArray)(key)) {
+			if (this.isEmpty()) return new this.constructor();
+			return this.whereIn(this.first().getKeyName(), key);
+		}
+		(0, collect_js.collect)(this.items).first((model) => {
+			return model.getKey() == key;
+		});
+		return this.items.filter((model) => {
+			return model.getKey() == key;
+		})[0] || defaultValue;
+	}
+	async fresh(...args) {
+		if (this.isEmpty()) return new this.constructor();
+		const model = this.first();
+		const freshModels = (await model.newQuery().with(...args).whereIn(model.getKeyName(), this.modelKeys()).get()).getDictionary();
+		return this.filter((model$1) => {
+			return model$1.exists && freshModels[model$1.getKey()] !== void 0;
+		}).map((model$1) => {
+			return freshModels[model$1.getKey()];
+		});
+	}
+	makeVisible(attributes) {
+		return this.each((item) => {
+			item.makeVisible(attributes);
+		});
+	}
+	makeHidden(attributes) {
+		return this.each((item) => {
+			item.makeHidden(attributes);
+		});
+	}
+	append(attributes) {
+		return this.each((item) => {
+			item.append(attributes);
+		});
+	}
+	only(keys) {
+		if (keys === null) return new Collection(this.items);
+		const dictionary = (0, radashi.pick)(this.getDictionary(), keys);
+		return new this.constructor(Object.values(dictionary));
+	}
+	getDictionary(items) {
+		items = !items ? this.items : items;
+		const dictionary = {};
+		items.map((value) => {
+			dictionary[value.getKey()] = value;
+		});
+		return dictionary;
+	}
+	toQuery() {
+		const model = this.first();
+		if (!model) throw new Error("Unable to create query for empty collection.");
+		const modelName = model.constructor.name;
+		if (this.filter((model$1) => {
+			return !(model$1 instanceof modelName);
+		}).isNotEmpty()) throw new Error("Unable to create query for collection with mixed types.");
+		return model.newModelQuery().whereKey(this.modelKeys());
+	}
+	toData() {
+		return this.all().map((item) => typeof item.toData == "function" ? item.toData() : item);
+	}
+	toJSON() {
+		return this.toData();
+	}
+	toJson(...args) {
+		return JSON.stringify(this.toData(), ...args);
+	}
+	[Symbol.iterator] = () => {
+		const items = this.items;
+		const length = this.items.length;
+		let n = 0;
+		return { next() {
+			return n < length ? {
+				value: items[n++],
+				done: false
+			} : { done: true };
+		} };
+	};
+};
+var collection_default = Collection;
+
+//#endregion
+//#region src/relations/concerns/interacts-with-pivot-table.ts
+const InteractsWithPivotTable = (Relation$1) => {
+	return class extends Relation$1 {
+		newExistingPivot(attributes = []) {
+			return this.newPivot(attributes, true);
+		}
+		newPivot(attributes = [], exists = false) {
+			return this.related.newPivot(this.parent, attributes, this.getTable(), exists, this.using).setPivotKeys(this.foreignPivotKey, this.relatedPivotKey);
+		}
+		async attach(id, attributes = {}, _touch = true) {
+			if (this.using) await this.attachUsingCustomClass(id, attributes);
+			else await this.newPivotStatement().insert(this.formatAttachRecords(this.parseIds(id), attributes));
+		}
+		async detach(ids, _touch = true) {
+			let results;
+			if (this.using && ids !== null && this.pivotWheres.length == 0 && this.pivotWhereIns.length == 0 && this.pivotWhereNulls.length == 0) results = await this.detachUsingCustomClass(ids);
+			else {
+				const query = this.newPivotQuery();
+				if (ids !== null) {
+					ids = this.parseIds(ids);
+					if (ids.length == 0) return 0;
+					query.whereIn(this.getQualifiedRelatedPivotKeyName(), ids);
+				}
+				results = await query.delete();
+			}
+			return results;
+		}
+		async sync(ids, detaching = true) {
+			let changes = {
+				attached: [],
+				detached: [],
+				updated: []
+			};
+			let records;
+			const results = await this.getCurrentlyAttachedPivots();
+			const current = results.length === 0 ? [] : results.map((result) => result.toData()).pluck(this.relatedPivotKey).all().map((i) => String(i));
+			const detach = (0, radashi.diff)(current, Object.keys(records = this.formatRecordsList(this.parseIds(ids))));
+			if (detaching && detach.length > 0) {
+				await this.detach(detach);
+				changes.detached = this.castKeys(detach);
+			}
+			changes = (0, radashi.assign)(changes, await this.attachNew(records, current, false));
+			return changes;
+		}
+		syncWithoutDetaching(ids) {
+			return this.sync(ids, false);
+		}
+		syncWithPivotValues(ids, values, detaching = true) {
+			return this.sync((0, collect_js.collect)(this.parseIds(ids)).mapWithKeys((id) => {
+				return [id, values];
+			}), detaching);
+		}
+		withPivot(columns) {
+			this.pivotColumns = this.pivotColumns.concat((0, radashi.isArray)(columns) ? columns : Array.prototype.slice.call(columns));
+			return this;
+		}
+		async attachNew(records, current, touch = true) {
+			const changes = {
+				attached: [],
+				updated: []
+			};
+			for (const id in records) {
+				const attributes = records[id];
+				if (!current.includes(id)) {
+					await this.attach(id, attributes, touch);
+					changes.attached.push(this.castKey(id));
+				} else if (Object.keys(attributes).length > 0 && await this.updateExistingPivot(id, attributes, touch)) changes.updated.push(this.castKey(id));
+			}
+			return changes;
+		}
+		async updateExistingPivot(id, attributes, touch = true) {
+			if (this.using && this.pivotWheres.length > 0 && this.pivotWhereInspivotWheres.length > 0 && this.pivotWhereNullspivotWheres.length > 0) return await this.updateExistingPivotUsingCustomClass(id, attributes, touch);
+			if (this.hasPivotColumn(this.updatedAt())) attributes = this.addTimestampsToAttachment(attributes, true);
+			return this.newPivotStatementForId(this.parseId(id)).update(this.castAttributes(attributes));
+		}
+		addTimestampsToAttachment(record, exists = false) {
+			let fresh = this.parent.freshTimestamp();
+			if (this.using) fresh = new this.using().fromDateTime(fresh);
+			if (!exists && this.hasPivotColumn(this.createdAt())) record[this.createdAt()] = fresh;
+			if (this.hasPivotColumn(this.updatedAt())) record[this.updatedAt()] = fresh;
+			return record;
+		}
+		async updateExistingPivotUsingCustomClass(id, attributes, _touch) {
+			const pivot = await this.getCurrentlyAttachedPivots().where(this.foreignPivotKey, this.parent[this.parentKey]).where(this.relatedPivotKey, this.parseId(id)).first();
+			const updated = pivot ? pivot.fill(attributes).isDirty() : false;
+			if (updated) await pivot.save();
+			return parseInt(updated);
+		}
+		formatRecordsList(records) {
+			return (0, collect_js.collect)(records).mapWithKeys((attributes, id) => {
+				if (!(0, radashi.isArray)(attributes)) [id, attributes] = [attributes, {}];
+				return [id, attributes];
+			}).all();
+		}
+		async getCurrentlyAttachedPivots() {
+			return (await this.newPivotQuery().get()).map((record) => {
+				return (this.using || Pivot).fromRawAttributes(this.parent, record, this.getTable(), true).setPivotKeys(this.foreignPivotKey, this.relatedPivotKey);
+			});
+		}
+		castKeys(keys) {
+			return keys.map((v) => {
+				return this.castKey(v);
+			});
+		}
+		castKey(key) {
+			return this.getTypeSwapValue(this.related.getKeyType(), key);
+		}
+		getTypeSwapValue(type, value) {
+			switch (type.toLowerCase()) {
+				case "int":
+				case "integer": return parseInt(value);
+				case "real":
+				case "float":
+				case "double": return parseFloat(value);
+				case "string": return String(value);
+				default: return value;
+			}
+		}
+		newPivotQuery() {
+			const query = this.newPivotStatement();
+			this.pivotWheres.map((args) => {
+				query.where(...args);
+			});
+			this.pivotWhereIns.map((args) => {
+				query.whereIn(...args);
+			});
+			this.pivotWhereNulls.map((args) => {
+				query.whereNull(...args);
+			});
+			return query.where(this.getQualifiedForeignPivotKeyName(), this.parent[this.parentKey]);
+		}
+		async detachUsingCustomClass(ids) {
+			let results = 0;
+			for (const id in this.parseIds(ids)) results += await this.newPivot({
+				[this.foreignPivotKey]: this.parent[this.parentKey],
+				[this.relatedPivotKey]: id
+			}, true).delete();
+			return results;
+		}
+		newPivotStatement() {
+			const builder = this.parent.newQuery();
+			builder.setTable(this.table);
+			return builder;
+		}
+		async attachUsingCustomClass(id, attributes) {
+			const records = this.formatAttachRecords(this.parseIds(id), attributes);
+			await Promise.all(records.map(async (record) => {
+				await this.newPivot(record, false).save();
+			}));
+		}
+		formatAttachRecords(ids, attributes) {
+			const records = [];
+			const hasTimestamps = this.hasPivotColumn(this.createdAt()) || this.hasPivotColumn(this.updatedAt());
+			for (const key in ids) {
+				const value = ids[key];
+				records.push(this.formatAttachRecord(key, value, attributes, hasTimestamps));
+			}
+			return records;
+		}
+		formatAttachRecord(key, value, attributes, hasTimestamps) {
+			const [id, newAttributes] = this.extractAttachIdAndAttributes(key, value, attributes);
+			return (0, radashi.assign)(this.baseAttachRecord(id, hasTimestamps), newAttributes);
+		}
+		baseAttachRecord(id, timed) {
+			let record = {};
+			record[this.relatedPivotKey] = id;
+			record[this.foreignPivotKey] = this.parent[this.parentKey];
+			if (timed) record = this.addTimestampsToAttachment(record);
+			this.pivotValues.map((value) => {
+				record[value.column] = value.value;
+			});
+			return record;
+		}
+		extractAttachIdAndAttributes(key, value, newAttributes) {
+			return (0, radashi.isArray)(value) ? [key, {
+				...value,
+				...newAttributes
+			}] : [value, newAttributes];
+		}
+		hasPivotColumn(column) {
+			return this.pivotColumns.includes(column);
+		}
+		parseIds(value) {
+			if (value instanceof Model) return [value[this.relatedKey]];
+			if (value instanceof collection_default) return value.pluck(this.relatedKey).all();
+			return (0, radashi.isArray)(value) ? value : [value];
+		}
+	};
+};
+var interacts_with_pivot_table_default = InteractsWithPivotTable;
+
+//#endregion
+//#region src/relations/belongs-to-many.ts
+var BelongsToMany = class extends compose(relation_default, interacts_with_pivot_table_default) {
+	table;
+	foreignPivotKey;
+	relatedPivotKey;
+	parentKey;
+	relatedKey;
+	pivotColumns = [];
+	pivotValues = [];
+	pivotWheres = [];
+	pivotWhereIns = [];
+	pivotWhereNulls = [];
+	accessor = "pivot";
+	using;
+	pivotCreatedAt;
+	pivotUpdatedAt;
+	constructor(query, parent, table, foreignPivotKey, relatedPivotKey, parentKey, relatedKey) {
+		super(query, parent);
+		this.table = table;
+		this.foreignPivotKey = foreignPivotKey;
+		this.relatedPivotKey = relatedPivotKey;
+		this.parentKey = parentKey;
+		this.relatedKey = relatedKey;
+		this.addConstraints();
+		return this.asProxy();
+	}
+	initRelation(models, relation) {
+		models.map((model) => {
+			model.setRelation(relation, new collection_default([]));
+		});
+		return models;
+	}
+	addConstraints() {
+		this.performJoin();
+		if (this.constructor.constraints) this.addWhereConstraints();
+	}
+	performJoin(query = null) {
+		query = query || this.query;
+		query.join(this.getTable(), this.getQualifiedRelatedKeyName(), "=", this.qualifyPivotColumn(this.relatedPivotKey));
+		return this;
+	}
+	getTable() {
+		return this.table;
+	}
+	getQualifiedRelatedKeyName() {
+		return this.related.qualifyColumn(this.relatedKey);
+	}
+	async getResults() {
+		return this.parent[this.parentKey] !== null ? await this.get() : new collection_default([]);
+	}
+	addWhereConstraints() {
+		this.query.where(this.getQualifiedForeignPivotKeyName(), "=", this.parent[this.parentKey]);
+		return this;
+	}
+	async get(columns) {
+		var _builder$query;
+		const builder = this.query.applyScopes();
+		columns = ((_builder$query = builder.query) === null || _builder$query === void 0 || (_builder$query = _builder$query._statements) === null || _builder$query === void 0 ? void 0 : _builder$query.find((item) => item.grouping == "columns")) ? [] : columns;
+		let models = await builder.select(this.shouldSelect(columns)).getModels();
+		this.hydratePivotRelation(models);
+		if (models.length > 0) models = await builder.eagerLoadRelations(models);
+		return new collection_default(models);
+	}
+	async first(columns = ["*"]) {
+		const results = await this.take(1).get(columns);
+		return results.count() > 0 ? results.first() : null;
+	}
+	async firstOrFail(columns = ["*"]) {
+		const model = await this.first(columns);
+		if (model !== null) return model;
+		throw new ModelNotFoundError().setModel(this.related.constructor);
+	}
+	async paginate(page = 1, perPage = 15, columns = ["*"]) {
+		this.query.select(this.shouldSelect(columns));
+		return tap(await this.query.paginate(page, perPage), (paginator) => {
+			this.hydratePivotRelation(paginator.items());
+		});
+	}
+	async chunk(count, callback) {
+		return await this.prepareQueryBuilder().chunk(count, async (results, page) => {
+			this.hydratePivotRelation(results.all());
+			return await callback(results, page);
+		});
+	}
+	setUsing(model) {
+		this.using = model;
+		return this;
+	}
+	as(accessor) {
+		this.accessor = accessor;
+		return this;
+	}
+	prepareQueryBuilder() {
+		return this.query.select(this.shouldSelect());
+	}
+	hydratePivotRelation(models) {
+		models.map((model) => {
+			model.setRelation(this.accessor, this.newExistingPivot(this.migratePivotAttributes(model)));
+		});
+	}
+	migratePivotAttributes(model) {
+		const values = {};
+		for (const key in model.attributes) {
+			const value = model.attributes[key];
+			if (key.startsWith("pivot_")) {
+				values[key.substring(6)] = value;
+				model.attributes = (0, radashi.omit)(model.attributes, [key]);
+			}
+		}
+		return values;
+	}
+	withTimestamps(createdAt = null, updatedAt = null) {
+		this.pivotCreatedAt = createdAt;
+		this.pivotUpdatedAt = updatedAt;
+		return this.withPivot(this.createdAt(), this.updatedAt());
+	}
+	shouldSelect(columns = ["*"]) {
+		if ((0, radashi.isEqual)(columns, ["*"])) columns = [this.related.getTable() + ".*"];
+		return columns.concat(this.aliasedPivotColumns());
+	}
+	aliasedPivotColumns() {
+		const defaults = [this.foreignPivotKey, this.relatedPivotKey];
+		return (0, collect_js.collect)(defaults.concat(this.pivotColumns)).map((column) => {
+			return this.qualifyPivotColumn(column) + " as pivot_" + column;
+		}).unique().all();
+	}
+	qualifyPivotColumn(column) {
+		return column.includes(".") ? column : this.getTable() + "." + column;
+	}
+	match(models, results, relation) {
+		const dictionary = this.buildDictionary(results);
+		models.map((model) => {
+			const key = model.getKey();
+			if (dictionary[key] !== void 0) model.setRelation(relation, dictionary[key]);
+		});
+		return models;
+	}
+	buildDictionary(results) {
+		const dictionary = {};
+		results.map((result) => {
+			const value = result[this.accessor][this.foreignPivotKey];
+			if (dictionary[value] === void 0) dictionary[value] = new collection_default([]);
+			dictionary[value].push(result);
+		});
+		return dictionary;
+	}
+	addEagerConstraints(models) {
+		this.query.whereIn(this.getQualifiedForeignPivotKeyName(), this.getKeys(models, this.parentKey));
+	}
+	getQualifiedForeignPivotKeyName() {
+		return this.qualifyPivotColumn(this.foreignPivotKey);
+	}
+	getQualifiedRelatedPivotKeyName() {
+		return this.qualifyPivotColumn(this.relatedPivotKey);
+	}
+	wherePivot(column, operator = null, value = null, boolean = "and") {
+		this.pivotWheres.push(Array.prototype.slice.call(arguments));
+		return this.where(this.qualifyPivotColumn(column), operator, value, boolean);
+	}
+	wherePivotBetween(column, values, boolean = "and", not = false) {
+		return this.whereBetween(this.qualifyPivotColumn(column), values, boolean, not);
+	}
+	orWherePivotBetween(column, values) {
+		return this.wherePivotBetween(column, values, "or");
+	}
+	wherePivotNotBetween(column, values, boolean = "and") {
+		return this.wherePivotBetween(column, values, boolean, true);
+	}
+	orWherePivotNotBetween(column, values) {
+		return this.wherePivotBetween(column, values, "or", true);
+	}
+	wherePivotIn(column, values, boolean = "and", not = false) {
+		return this.whereIn(this.qualifyPivotColumn(column), values, boolean, not);
+	}
+	orWherePivot(column, operator = null, value = null) {
+		return this.wherePivot(column, operator, value, "or");
+	}
+	orWherePivotIn(column, values) {
+		return this.wherePivotIn(column, values, "or");
+	}
+	wherePivotNotIn(column, values, boolean = "and") {
+		return this.wherePivotIn(column, values, boolean, true);
+	}
+	orWherePivotNotIn(column, values) {
+		return this.wherePivotNotIn(column, values, "or");
+	}
+	wherePivotNull(column, boolean = "and", not = false) {
+		return this.whereNull(this.qualifyPivotColumn(column), boolean, not);
+	}
+	wherePivotNotNull(column, boolean = "and") {
+		return this.wherePivotNull(column, boolean, true);
+	}
+	orWherePivotNull(column, not = false) {
+		return this.wherePivotNull(column, "or", not);
+	}
+	orWherePivotNotNull(column) {
+		return this.orWherePivotNull(column, true);
+	}
+	orderByPivot(column, direction = "asc") {
+		return this.orderBy(this.qualifyPivotColumn(column), direction);
+	}
+	createdAt() {
+		return this.pivotCreatedAt || this.parent.getCreatedAtColumn();
+	}
+	updatedAt() {
+		return this.pivotUpdatedAt || this.parent.getUpdatedAtColumn();
+	}
+	getExistenceCompareKey() {
+		return this.getQualifiedForeignPivotKeyName();
+	}
+	getRelationExistenceQuery(query, parentQuery, columns = ["*"]) {
+		if (parentQuery.getQuery()._single.table == query.getQuery()._single.table) return this.getRelationExistenceQueryForSelfJoin(query, parentQuery, columns);
+		this.performJoin(query);
+		return super.getRelationExistenceQuery(query, parentQuery, columns);
+	}
+	getRelationExistenceQueryForSelfJoin(query, parentQuery, columns = ["*"]) {
+		const hash = this.getRelationCountHash();
+		query.select(columns).from(this.related.getTable() + " as " + hash);
+		this.related.setTable(hash);
+		this.performJoin(query);
+		return super.getRelationExistenceQuery(query, parentQuery, columns);
+	}
+};
+var belongs_to_many_default = BelongsToMany;
+
+//#endregion
+//#region src/builder.ts
+const Inference = class {};
+var Builder = class Builder extends Inference {
+	query;
+	connection;
+	model;
+	actions;
+	localMacros = {};
+	eagerLoad = {};
+	globalScopes = {};
+	onDeleteCallback;
+	constructor(query) {
+		super();
+		this.query = query;
+		return this.asProxy();
+	}
+	asProxy() {
+		return new Proxy(this, { get(target, prop) {
+			if (typeof target[prop] !== "undefined") return target[prop];
+			if ([
+				"select",
+				"from",
+				"where",
+				"orWhere",
+				"whereColumn",
+				"whereRaw",
+				"whereNot",
+				"orWhereNot",
+				"whereIn",
+				"orWhereIn",
+				"whereNotIn",
+				"orWhereNotIn",
+				"whereNull",
+				"orWhereNull",
+				"whereNotNull",
+				"orWhereNotNull",
+				"whereExists",
+				"orWhereExists",
+				"whereNotExists",
+				"orWhereNotExists",
+				"whereBetween",
+				"orWhereBetween",
+				"whereNotBetween",
+				"orWhereNotBetween",
+				"whereLike",
+				"orWhereLike",
+				"whereILike",
+				"orWhereILike",
+				"whereJsonObject",
+				"whereJsonPath",
+				"whereJsonSupersetOf",
+				"whereJsonSubsetOf",
+				"join",
+				"joinRaw",
+				"leftJoin",
+				"leftOuterJoin",
+				"rightJoin",
+				"rightOuterJoin",
+				"crossJoin",
+				"transacting",
+				"groupBy",
+				"groupByRaw",
+				"returning",
+				"having",
+				"havingRaw",
+				"havingBetween",
+				"limit",
+				"offset",
+				"orderBy",
+				"orderByRaw",
+				"union",
+				"insert",
+				"forUpdate",
+				"forShare",
+				"distinct",
+				"clearOrder",
+				"clear",
+				"clearSelect",
+				"clearWhere",
+				"clearHaving",
+				"clearGroup"
+			].includes(prop)) return (...args) => {
+				target.query[prop](...args);
+				return target.asProxy();
+			};
+			if ([
+				"avg",
+				"max",
+				"min",
+				"sum",
+				"count"
+			].includes(prop)) return (column) => {
+				const instance = target.asProxy();
+				instance.applyScopes();
+				column = !column && prop === "count" ? "*" : column;
+				return instance.query[prop](column);
+			};
+			if (typeof prop === "string") {
+				if (target.hasMacro(prop)) {
+					const instance = target.asProxy();
+					return (...args) => {
+						return instance.localMacros[prop](instance, ...args);
+					};
+				}
+				if (target.hasNamedScope(prop)) {
+					const instance = target.asProxy();
+					return (...args) => {
+						instance.callNamedScope(prop, args);
+						return instance;
+					};
+				}
+				if (prop.startsWith("where")) {
+					const column = (0, radashi.snake)(prop.substring(5));
+					return (...args) => {
+						target.query.where(column, ...args);
+						return target.asProxy();
+					};
+				}
+			}
+		} });
+	}
+	orWhere(...args) {
+		if (typeof args[0] === "function") {
+			const callback = args[0];
+			this.query.orWhere((query) => {
+				this.query = query;
+				callback(this);
+			});
+			return this;
+		}
+		this.query.orWhere(...args);
+		return this;
+	}
+	async chunk(count, callback) {
+		let page = 1;
+		let countResults;
+		do {
+			this.enforceOrderBy();
+			const results = await this.clone().forPage(page, count).get();
+			countResults = results.count();
+			if (countResults == 0) break;
+			if (await callback(results, page) === false) return false;
+			page++;
+		} while (countResults === count);
+		return true;
+	}
+	enforceOrderBy() {
+		if (this.query._statements.filter((item) => item.grouping === "order").length === 0) this.orderBy(this.model.getQualifiedKeyName(), "asc");
+	}
+	clone() {
+		const query = this.query.clone();
+		const builder = new this.constructor(query);
+		builder.connection = this.connection;
+		builder.setModel(this.model);
+		builder.globalScopes = { ...this.globalScopes };
+		builder.localMacros = { ...this.localMacros };
+		builder.eagerLoad = { ...this.eagerLoad };
+		return builder;
+	}
+	forPage(page, perPage = 15) {
+		return this.offset((page - 1) * perPage).limit(perPage);
+	}
+	insert(...args) {
+		return this.query.insert(...args);
+	}
+	update(values) {
+		this.applyScopes();
+		return this.query.update(this.addUpdatedAtColumn(values));
+	}
+	increment(column, amount = 1, extra = {}) {
+		this.applyScopes();
+		const db = this.model.getConnection();
+		return this.query.update(this.addUpdatedAtColumn({
+			...extra,
+			[column]: db.raw(`${column} + ${amount}`)
+		}));
+	}
+	decrement(column, amount = 1, extra = {}) {
+		this.applyScopes();
+		const db = this.model.getConnection();
+		return this.query.update(this.addUpdatedAtColumn({
+			...extra,
+			[column]: db.raw(`${column} - ${amount}`)
+		}));
+	}
+	addUpdatedAtColumn(values) {
+		if (!this.model.usesTimestamps() || this.model.getUpdatedAtColumn() === null) return values;
+		const column = this.model.getUpdatedAtColumn();
+		values = (0, radashi.assign)({ [column]: this.model.freshTimestampString() }, values);
+		return values;
+	}
+	delete() {
+		if (this.onDeleteCallback) return this.onDeleteCallback(this);
+		return this.query.delete();
+	}
+	onDelete(callback) {
+		this.onDeleteCallback = callback;
+	}
+	forceDelete() {
+		return this.query.delete();
+	}
+	async create(attributes = {}) {
+		return await tap(this.newModelInstance(attributes), async (instance) => {
+			await instance.save({ client: this.query });
+		});
+	}
+	newModelInstance(attributes = {}) {
+		return this.model.newInstance(attributes).setConnection(this.model.getConnectionName());
+	}
+	getQuery() {
+		return this.query;
+	}
+	getModel() {
+		return this.model;
+	}
+	setModel(model) {
+		var _this$query;
+		this.model = model;
+		if (typeof ((_this$query = this.query) === null || _this$query === void 0 || (_this$query = _this$query.client) === null || _this$query === void 0 ? void 0 : _this$query.table) == "function") this.query = this.query.client.table(this.model.getTable());
+		else this.query = this.query.table(this.model.getTable());
+		return this;
+	}
+	qualifyColumn(column) {
+		return this.model.qualifyColumn(column);
+	}
+	setTable(table) {
+		this.query = this.query.table(table);
+		return this;
+	}
+	applyScopes() {
+		if (!this.globalScopes) return this;
+		for (const identifier in this.globalScopes) {
+			const scope = this.globalScopes[identifier];
+			if (scope instanceof scope_default) scope.apply(this, this.getModel());
+			else scope(this);
+		}
+		return this;
+	}
+	hasNamedScope(name) {
+		return this.model && this.model.hasNamedScope(name);
+	}
+	callNamedScope(scope, parameters) {
+		return this.model.callNamedScope(scope, [this, ...parameters]);
+	}
+	callScope(scope, parameters = []) {
+		return scope(this, ...parameters) || this;
+	}
+	scopes(scopes) {
+		scopes.map((scopeName) => {
+			const scopeMethod = getScopeMethod(scopeName);
+			if (typeof this.model[scopeMethod] === "function") this.globalScopes[scopeName] = this.model[scopeMethod];
+		});
+		return this;
+	}
+	withGlobalScope(identifier, scope) {
+		this.globalScopes[identifier] = scope;
+		if (typeof scope.extend === "function") scope.extend(this);
+		return this;
+	}
+	withoutGlobalScope(scope) {
+		if (typeof scope !== "string") scope = scope.constructor.name;
+		this.globalScopes = (0, radashi.omit)(this.globalScopes, [scope]);
+		return this;
+	}
+	macro(name, callback) {
+		this.localMacros[name] = callback;
+		return this;
+	}
+	hasMacro(name) {
+		return name in this.localMacros;
+	}
+	getMacro(name) {
+		return this.localMacros[name];
+	}
+	with(...args) {
+		let eagerLoads = {};
+		if (typeof args[1] === "function") {
+			const eagerLoad = this.parseWithRelations({ [args[0]]: args[1] });
+			this.eagerLoad = (0, radashi.assign)(this.eagerLoad, eagerLoad);
+			return this;
+		}
+		const relations = flattenDeep(args);
+		if (relations.length === 0) return this;
+		for (const relation of relations) {
+			let eagerLoad;
+			if (typeof relation === "string") eagerLoad = { [relation]: (q) => q };
+			else if (typeof relation === "object") eagerLoad = relation;
+			eagerLoads = (0, radashi.assign)(eagerLoads, eagerLoad);
+		}
+		this.eagerLoad = (0, radashi.assign)(this.eagerLoad, this.parseWithRelations(eagerLoads));
+		return this;
+	}
+	has(relation, operator = ">=", count = 1, boolean = "and", callback = null) {
+		if ((0, radashi.isString)(relation)) {
+			if (relation.includes(".")) return this.hasNested(relation, operator, count, boolean, callback);
+			relation = this.getRelationWithoutConstraints(getRelationMethod(relation));
+		}
+		const method = this.canUseExistsForExistenceCheck(operator, count) ? "getRelationExistenceQuery" : "getRelationExistenceCountQuery";
+		const hasQuery = relation[method](relation.getRelated().newModelQuery(), this);
+		if (callback) callback(hasQuery);
+		return this.addHasWhere(hasQuery, relation, operator, count, boolean);
+	}
+	orHas(relation, operator = ">=", count = 1) {
+		return this.has(relation, operator, count, "or");
+	}
+	doesntHave(relation, boolean = "and", callback = null) {
+		return this.has(relation, "<", 1, boolean, callback);
+	}
+	orDoesntHave(relation) {
+		return this.doesntHave(relation, "or");
+	}
+	whereHas(relation, callback = null, operator = ">=", count = 1) {
+		return this.has(relation, operator, count, "and", callback);
+	}
+	orWhereHas(relation, callback = null, operator = ">=", count = 1) {
+		return this.has(relation, operator, count, "or", callback);
+	}
+	whereRelation(relation, ...args) {
+		const column = args.shift();
+		return this.whereHas(relation, (query) => {
+			if (typeof column === "function") column(query);
+			else query.where(column, ...args);
+		});
+	}
+	orWhereRelation(relation, ...args) {
+		const column = args.shift();
+		return this.orWhereHas(relation, function(query) {
+			if (typeof column === "function") column(query);
+			else query.where(column, ...args);
+		});
+	}
+	hasNested(relations, operator = ">=", count = 1, boolean = "and", callback = null) {
+		relations = relations.split(".");
+		const doesntHave = operator === "<" && count === 1;
+		if (doesntHave) {
+			operator = ">=";
+			count = 1;
+		}
+		const closure = (q) => {
+			if (relations.length > 1) q.whereHas(relations.shift(), closure);
+			else q.has(relations.shift(), operator, count, "and", callback);
+			return null;
+		};
+		return this.has(relations.shift(), doesntHave ? "<" : ">=", 1, boolean, closure);
+	}
+	canUseExistsForExistenceCheck(operator, count) {
+		return (operator === ">=" || operator === "<") && count === 1;
+	}
+	addHasWhere(hasQuery, relation, operator, count, boolean) {
+		hasQuery.mergeConstraintsFrom(relation.getQuery());
+		return this.canUseExistsForExistenceCheck(operator, count) ? this.addWhereExistsQuery(hasQuery.getQuery(), boolean, operator === "<" && count === 1) : this.addWhereCountQuery(hasQuery.getQuery(), operator, count, boolean);
+	}
+	addWhereExistsQuery(query, boolean = "and", not = false) {
+		const type = not ? "NotExists" : "Exists";
+		const method = boolean === "and" ? "where" + type : "orWhere" + type;
+		this[method](query.connector);
+		return this;
+	}
+	addWhereCountQuery(query, operator = ">=", count = 1, boolean = "and") {
+		const db = this.model.getConnection();
+		return this.where(db.raw("(" + query.toSQL().sql + ")"), operator, typeof count === "number" ? db.raw(count) : count, boolean);
+	}
+	withAggregate(relations, column, action = null) {
+		if (relations.length === 0) return this;
+		relations = flattenDeep([relations]);
+		let eagerLoads = {};
+		for (const relation of relations) {
+			let eagerLoad;
+			if (typeof relation === "string") eagerLoad = { [relation]: (q) => q };
+			else if (typeof relation === "object") eagerLoad = relation;
+			eagerLoads = (0, radashi.assign)(eagerLoads, eagerLoad);
+		}
+		relations = eagerLoads;
+		const db = this.model.getConnection();
+		if (this.query._statements.filter((item) => item.grouping == "columns").map((item) => item.value).flat().length === 0) this.query.select([this.query._single.table + ".*"]);
+		const parses = this.parseWithRelations(relations);
+		for (let name in parses) {
+			const constraints = parses[name];
+			const segments = name.split(" ");
+			let alias, expression;
+			if (segments.length === 3 && segments[1].toLocaleLowerCase() === "as") [name, alias] = [segments[0], segments[2]];
+			const relation = this.getRelationWithoutConstraints(getRelationMethod(name));
+			if (action) {
+				const hashedColumn = this.query._single.table === relation.query.query._single.table ? `${relation.getRelationCountHash(false)}.${column}` : column;
+				const wrappedColumn = column === "*" ? column : relation.getRelated().qualifyColumn(hashedColumn);
+				expression = action === "exists" ? wrappedColumn : `${action}(${wrappedColumn})`;
+			} else expression = column;
+			const query = relation.getRelationExistenceQuery(relation.getRelated().newModelQuery(), this, db.raw(expression));
+			constraints(query);
+			alias = alias || (0, radashi.snake)(`${name} ${action} ${column}`.replace("/[^[:alnum:][:space:]_]/u", ""));
+			if (action === "exists") this.select(db.raw(`exists(${query.toSql().sql}) as ${alias}`));
+			else this.selectSub(action ? query : query.limit(1), alias);
+		}
+		return this;
+	}
+	toSql() {
+		const query = this.clone();
+		query.applyScopes();
+		return query.query.toSQL();
+	}
+	mergeConstraintsFrom(_from) {
+		return this;
+	}
+	selectSub(query, as) {
+		const [querySub, bindings] = this.createSub(query);
+		const db = this.model.getConnection();
+		return this.select(db.raw("(" + querySub + ") as " + as, bindings));
+	}
+	createSub(query) {
+		return this.parseSub(query);
+	}
+	parseSub(query) {
+		if (query instanceof Builder || query instanceof relation_default) return [query.toSql().sql, query.toSql().bindings];
+		else if ((0, radashi.isString)(query)) return [query, []];
+		else throw new Error("A subquery must be a query builder instance, a Closure, or a string.");
+	}
+	prependDatabaseNameIfCrossDatabaseQuery(query) {
+		if (query.query._single.table !== this.query._single.table) {
+			const databaseName = query.query._single.table;
+			if (!query.query._single.table.startsWith(databaseName) && !query.query._single.table.contains(".")) query.from(databaseName + "." + query.from);
+		}
+		return query;
+	}
+	getRelationWithoutConstraints(relation) {
+		return relation_default.noConstraints(() => {
+			return this.getModel()[relation]();
+		});
+	}
+	withCount(...args) {
+		return this.withAggregate(flattenDeep(args), "*", "count");
+	}
+	withMax(relation, column) {
+		return this.withAggregate(relation, column, "max");
+	}
+	withMin(relation, column) {
+		return this.withAggregate(relation, column, "min");
+	}
+	withAvg(relation, column) {
+		return this.withAggregate(relation, column, "avg");
+	}
+	withSum(relation, column) {
+		return this.withAggregate(relation, column, "sum");
+	}
+	withExists(relation) {
+		return this.withAggregate(relation, "*", "exists");
+	}
+	parseWithRelations(relations) {
+		if (relations.length === 0) return [];
+		let results = {};
+		const constraintsMap = this.prepareNestedWithRelationships(relations);
+		for (const name in constraintsMap) {
+			results = this.addNestedWiths(name, results);
+			results[name] = constraintsMap[name];
+		}
+		return results;
+	}
+	addNestedWiths(name, results) {
+		const progress = [];
+		name.split(".").map((segment) => {
+			progress.push(segment);
+			const last = progress.join(".");
+			if (results[last] === void 0) results[last] = () => {};
+		});
+		return results;
+	}
+	prepareNestedWithRelationships(relations, prefix = "") {
+		let preparedRelationships = {};
+		if (prefix !== "") prefix += ".";
+		for (const key in relations) {
+			const value = relations[key];
+			if ((0, radashi.isString)(value) || Number.isFinite(parseInt(value))) continue;
+			const [attribute, attributeSelectConstraint] = this.parseNameAndAttributeSelectionConstraint(key, value);
+			preparedRelationships = Object.assign({}, preparedRelationships, { [`${prefix}${attribute}`]: attributeSelectConstraint }, this.prepareNestedWithRelationships(value, `${prefix}${attribute}`));
+			relations = (0, radashi.omit)(relations, [key]);
+		}
+		for (const key in relations) {
+			const value = relations[key];
+			let attribute = key, attributeSelectConstraint = value;
+			if ((0, radashi.isString)(value)) [attribute, attributeSelectConstraint] = this.parseNameAndAttributeSelectionConstraint(value);
+			preparedRelationships[`${prefix}${attribute}`] = this.combineConstraints([attributeSelectConstraint, preparedRelationships[`${prefix}${attribute}`] || (() => {})]);
+		}
+		return preparedRelationships;
+	}
+	combineConstraints(constraints) {
+		return (builder) => {
+			constraints.map((constraint) => {
+				builder = constraint(builder) || builder;
+			});
+			return builder;
+		};
+	}
+	parseNameAndAttributeSelectionConstraint(name, value) {
+		return name.includes(":") ? this.createSelectWithConstraint(name) : [name, value];
+	}
+	createSelectWithConstraint(name) {
+		return [name.split(":")[0], (query) => {
+			query.select(name.split(":")[1].split(",").map((column) => {
+				if (column.includes(".")) return column;
+				return query instanceof belongs_to_many_default ? query.related.getTable() + "." + column : column;
+			}));
+		}];
+	}
+	related(relation) {
+		if (typeof this.model[getRelationMethod(relation)] !== "function") {
+			const message = `Model [${this.model.constructor.name}]'s relation [${relation}] doesn't exist.`;
+			throw new RelationNotFoundError(message);
+		}
+		return this.model[getRelationMethod(relation)]();
+	}
+	take(...args) {
+		return this.limit(...args);
+	}
+	skip(...args) {
+		return this.offset(...args);
+	}
+	async first(...columns) {
+		this.applyScopes();
+		this.limit(1);
+		let models = await this.getModels(columns);
+		if (models.length > 0) models = await this.eagerLoadRelations(models);
+		return models[0] || null;
+	}
+	async firstOrFail(...columns) {
+		const data = await this.first(...columns);
+		if (data === null) throw new ModelNotFoundError().setModel(this.model.constructor.name);
+		return data;
+	}
+	async findOrFail(...args) {
+		const data = await this.find(...args);
+		if ((0, radashi.isArray)(args[0])) {
+			if (data.count() !== args[0].length) throw new ModelNotFoundError().setModel(this.model.constructor.name, (0, radashi.diff)(args[0], data.modelKeys()));
+			return data;
+		}
+		if (data === null) throw new ModelNotFoundError().setModel(this.model.constructor.name, args[0]);
+		return data;
+	}
+	async findOrNew(id, columns = ["*"]) {
+		const model = await this.find(id, columns);
+		if (model !== null) return model;
+		return this.newModelInstance();
+	}
+	async firstOrNew(attributes = {}, values = {}) {
+		const instance = await this.where(attributes).first();
+		if (instance !== null) return instance;
+		return this.newModelInstance((0, radashi.assign)(attributes, values));
+	}
+	async firstOrCreate(attributes = {}, values = {}) {
+		const instance = await this.where(attributes).first();
+		if (instance !== null) return instance;
+		return tap(this.newModelInstance((0, radashi.assign)(attributes, values)), async (instance$1) => {
+			await instance$1.save({ client: this.query });
+		});
+	}
+	async updateOrCreate(attributes, values = {}) {
+		return await tap(await this.firstOrNew(attributes), async (instance) => {
+			await instance.fill(values).save({ client: this.query });
+		});
+	}
+	latest(column = "id") {
+		if (column === null) column = this.model.getCreatedAtColumn() || "created_at";
+		this.query.orderBy(column, "desc");
+		return this;
+	}
+	oldest(column = "id") {
+		if (column === null) column = this.model.getCreatedAtColumn() || "created_at";
+		this.query.orderBy(column, "asc");
+		return this;
+	}
+	async find(id, columns) {
+		if ((0, radashi.isArray)(id) || id instanceof collection_default) return await this.findMany(id, columns);
+		return await this.where(this.model.getKeyName(), id).first(columns);
+	}
+	async findMany(ids, columns = ["*"]) {
+		if (ids instanceof collection_default) ids = ids.modelKeys();
+		ids = (0, radashi.isArray)(ids) ? ids : [ids];
+		if (ids.length === 0) return new collection_default([]);
+		return await this.whereIn(this.model.getKeyName(), ids).get(columns);
+	}
+	async pluck(column) {
+		const data = await this.query.pluck(column);
+		return new collection_default(data);
+	}
+	async destroy(ids) {
+		if (ids instanceof collection_default) ids = ids.modelKeys();
+		if (ids instanceof collect_js.Collection) ids = ids.all();
+		ids = (0, radashi.isArray)(ids) ? ids : Array.prototype.slice.call(ids);
+		if (ids.length === 0) return 0;
+		const key = this.model.newInstance().getKeyName();
+		let count = 0;
+		const models = await this.model.newModelQuery().whereIn(key, ids).get();
+		for (const model of models) if (await model.delete()) count++;
+		return count;
+	}
+	async get(columns = ["*"]) {
+		this.applyScopes();
+		let models = await this.getModels(columns);
+		if (models.length > 0) models = await this.eagerLoadRelations(models);
+		return new collection_default(models);
+	}
+	async all(columns = ["*"]) {
+		return await this.model.newModelQuery().get(columns);
+	}
+	async paginate(page = 1, perPage = 10) {
+		var _this;
+		page = page || 1;
+		perPage = perPage || ((_this = this) === null || _this === void 0 || (_this = _this.model) === null || _this === void 0 ? void 0 : _this.perPage) || 15;
+		this.applyScopes();
+		const total = await this.query.clone().clearOrder().clearSelect().count(this.primaryKey);
+		let results = [];
+		if (total > 0) {
+			const skip = (page - 1) * (perPage ?? 10);
+			this.take(perPage).skip(skip);
+			results = await this.getModels();
+			if (results.length > 0) results = await this.eagerLoadRelations(results);
+		} else results = [];
+		return new paginator_default(results, parseInt(total), perPage, page);
+	}
+	async getModels(...columns) {
+		columns = (0, radashi.flat)(columns);
+		if (columns.length > 0) {
+			if (this.query._statements.filter((item) => item.grouping == "columns").length == 0 && columns[0] !== "*") this.query.select(...columns);
+		}
+		return this.hydrate(await this.query.get()).all();
+	}
+	getRelation(name) {
+		if (typeof this.model[getRelationMethod(name)] !== "function") {
+			const message = `Model [${this.model.constructor.name}]'s relation [${name}] doesn't exist.`;
+			throw new RelationNotFoundError(message);
+		}
+		const relation = relation_default.noConstraints(() => this.model.newInstance(this.model.attributes)[getRelationMethod(name)]());
+		const nested = this.relationsNestedUnder(name);
+		if (Object.keys(nested).length > 0) relation.query.with(nested);
+		return relation.asProxy();
+	}
+	relationsNestedUnder(relation) {
+		const nested = {};
+		for (const name in this.eagerLoad) {
+			const constraints = this.eagerLoad[name];
+			if (this.isNestedUnder(relation, name)) nested[name.substring((relation + ".").length)] = constraints;
+		}
+		return nested;
+	}
+	isNestedUnder(relation, name) {
+		return name.includes(".") && name.startsWith(relation + ".");
+	}
+	async eagerLoadRelation(models, name, constraints) {
+		const relation = this.getRelation(name);
+		relation.addEagerConstraints(models);
+		constraints(relation);
+		return relation.match(relation.initRelation(models, name), await relation.get(), name);
+	}
+	async eagerLoadRelations(models) {
+		for (const name in this.eagerLoad) {
+			const constraints = this.eagerLoad[name];
+			if (!name.includes(".")) models = await this.eagerLoadRelation(models, name, constraints);
+		}
+		return models;
+	}
+	hydrate(items) {
+		return new collection_default(items.map((item) => {
+			if (!this.model) return item;
+			return this.model.newFromBuilder(item);
+		}));
+	}
+};
+var builder_default = Builder;
+
+//#endregion
+//#region src/cli/utils.ts
+const join = path.default.join;
+
+//#endregion
+//#region src/inspector/dialects/sqlite.ts
+function parseDefaultValue(value) {
+	if (value === null || value.trim().toLowerCase() === "null") return null;
+	return stripQuotes(value);
+}
+var SQLite = class {
+	knex;
+	constructor(knex$1) {
+		this.knex = knex$1;
+	}
+	/**
+	* List all existing tables in the current schema/database
+	*/
+	async tables() {
+		return (await this.knex.select("name").from("sqlite_master").whereRaw("type = 'table' AND name NOT LIKE 'sqlite_%'")).map(({ name }) => name);
+	}
+	async tableInfo(table) {
+		const query = this.knex.select("name", "sql").from("sqlite_master").where({ type: "table" }).andWhereRaw("name NOT LIKE 'sqlite_%'");
+		if (table) query.andWhere({ name: table });
+		let records = await query;
+		records = records.map((table$1) => ({
+			name: table$1.name,
+			sql: table$1.sql
+		}));
+		if (table) return records[0];
+		return records;
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasTable(table) {
+		return (await this.knex.select(1).from("sqlite_master").where({
+			type: "table",
+			name: table
+		})).length > 0;
+	}
+	/**
+	* Get all the available columns in the current schema/database. Can be filtered to a specific table
+	*/
+	async columns(table) {
+		if (table) return (await this.knex.raw("PRAGMA table_xinfo(??)", table)).map((column) => ({
+			table,
+			column: column.name
+		}));
+		const tables = await this.tables();
+		const columnsPerTable = await Promise.all(tables.map(async (table$1) => await this.columns(table$1)));
+		return flatten(columnsPerTable);
+	}
+	async columnInfo(table, column) {
+		const getColumnsForTable = async (table$1) => {
+			const tablesWithAutoIncrementPrimaryKeys = (await this.knex.select("name").from("sqlite_master").whereRaw("sql LIKE '%AUTOINCREMENT%'")).map(({ name }) => name);
+			const columns = await this.knex.raw("PRAGMA table_xinfo(??)", table$1);
+			const foreignKeys = await this.knex.raw("PRAGMA foreign_key_list(??)", table$1);
+			const indexList = await this.knex.raw("PRAGMA index_list(??)", table$1);
+			const indexInfoList = await Promise.all(indexList.map((index) => this.knex.raw("PRAGMA index_info(??)", index.name)));
+			return columns.map((raw) => {
+				const foreignKey = foreignKeys.find((fk) => fk.from === raw.name);
+				const indexIndex = indexInfoList.findIndex((list) => list.find((fk) => fk.name === raw.name));
+				const index = indexList[indexIndex];
+				const indexInfo = indexInfoList[indexIndex];
+				return {
+					name: raw.name,
+					table: table$1,
+					data_type: extractType(raw.type),
+					default_value: parseDefaultValue(raw.dflt_value),
+					max_length: extractMaxLength(raw.type),
+					numeric_precision: null,
+					numeric_scale: null,
+					is_generated: raw.hidden !== 0,
+					generation_expression: null,
+					is_nullable: raw.notnull === 0,
+					is_unique: !!(index === null || index === void 0 ? void 0 : index.unique) && (indexInfo === null || indexInfo === void 0 ? void 0 : indexInfo.length) === 1,
+					is_primary_key: raw.pk === 1,
+					has_auto_increment: raw.pk === 1 && tablesWithAutoIncrementPrimaryKeys.includes(table$1),
+					foreign_key_column: (foreignKey === null || foreignKey === void 0 ? void 0 : foreignKey.to) || null,
+					foreign_key_table: (foreignKey === null || foreignKey === void 0 ? void 0 : foreignKey.table) || null
+				};
+			});
+		};
+		if (!table) {
+			const tables = await this.tables();
+			const columnsPerTable = await Promise.all(tables.map(async (table$1) => await getColumnsForTable(table$1)));
+			return flatten(columnsPerTable);
+		}
+		if (table && !column) return await getColumnsForTable(table);
+		return (await getColumnsForTable(table)).find((columnInfo) => columnInfo.name === column);
+	}
+	/**
+	* Check if a table exists in the current schema/database
+	*/
+	async hasColumn(table, column) {
+		let isColumn = false;
+		if ((await this.knex.raw(`SELECT COUNT(*) AS ct FROM pragma_table_xinfo('${table}') WHERE name='${column}'`))[0]["ct"] !== 0) isColumn = true;
+		return isColumn;
+	}
+	/**
+	* Get the primary key column for the given table
+	*/
+	async primary(table) {
+		const pkColumns = (await this.knex.raw("PRAGMA table_xinfo(??)", table)).filter((col) => col.pk !== 0);
+		return pkColumns.length > 0 ? pkColumns.length === 1 ? pkColumns[0].name : pkColumns.map((col) => col.name) : null;
+	}
+	async foreignKeys(table) {
+		if (table) return (await this.knex.raw("PRAGMA foreign_key_list(??)", table)).map((key) => ({
+			table,
+			column: key.from,
+			foreign_key_table: key.table,
+			foreign_key_column: key.to,
+			on_update: key.on_update,
+			on_delete: key.on_delete,
+			constraint_name: null
+		}));
+		const tables = await this.tables();
+		const keysPerTable = await Promise.all(tables.map(async (table$1) => await this.foreignKeys(table$1)));
+		return flatten(keysPerTable);
+	}
+	async uniqueConstraints(table) {
+		if (table) {
+			const indexList = await this.knex.raw("PRAGMA index_list(??)", table);
+			const indexInfoList = await Promise.all(indexList.map((index) => this.knex.raw("PRAGMA index_info(??)", index.name)));
+			return indexList.filter((i) => i.unique).map((index, i) => {
+				const info = indexInfoList[i];
+				return {
+					table,
+					constraint_name: index.name,
+					columns: info.map((c) => c.name)
+				};
+			});
+		}
+		const tables = await this.tables();
+		const constraintsPerTable = await Promise.all(tables.map(async (table$1) => await this.uniqueConstraints(table$1)));
+		return flatten(constraintsPerTable);
+	}
+};
+
+//#endregion
+//#region src/inspector/index.ts
+var SchemaInspector = class {
+	static inspect(knex$1) {
+		let constructor;
+		switch (knex$1.client.constructor.name) {
+			case "Client_MySQL":
+			case "Client_MySQL2":
+				constructor = MySQL;
+				break;
+			case "Client_PG":
+				constructor = Postgres;
+				break;
+			case "Client_CockroachDB":
+				constructor = CockroachDB;
+				break;
+			case "Client_SQLite3":
+			case "Client_BetterSQLite3":
+				constructor = SQLite;
+				break;
+			case "Client_Oracledb":
+			case "Client_Oracle":
+				constructor = oracleDB;
+				break;
+			case "Client_MSSQL":
+				constructor = MSSQL;
+				break;
+			default: throw Error("Unsupported driver used: " + knex$1.client.constructor.name);
+		}
+		return new constructor(knex$1);
+	}
+};
+
+//#endregion
+exports.SchemaInspector = SchemaInspector;