@h3ravel/arquebus 0.6.5 → 0.6.7

package/dist/inspector/index.js

@@ -1,4932 +0,0 @@
-import "node:module";
-import { assign, camel, diff, flat, get, isArray, isEmpty, isEqual, isString, omit, pick, set, snake, trim } from "radashi";
-import advancedFormat from "dayjs/plugin/advancedFormat.js";
-import dayjs from "dayjs";
-import collect$1, { Collection, collect } from "collect.js";
-import Knex$1 from "knex";
-import path from "path";
-import { existsSync } from "fs";
-import { access } from "fs/promises";
-import escalade from "escalade/sync";
-import resolveFrom from "resolve-from";
-import pluralize from "pluralize";
-import "@h3ravel/shared";
-import "node:fs/promises";
-import "node:path";
-import "node:url";
-
-//#region rolldown:runtime
-var __defProp = Object.defineProperty;
-var __export = (all) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	return target;
-};
-
-//#endregion
-//#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) {
-		this.knex = knex;
-		const config = knex.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 } = 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.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.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) {
-		this.knex = knex;
-	}
-	/**
-	* 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) {
-		this.knex = knex;
-	}
-	/**
-	* 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 } = this;
-		const query = knex.select("stat.table_name AS table_name", "stat.index_name AS constraint_name", knex.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.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) {
-		this.knex = knex;
-	}
-	/**
-	* 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) {
-		this.knex = knex;
-		const config = knex.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 } = 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.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.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 } = this;
-		const schemaIn = this.explodedSchema.map((schemaName) => `${this.knex.raw("?", [schemaName])}::regnamespace`);
-		const bindings = [];
-		if (table) bindings.push(table);
-		return (await knex.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 = 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.extend(advancedFormat);
-const getRelationName = (relationMethod) => {
-	return snake(relationMethod.substring(8));
-};
-const getRelationMethod = (relation) => {
-	return camel(`relation_${relation}`);
-};
-const getScopeMethod = (scope) => {
-	return camel(`scope_${scope}`);
-};
-const getAttrMethod = (attr) => {
-	return camel(`attribute_${attr}`);
-};
-const getGetterMethod = (attr) => {
-	return camel(`get_${attr}_attribute`);
-};
-const getSetterMethod = (attr) => {
-	return 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) => trim(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 collect$1(JSON.parse(value));
-				} catch {
-					return collect$1([]);
-				}
-				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 = omit(attributes, [key]);
-				if (this.visible.length > 0 && this.visible.includes(key) === false) attributes = 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] = dayjs(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 ? dayjs(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 = flat(types);
-				return types.length > 0 ? types.includes(this.getCastType(key)) : true;
-			}
-			return false;
-		}
-		withDayjs(date) {
-			return dayjs(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 dayjs(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 dayjs(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 = set(this.globalScopes ?? {}, this.name + "." + scope, implementation);
-				return implementation;
-			} else if (scope instanceof scope_default) {
-				this.globalScopes = 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 get(this.globalScopes, this.name + "." + scope);
-			return get(this.globalScopes, this.name + "." + scope.constructor.name);
-		}
-		static getAllGlobalScopes() {
-			return this.globalScopes;
-		}
-		static setAllGlobalScopes(scopes) {
-			this.globalScopes = scopes;
-		}
-		getGlobalScopes() {
-			return 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 collect$1(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 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 (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 ?? 15, 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 = 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 = 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 [];
-		}
-		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");
-		if (!formatter) return;
-		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) {
-				var _target$connector$cli;
-				if (typeof target[prop] !== "undefined") return target[prop];
-				if (["destroy", "schema"].includes(prop)) return target.connector.schema;
-				const skipReturning = !!((_target$connector$cli = target.connector.client.config) === null || _target$connector$cli === void 0 || (_target$connector$cli = _target$connector$cli.client) === null || _target$connector$cli === void 0 ? void 0 : _target$connector$cli.includes("mysql")) && prop === "returning";
-				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) && !skipReturning) 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, _pageName, _page) {
-		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/cli/utils.ts
-const join = path.join;
-var Utils = class {
-	/**
-	* Wraps text with chalk
-	*
-	* @param txt
-	* @param color
-	* @returns
-	*/
-	static textFormat(txt, color) {
-		return String(txt).split(":").map((e, i, a) => i == 0 && a.length > 1 ? color(" " + e + ": ") : e).join("");
-	}
-	static findModulePkg(moduleId, cwd) {
-		const parts = moduleId.replace(/\\/g, "/").split("/");
-		let packageName = "";
-		if (parts.length > 0 && parts[0][0] === "@") packageName += parts.shift() + "/";
-		packageName += parts.shift();
-		const packageJson = path.join(packageName, "package.json");
-		const resolved = resolveFrom.silent(cwd ?? process.cwd(), packageJson);
-		if (!resolved) return;
-		return path.join(path.dirname(resolved), parts.join("/"));
-	}
-	static async getMigrationPaths(cwd, migrator, defaultPath, path$1) {
-		if (path$1) return [join(cwd, path$1)];
-		return [...migrator.getPaths(), join(cwd, defaultPath)];
-	}
-	/**
-	* Check if file exists
-	*
-	* @param path
-	* @returns
-	*/
-	static async fileExists(path$1) {
-		try {
-			await access(path$1);
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	static findUpConfig(cwd, name, extensions) {
-		return escalade(cwd, (_dir, names) => {
-			for (const ext of extensions) {
-				const filename = `${name}.${ext}`;
-				if (names.includes(filename)) return filename;
-			}
-			return false;
-		});
-	}
-};
-
-//#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$1;
-	}
-	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";
-		const resolvedName = this.connections[name] ? name : "default";
-		if (this.manager[resolvedName] === void 0) {
-			const queryBuilder = new query_builder_default(this.connections[resolvedName], arquebus.getConnectorFactory());
-			this.manager[resolvedName] = queryBuilder;
-		}
-		return this.manager[resolvedName];
-	}
-	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.resolve("arquebus.config.js");
-		const tsPath = path.resolve("arquebus.config.ts");
-		const instance = this.getInstance();
-		if (existsSync(jsPath)) {
-			config = (await import(jsPath)).default;
-			if (addConnection) instance.addConnection(config, config.client);
-			return config;
-		}
-		if (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");
-		const candidateDirs = [
-			process.cwd(),
-			path.join(process.cwd(), "test", "cli"),
-			path.join(process.cwd(), "test")
-		];
-		for (const dir of candidateDirs) {
-			const found = Utils.findUpConfig(dir, "arquebus.config", [
-				"js",
-				"ts",
-				"cjs"
-			]);
-			if (found) if (!found.endsWith(".ts") || process.env.NODE_ENV !== "production") {
-				config = (await import(found)).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 ModelClass = class {};
-const BaseModel = compose(ModelClass, 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 {
-	builder = null;
-	table = null;
-	keyType = "int";
-	incrementing = true;
-	withCount = [];
-	primaryKey = "id";
-	perPage = 15;
-	static globalScopes = {};
-	static pluginInitializers = {};
-	static _booted = {};
-	static resolver;
-	connection = null;
-	eagerLoad = {};
-	exists = false;
-	with = [];
-	name;
-	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 || pluralize(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 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(collect$1(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$1 = class Collection$1 extends 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 = diff(Object.keys(models.first().getAttributes()), [models.first().getKeyName()]);
-		this.each((model) => {
-			const extraAttributes = 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$1 = new this.constructor();
-		const dictionary = this.getDictionary(items);
-		this.items.map((item) => {
-			if (dictionary[item.getKey()] === void 0) diff$1.add(item);
-		});
-		return diff$1;
-	}
-	except(keys) {
-		const dictionary = omit(this.getDictionary(), keys);
-		return new this.constructor(Object.values(dictionary));
-	}
-	intersect(items) {
-		const intersect = new this.constructor();
-		if (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 (isArray(key)) {
-			if (this.isEmpty()) return new this.constructor();
-			return this.whereIn(this.first().getKeyName(), key);
-		}
-		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$1(this.items);
-		const dictionary = 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$1;
-
-//#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 = 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 = 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(collect(this.parseIds(ids)).mapWithKeys((id) => {
-				return [id, values];
-			}), detaching);
-		}
-		withPivot(columns) {
-			this.pivotColumns = this.pivotColumns.concat(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 collect(records).mapWithKeys((attributes, id) => {
-				if (!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 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 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 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 = 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 (isEqual(columns, ["*"])) columns = [this.related.getTable() + ".*"];
-		return columns.concat(this.aliasedPivotColumns());
-	}
-	aliasedPivotColumns() {
-		const defaults = [this.foreignPivotKey, this.relatedPivotKey];
-		return 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) {
-			var _target$query$connect;
-			if (typeof target[prop] !== "undefined") return target[prop];
-			const skipReturning = !!((_target$query$connect = target.query.connector) === null || _target$query$connect === void 0 || (_target$query$connect = _target$query$connect.client.config) === null || _target$query$connect === void 0 || (_target$query$connect = _target$query$connect.client) === null || _target$query$connect === void 0 ? void 0 : _target$query$connect.includes("mysql")) && prop === "returning";
-			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) && !skipReturning) 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 = 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 = 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 = 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 = 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 = assign(eagerLoads, eagerLoad);
-		}
-		this.eagerLoad = assign(this.eagerLoad, this.parseWithRelations(eagerLoads));
-		return this;
-	}
-	has(relation, operator = ">=", count = 1, boolean = "and", callback = null) {
-		if (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 = 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 || 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 (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 (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 = omit(relations, [key]);
-		}
-		for (const key in relations) {
-			const value = relations[key];
-			let attribute = key, attributeSelectConstraint = value;
-			if (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 (isArray(args[0])) {
-			if (data.count() !== args[0].length) throw new ModelNotFoundError().setModel(this.model.constructor.name, 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(assign(attributes, values));
-	}
-	async firstOrCreate(attributes = {}, values = {}) {
-		const instance = await this.where(attributes).first();
-		if (instance !== null) return instance;
-		return tap(this.newModelInstance(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 (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 = 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 Collection) ids = ids.all();
-		ids = 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 = 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/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) {
-		this.knex = knex;
-	}
-	/**
-	* 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) {
-		let constructor;
-		switch (knex.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.client.constructor.name);
-		}
-		return new constructor(knex);
-	}
-};
-
-//#endregion
-export { SchemaInspector };