@azlib/cms 0.5.0 → 0.6.0

package/dist/index.cjs

@@ -1,4 +1,28 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let exceljs = require("exceljs");
+exceljs = __toESM(exceljs, 1);
 //#region src/content/schema.ts
 const fields = {
 	text(options) {
@@ -2857,7 +2881,7 @@ var EcommerceService = class {
 };
 //#endregion
 //#region src/plugins/ecommerce/routes.ts
-function json$1(data, status = 200) {
+function json$2(data, status = 200) {
 	return new Response(JSON.stringify(data), {
 		status,
 		headers: {
@@ -2866,11 +2890,11 @@ function json$1(data, status = 200) {
 		}
 	});
 }
-function badRequest$1(message) {
-	return json$1({ error: message }, 400);
+function badRequest$2(message) {
+	return json$2({ error: message }, 400);
 }
-function notFound$1(message) {
-	return json$1({ error: message }, 404);
+function notFound$2(message) {
+	return json$2({ error: message }, 404);
 }
 function registerEcommerceRoutes(ctx, service, options = {}) {
 	const prefix = (options.apiPrefix ?? "/api/ecommerce").replace(/\/+$/, "");
@@ -2893,7 +2917,7 @@ function registerEcommerceRoutes(ctx, service, options = {}) {
 			const offsetStr = url.searchParams.get("offset");
 			const limit = limitStr ? parseInt(limitStr, 10) : 20;
 			const offset = offsetStr ? parseInt(offsetStr, 10) : 0;
-			return json$1(await service.listProducts({
+			return json$2(await service.listProducts({
 				categorySlug,
 				categoryId,
 				tagSlug,
@@ -2909,7 +2933,7 @@ function registerEcommerceRoutes(ctx, service, options = {}) {
 				offset
 			}));
 		} catch (err) {
-			return badRequest$1(err instanceof Error ? err.message : String(err));
+			return badRequest$2(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("GET", `${prefix}/products/:id`, async (_req, { params, url }) => {
@@ -2921,32 +2945,32 @@ function registerEcommerceRoutes(ctx, service, options = {}) {
 			product = await service.getProduct(id);
 			if (!product) product = await service.getProductBySlug(id);
 		}
-		if (!product) return notFound$1(`Product '${id}' not found`);
-		return json$1(product);
+		if (!product) return notFound$2(`Product '${id}' not found`);
+		return json$2(product);
 	});
 	ctx.registerRoute("POST", `${prefix}/products`, async (req) => {
 		try {
 			const body = await req.json();
-			if (!body.title) return badRequest$1("Product 'title' is required.");
-			if (body.price === void 0 || body.price < 0) return badRequest$1("Valid product 'price' is required.");
-			return json$1(await service.createProduct(body), 201);
+			if (!body.title) return badRequest$2("Product 'title' is required.");
+			if (body.price === void 0 || body.price < 0) return badRequest$2("Valid product 'price' is required.");
+			return json$2(await service.createProduct(body), 201);
 		} catch (err) {
-			return badRequest$1(err instanceof Error ? err.message : String(err));
+			return badRequest$2(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("PUT", `${prefix}/products/:id`, async (req, { params }) => {
 		try {
 			const body = await req.json();
 			const updated = await service.updateProduct(params.id, body);
-			if (!updated) return notFound$1(`Product '${params.id}' not found.`);
-			return json$1(updated);
+			if (!updated) return notFound$2(`Product '${params.id}' not found.`);
+			return json$2(updated);
 		} catch (err) {
-			return badRequest$1(err instanceof Error ? err.message : String(err));
+			return badRequest$2(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("DELETE", `${prefix}/products/:id`, async (_req, { params }) => {
-		if (!await service.deleteProduct(params.id)) return notFound$1(`Product '${params.id}' not found.`);
-		return json$1({
+		if (!await service.deleteProduct(params.id)) return notFound$2(`Product '${params.id}' not found.`);
+		return json$2({
 			success: true,
 			id: params.id
 		});
@@ -2954,8 +2978,8 @@ function registerEcommerceRoutes(ctx, service, options = {}) {
 	ctx.registerRoute("POST", `${prefix}/products/:id/images`, async (req, { params }) => {
 		try {
 			const body = await req.json();
-			if (!body.filename || !body.mimeType) return badRequest$1("'filename' and 'mimeType' are required.");
-			return json$1(await service.uploadProductImage(params.id, {
+			if (!body.filename || !body.mimeType) return badRequest$2("'filename' and 'mimeType' are required.");
+			return json$2(await service.uploadProductImage(params.id, {
 				filename: body.filename,
 				mimeType: body.mimeType,
 				sizeBytes: body.sizeBytes ?? 0,
@@ -2967,68 +2991,68 @@ function registerEcommerceRoutes(ctx, service, options = {}) {
 				isFeatured: body.isFeatured
 			}), 201);
 		} catch (err) {
-			return badRequest$1(err instanceof Error ? err.message : String(err));
+			return badRequest$2(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("GET", `${prefix}/categories`, async (_req, { url }) => {
 		try {
-			if (url.searchParams.get("tree") === "true") return json$1(await service.getCategoryTree());
+			if (url.searchParams.get("tree") === "true") return json$2(await service.getCategoryTree());
 			const parentId = url.searchParams.get("parentId");
-			return json$1(await service.getCategories({ parentId: parentId === "null" ? null : parentId ?? void 0 }));
+			return json$2(await service.getCategories({ parentId: parentId === "null" ? null : parentId ?? void 0 }));
 		} catch (err) {
-			return badRequest$1(err instanceof Error ? err.message : String(err));
+			return badRequest$2(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("POST", `${prefix}/categories`, async (req) => {
 		try {
 			const body = await req.json();
-			if (!body.name) return badRequest$1("Category 'name' is required.");
-			return json$1(await service.createCategory(body), 201);
+			if (!body.name) return badRequest$2("Category 'name' is required.");
+			return json$2(await service.createCategory(body), 201);
 		} catch (err) {
-			return badRequest$1(err instanceof Error ? err.message : String(err));
+			return badRequest$2(err instanceof Error ? err.message : String(err));
 		}
 	});
 	if (options.enableDiscounts !== false) {
 		ctx.registerRoute("POST", `${prefix}/discounts`, async (req) => {
 			try {
 				const body = await req.json();
-				if (!body.title || !body.code) return badRequest$1("'title' and 'code' are required.");
-				if (body.value === void 0 || body.value < 0) return badRequest$1("Valid discount 'value' is required.");
-				return json$1(await service.createDiscount(body), 201);
+				if (!body.title || !body.code) return badRequest$2("'title' and 'code' are required.");
+				if (body.value === void 0 || body.value < 0) return badRequest$2("Valid discount 'value' is required.");
+				return json$2(await service.createDiscount(body), 201);
 			} catch (err) {
-				return badRequest$1(err instanceof Error ? err.message : String(err));
+				return badRequest$2(err instanceof Error ? err.message : String(err));
 			}
 		});
 		ctx.registerRoute("POST", `${prefix}/discounts/validate`, async (req) => {
 			try {
 				const body = await req.json();
-				if (!body.code) return badRequest$1("Discount 'code' is required.");
+				if (!body.code) return badRequest$2("Discount 'code' is required.");
 				const subtotal = Number(body.subtotal ?? 0);
 				const productIds = Array.isArray(body.productIds) ? body.productIds : [];
-				return json$1(await service.validateDiscount(body.code, subtotal, productIds));
+				return json$2(await service.validateDiscount(body.code, subtotal, productIds));
 			} catch (err) {
-				return badRequest$1(err instanceof Error ? err.message : String(err));
+				return badRequest$2(err instanceof Error ? err.message : String(err));
 			}
 		});
 	}
 	ctx.registerRoute("POST", `${prefix}/cart/calculate`, async (req) => {
 		try {
 			const body = await req.json();
-			if (!body.items || !Array.isArray(body.items) || body.items.length === 0) return badRequest$1("'items' array is required and must not be empty.");
-			return json$1(await service.calculateCart(body));
+			if (!body.items || !Array.isArray(body.items) || body.items.length === 0) return badRequest$2("'items' array is required and must not be empty.");
+			return json$2(await service.calculateCart(body));
 		} catch (err) {
-			return badRequest$1(err instanceof Error ? err.message : String(err));
+			return badRequest$2(err instanceof Error ? err.message : String(err));
 		}
 	});
 	if (options.enableOrders !== false) {
 		ctx.registerRoute("POST", `${prefix}/orders`, async (req) => {
 			try {
 				const body = await req.json();
-				if (!body.customerEmail) return badRequest$1("'customerEmail' is required.");
-				if (!body.items || !Array.isArray(body.items) || body.items.length === 0) return badRequest$1("'items' array is required.");
-				return json$1(await service.createOrder(body), 201);
+				if (!body.customerEmail) return badRequest$2("'customerEmail' is required.");
+				if (!body.items || !Array.isArray(body.items) || body.items.length === 0) return badRequest$2("'items' array is required.");
+				return json$2(await service.createOrder(body), 201);
 			} catch (err) {
-				return badRequest$1(err instanceof Error ? err.message : String(err));
+				return badRequest$2(err instanceof Error ? err.message : String(err));
 			}
 		});
 		ctx.registerRoute("GET", `${prefix}/orders/:id`, async (_req, { params, url }) => {
@@ -3040,18 +3064,18 @@ function registerEcommerceRoutes(ctx, service, options = {}) {
 				order = await service.getOrder(id);
 				if (!order) order = await service.getOrderByNumber(id);
 			}
-			if (!order) return notFound$1(`Order '${id}' not found.`);
-			return json$1(order);
+			if (!order) return notFound$2(`Order '${id}' not found.`);
+			return json$2(order);
 		});
 		ctx.registerRoute("PATCH", `${prefix}/orders/:id/status`, async (req, { params }) => {
 			try {
 				const body = await req.json();
-				if (!body.status) return badRequest$1("New 'status' is required.");
+				if (!body.status) return badRequest$2("New 'status' is required.");
 				const updated = await service.updateOrderStatus(params.id, body.status, body.note);
-				if (!updated) return notFound$1(`Order '${params.id}' not found.`);
-				return json$1(updated);
+				if (!updated) return notFound$2(`Order '${params.id}' not found.`);
+				return json$2(updated);
 			} catch (err) {
-				return badRequest$1(err instanceof Error ? err.message : String(err));
+				return badRequest$2(err instanceof Error ? err.message : String(err));
 			}
 		});
 	}
@@ -4285,7 +4309,7 @@ var HRMSService = class {
 };
 //#endregion
 //#region src/plugins/hrms/routes.ts
-function json(data, status = 200) {
+function json$1(data, status = 200) {
 	return new Response(JSON.stringify(data), {
 		status,
 		headers: {
@@ -4294,11 +4318,11 @@ function json(data, status = 200) {
 		}
 	});
 }
-function badRequest(message) {
-	return json({ error: message }, 400);
+function badRequest$1(message) {
+	return json$1({ error: message }, 400);
 }
-function notFound(message) {
-	return json({ error: message }, 404);
+function notFound$1(message) {
+	return json$1({ error: message }, 404);
 }
 function registerHRMSRoutes(ctx, service, options = {}) {
 	const prefix = (options.apiPrefix ?? "/api/hrms").replace(/\/+$/, "");
@@ -4309,41 +4333,41 @@ function registerHRMSRoutes(ctx, service, options = {}) {
 			const limitStr = url.searchParams.get("limit");
 			const page = pageStr ? parseInt(pageStr, 10) : void 0;
 			const limit = limitStr ? parseInt(limitStr, 10) : void 0;
-			return json(await service.listEmployers({
+			return json$1(await service.listEmployers({
 				status,
 				page,
 				limit
 			}));
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("POST", `${prefix}/employers`, async (req) => {
 		try {
 			const body = await req.json();
-			if (!body.companyName) return badRequest("companyName is required.");
-			return json(await service.createEmployer(body), 201);
+			if (!body.companyName) return badRequest$1("companyName is required.");
+			return json$1(await service.createEmployer(body), 201);
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("GET", `${prefix}/employers/:id`, async (_req, { params }) => {
 		try {
 			const employer = await service.getEmployer(params.id);
-			if (!employer) return notFound(`Employer '${params.id}' not found.`);
-			return json(employer);
+			if (!employer) return notFound$1(`Employer '${params.id}' not found.`);
+			return json$1(employer);
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("PUT", `${prefix}/employers/:id`, async (req, { params }) => {
 		try {
 			const body = await req.json();
 			const updated = await service.updateEmployer(params.id, body);
-			if (!updated) return notFound(`Employer '${params.id}' not found.`);
-			return json(updated);
+			if (!updated) return notFound$1(`Employer '${params.id}' not found.`);
+			return json$1(updated);
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("GET", `${prefix}/employees`, async (_req, { url }) => {
@@ -4357,7 +4381,7 @@ function registerHRMSRoutes(ctx, service, options = {}) {
 			const limitStr = url.searchParams.get("limit");
 			const page = pageStr ? parseInt(pageStr, 10) : void 0;
 			const limit = limitStr ? parseInt(limitStr, 10) : void 0;
-			return json(await service.listEmployees({
+			return json$1(await service.listEmployees({
 				employerId,
 				department,
 				employmentType,
@@ -4367,84 +4391,84 @@ function registerHRMSRoutes(ctx, service, options = {}) {
 				limit
 			}));
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("POST", `${prefix}/employees`, async (req) => {
 		try {
 			const body = await req.json();
-			if (!body.employerId) return badRequest("employerId is required.");
-			if (!body.employeeNumber) return badRequest("employeeNumber is required.");
-			if (!body.firstName || !body.lastName) return badRequest("firstName and lastName are required.");
-			if (!body.email) return badRequest("email is required.");
-			return json(await service.createEmployee(body), 201);
+			if (!body.employerId) return badRequest$1("employerId is required.");
+			if (!body.employeeNumber) return badRequest$1("employeeNumber is required.");
+			if (!body.firstName || !body.lastName) return badRequest$1("firstName and lastName are required.");
+			if (!body.email) return badRequest$1("email is required.");
+			return json$1(await service.createEmployee(body), 201);
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("GET", `${prefix}/employees/:id`, async (_req, { params }) => {
 		try {
 			const employee = await service.getEmployee(params.id);
-			if (!employee) return notFound(`Employee '${params.id}' not found.`);
-			return json(employee);
+			if (!employee) return notFound$1(`Employee '${params.id}' not found.`);
+			return json$1(employee);
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("PUT", `${prefix}/employees/:id`, async (req, { params }) => {
 		try {
 			const body = await req.json();
 			const updated = await service.updateEmployee(params.id, body);
-			if (!updated) return notFound(`Employee '${params.id}' not found.`);
-			return json(updated);
+			if (!updated) return notFound$1(`Employee '${params.id}' not found.`);
+			return json$1(updated);
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("DELETE", `${prefix}/employees/:id`, async (_req, { params }) => {
 		try {
-			if (!await service.deleteEmployee(params.id)) return notFound(`Employee '${params.id}' not found.`);
-			return json({ success: true });
+			if (!await service.deleteEmployee(params.id)) return notFound$1(`Employee '${params.id}' not found.`);
+			return json$1({ success: true });
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("GET", `${prefix}/employees/:id/leave-balance`, async (_req, { params, url }) => {
 		try {
 			const yearStr = url.searchParams.get("year");
 			const year = yearStr ? parseInt(yearStr, 10) : void 0;
-			return json(await service.calculateLeaveBalance(params.id, year));
+			return json$1(await service.calculateLeaveBalance(params.id, year));
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("GET", `${prefix}/employees/:id/direct-reports`, async (_req, { params }) => {
 		try {
 			const reports = await service.getDirectReports(params.id);
-			return json({
+			return json$1({
 				items: reports,
 				total: reports.length
 			});
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("POST", `${prefix}/attendance/check-in`, async (req) => {
 		try {
 			const body = await req.json();
-			if (!body.employeeId) return badRequest("employeeId is required.");
-			return json(await service.checkIn(body), 201);
+			if (!body.employeeId) return badRequest$1("employeeId is required.");
+			return json$1(await service.checkIn(body), 201);
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("POST", `${prefix}/attendance/check-out`, async (req) => {
 		try {
 			const body = await req.json();
-			if (!body.employeeId) return badRequest("employeeId is required.");
-			return json(await service.checkOut(body));
+			if (!body.employeeId) return badRequest$1("employeeId is required.");
+			return json$1(await service.checkOut(body));
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("GET", `${prefix}/attendance`, async (_req, { url }) => {
@@ -4459,7 +4483,7 @@ function registerHRMSRoutes(ctx, service, options = {}) {
 			const limitStr = url.searchParams.get("limit");
 			const page = pageStr ? parseInt(pageStr, 10) : void 0;
 			const limit = limitStr ? parseInt(limitStr, 10) : void 0;
-			return json(await service.listAttendance({
+			return json$1(await service.listAttendance({
 				employerId,
 				employeeId,
 				date,
@@ -4470,46 +4494,46 @@ function registerHRMSRoutes(ctx, service, options = {}) {
 				limit
 			}));
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("POST", `${prefix}/attendance/manual`, async (req) => {
 		try {
 			const body = await req.json();
-			if (!body.employerId || !body.employeeId || !body.date || !body.checkInAt) return badRequest("employerId, employeeId, date, and checkInAt are required.");
-			return json(await service.recordAttendanceManual(body), 201);
+			if (!body.employerId || !body.employeeId || !body.date || !body.checkInAt) return badRequest$1("employerId, employeeId, date, and checkInAt are required.");
+			return json$1(await service.recordAttendanceManual(body), 201);
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("GET", `${prefix}/leave-types`, async (_req, { url }) => {
 		try {
 			const employerId = url.searchParams.get("employerId") ?? void 0;
 			const types = await service.listLeaveTypes(employerId);
-			return json({
+			return json$1({
 				items: types,
 				total: types.length
 			});
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("POST", `${prefix}/leave-types`, async (req) => {
 		try {
 			const body = await req.json();
-			if (!body.name || !body.code || body.daysAllowedPerYear === void 0) return badRequest("name, code, and daysAllowedPerYear are required.");
-			return json(await service.createLeaveType(body), 201);
+			if (!body.name || !body.code || body.daysAllowedPerYear === void 0) return badRequest$1("name, code, and daysAllowedPerYear are required.");
+			return json$1(await service.createLeaveType(body), 201);
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("GET", `${prefix}/leave-types/:id`, async (_req, { params }) => {
 		try {
 			const leaveType = await service.getLeaveType(params.id);
-			if (!leaveType) return notFound(`Leave type '${params.id}' not found.`);
-			return json(leaveType);
+			if (!leaveType) return notFound$1(`Leave type '${params.id}' not found.`);
+			return json$1(leaveType);
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("GET", `${prefix}/leave-requests`, async (_req, { url }) => {
@@ -4524,7 +4548,7 @@ function registerHRMSRoutes(ctx, service, options = {}) {
 			const limitStr = url.searchParams.get("limit");
 			const page = pageStr ? parseInt(pageStr, 10) : void 0;
 			const limit = limitStr ? parseInt(limitStr, 10) : void 0;
-			return json(await service.listLeaveRequests({
+			return json$1(await service.listLeaveRequests({
 				employerId,
 				employeeId,
 				leaveTypeId,
@@ -4534,47 +4558,47 @@ function registerHRMSRoutes(ctx, service, options = {}) {
 				limit
 			}));
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("POST", `${prefix}/leave-requests`, async (req) => {
 		try {
 			const body = await req.json();
-			if (!body.employeeId || !body.leaveTypeId || !body.startDate || !body.endDate) return badRequest("employeeId, leaveTypeId, startDate, and endDate are required.");
-			return json(await service.requestLeave(body), 201);
+			if (!body.employeeId || !body.leaveTypeId || !body.startDate || !body.endDate) return badRequest$1("employeeId, leaveTypeId, startDate, and endDate are required.");
+			return json$1(await service.requestLeave(body), 201);
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("POST", `${prefix}/leave-requests/:id/approve`, async (req, { params }) => {
 		try {
 			const approverId = (await req.json().catch(() => ({}))).approverId ?? "admin";
-			return json(await service.approveLeave({
+			return json$1(await service.approveLeave({
 				requestId: params.id,
 				approverId
 			}));
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("POST", `${prefix}/leave-requests/:id/reject`, async (req, { params }) => {
 		try {
 			const body = await req.json().catch(() => ({}));
 			const approverId = body.approverId ?? "admin";
-			return json(await service.rejectLeave({
+			return json$1(await service.rejectLeave({
 				requestId: params.id,
 				approverId,
 				reason: body.reason
 			}));
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 	ctx.registerRoute("POST", `${prefix}/leave-requests/:id/cancel`, async (_req, { params }) => {
 		try {
-			return json(await service.cancelLeave(params.id));
+			return json$1(await service.cancelLeave(params.id));
 		} catch (err) {
-			return badRequest(err instanceof Error ? err.message : String(err));
+			return badRequest$1(err instanceof Error ? err.message : String(err));
 		}
 	});
 }
@@ -4826,6 +4850,1810 @@ function getHRMSService(engine, options) {
 	return service;
 }
 //#endregion
+//#region src/plugins/transfer/parsers/json.ts
+/**
+* @azlib/cms - Universal JSON Data Parser
+*/
+function parseJsonSource(input) {
+	if (Array.isArray(input)) return input.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item)));
+	let text;
+	if (typeof input === "string") text = input.trim();
+	else if (input instanceof Uint8Array || Buffer.isBuffer(input)) text = new TextDecoder("utf-8").decode(input).trim();
+	else if (input && typeof input === "object") {
+		const obj = input;
+		if (Array.isArray(obj.data)) return parseJsonSource(obj.data);
+		if (Array.isArray(obj.items)) return parseJsonSource(obj.items);
+		return [obj];
+	} else throw new Error("[TransferParser] Invalid JSON input: expected string, buffer, or array.");
+	if (text.charCodeAt(0) === 65279) text = text.slice(1);
+	if (!text) return [];
+	try {
+		const parsed = JSON.parse(text);
+		if (Array.isArray(parsed)) return parsed.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item)));
+		if (parsed && typeof parsed === "object") {
+			if (Array.isArray(parsed.data)) return parseJsonSource(parsed.data);
+			if (Array.isArray(parsed.items)) return parseJsonSource(parsed.items);
+			return [parsed];
+		}
+		return [];
+	} catch {
+		const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+		const records = [];
+		for (const line of lines) try {
+			const item = JSON.parse(line);
+			if (item && typeof item === "object" && !Array.isArray(item)) records.push(item);
+		} catch (err) {
+			throw new Error(`[TransferParser] Failed to parse JSON source: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		return records;
+	}
+}
+//#endregion
+//#region src/plugins/transfer/parsers/csv.ts
+/**
+* @azlib/cms - Universal RFC 4180 CSV Data Parser
+*/
+function parseCsvSource(input) {
+	let text;
+	if (typeof input === "string") text = input;
+	else if (input instanceof Uint8Array || Buffer.isBuffer(input)) text = new TextDecoder("utf-8").decode(input);
+	else throw new Error("[TransferParser] Invalid CSV input: expected string or buffer.");
+	if (text.charCodeAt(0) === 65279) text = text.slice(1);
+	const rows = parseCsvRows(text);
+	if (rows.length === 0) return [];
+	const headers = rows[0].map((h, i) => {
+		return h.trim() || `column_${i + 1}`;
+	});
+	const records = [];
+	for (let r = 1; r < rows.length; r++) {
+		const row = rows[r];
+		if (row.length === 0 || row.length === 1 && row[0].trim() === "") continue;
+		const record = {};
+		for (let c = 0; c < headers.length; c++) {
+			const header = headers[c];
+			record[header] = coerceCsvValue(c < row.length ? row[c].trim() : "");
+		}
+		records.push(record);
+	}
+	return records;
+}
+/**
+* Tokenize CSV into 2D array of string cells following RFC 4180.
+*/
+function parseCsvRows(text) {
+	const rows = [];
+	let currentRow = [];
+	let currentCell = "";
+	let insideQuotes = false;
+	let i = 0;
+	const len = text.length;
+	while (i < len) {
+		const char = text[i];
+		if (insideQuotes) if (char === "\"") if (i + 1 < len && text[i + 1] === "\"") {
+			currentCell += "\"";
+			i += 2;
+			continue;
+		} else {
+			insideQuotes = false;
+			i++;
+			continue;
+		}
+		else {
+			currentCell += char;
+			i++;
+			continue;
+		}
+		if (char === "\"") {
+			insideQuotes = true;
+			i++;
+			continue;
+		}
+		if (char === ",") {
+			currentRow.push(currentCell);
+			currentCell = "";
+			i++;
+			continue;
+		}
+		if (char === "\r") {
+			if (i + 1 < len && text[i + 1] === "\n") i++;
+			currentRow.push(currentCell);
+			rows.push(currentRow);
+			currentRow = [];
+			currentCell = "";
+			i++;
+			continue;
+		}
+		if (char === "\n") {
+			currentRow.push(currentCell);
+			rows.push(currentRow);
+			currentRow = [];
+			currentCell = "";
+			i++;
+			continue;
+		}
+		currentCell += char;
+		i++;
+	}
+	if (currentCell.length > 0 || currentRow.length > 0) {
+		currentRow.push(currentCell);
+		rows.push(currentRow);
+	}
+	return rows;
+}
+/**
+* Coerce obvious numeric / boolean CSV strings to primitives when lossless.
+*/
+function coerceCsvValue(val) {
+	if (val === "") return "";
+	if (val.toLowerCase() === "true") return true;
+	if (val.toLowerCase() === "false") return false;
+	if (val.toLowerCase() === "null") return null;
+	if (/^-?\d+(\.\d+)?$/.test(val)) {
+		if (val.length > 1 && val.startsWith("0") && !val.startsWith("0.")) return val;
+		const num = Number(val);
+		if (!Number.isNaN(num)) return num;
+	}
+	return val;
+}
+//#endregion
+//#region src/plugins/transfer/parsers/excel.ts
+/**
+* @azlib/cms - Universal Excel (.xlsx) Data Parser using ExcelJS
+*/
+async function parseExcelSource(input, options = {}) {
+	const workbook = new exceljs.default.Workbook();
+	let buffer;
+	if (Buffer.isBuffer(input)) buffer = input;
+	else if (input instanceof Uint8Array) buffer = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+	else if (input instanceof ArrayBuffer) buffer = Buffer.from(input);
+	else throw new Error("[TransferParser] Invalid Excel input: expected Buffer, Uint8Array, or ArrayBuffer.");
+	await workbook.xlsx.load(buffer);
+	const sheetNames = workbook.worksheets.map((s) => s.name);
+	if (sheetNames.length === 0) return {
+		sheets: [],
+		selectedSheet: "",
+		records: []
+	};
+	let worksheet = options.sheetName ? workbook.getWorksheet(options.sheetName) : void 0;
+	if (!worksheet) worksheet = workbook.worksheets[0];
+	const selectedSheet = worksheet.name;
+	const records = [];
+	const headerRow = worksheet.getRow(1);
+	const headers = [];
+	headerRow.eachCell({ includeEmpty: false }, (cell, colNumber) => {
+		let headerText = String(cell.value ?? "").trim();
+		if (!headerText) headerText = `column_${colNumber}`;
+		headers[colNumber] = headerText;
+	});
+	if (headers.length === 0) return {
+		sheets: sheetNames,
+		selectedSheet,
+		records: []
+	};
+	const rowCount = worksheet.rowCount;
+	for (let r = 2; r <= rowCount; r++) {
+		const row = worksheet.getRow(r);
+		let hasValues = false;
+		const record = {};
+		for (let c = 1; c < headers.length; c++) {
+			const header = headers[c];
+			if (!header) continue;
+			const val = extractCellValue(row.getCell(c).value);
+			if (val !== void 0 && val !== null && val !== "") hasValues = true;
+			record[header] = val;
+		}
+		if (hasValues) records.push(record);
+	}
+	return {
+		sheets: sheetNames,
+		selectedSheet,
+		records
+	};
+}
+/**
+* Normalizes ExcelJS cell values (handles formulas, dates, rich text, hyperlinks).
+*/
+function extractCellValue(val) {
+	if (val === void 0 || val === null) return null;
+	if (val instanceof Date) return val.toISOString();
+	if (typeof val === "object") {
+		if ("formula" in val) return extractCellValue(val.result);
+		if ("text" in val && "hyperlink" in val) return val.text;
+		if ("richText" in val && Array.isArray(val.richText)) return val.richText.map((t) => t.text).join("");
+		if ("error" in val) return null;
+	}
+	return val;
+}
+//#endregion
+//#region src/plugins/transfer/parsers/index.ts
+/**
+* Detect the format of an input payload if not explicitly provided.
+*/
+function detectFormat(input, fileName) {
+	if (Array.isArray(input)) return "json";
+	if (fileName) {
+		const lower = fileName.toLowerCase();
+		if (lower.endsWith(".xlsx") || lower.endsWith(".xls")) return "excel";
+		if (lower.endsWith(".csv")) return "csv";
+		if (lower.endsWith(".json") || lower.endsWith(".ndjson")) return "json";
+	}
+	if (input instanceof Uint8Array || Buffer.isBuffer(input)) {
+		if (input.length >= 4 && input[0] === 80 && input[1] === 75 && input[2] === 3 && input[3] === 4) return "excel";
+		try {
+			const head = new TextDecoder("utf-8").decode(input.slice(0, 100)).trim();
+			if (head.startsWith("{") || head.startsWith("[")) return "json";
+			if (head.includes(",") && head.includes("\n")) return "csv";
+		} catch {}
+	}
+	if (typeof input === "string") {
+		const trimmed = input.trim();
+		if (trimmed.startsWith("{") || trimmed.startsWith("[")) return "json";
+		if (trimmed.includes(",") || trimmed.includes("\n")) return "csv";
+	}
+	return "json";
+}
+/**
+* Universal source parser that handles JSON, CSV, and Excel (.xlsx).
+*/
+async function parseSource(input, options = {}) {
+	switch (options.format || detectFormat(input, options.fileName)) {
+		case "excel": {
+			const excelResult = await parseExcelSource(input, { sheetName: options.sheetName });
+			return {
+				format: "excel",
+				sheets: excelResult.sheets,
+				selectedSheet: excelResult.selectedSheet,
+				records: excelResult.records
+			};
+		}
+		case "csv": return {
+			format: "csv",
+			records: parseCsvSource(input)
+		};
+		default: return {
+			format: "json",
+			records: parseJsonSource(input)
+		};
+	}
+}
+//#endregion
+//#region src/plugins/transfer/serializers/json.ts
+function serializeJson(records, options = {}) {
+	const indent = options.pretty !== false ? 2 : void 0;
+	return JSON.stringify(records, null, indent);
+}
+//#endregion
+//#region src/plugins/transfer/serializers/csv.ts
+function serializeCsv(records, options = {}) {
+	if (records.length === 0) return "";
+	let columns = options.columns;
+	if (!columns || columns.length === 0) {
+		const keys = /* @__PURE__ */ new Set();
+		for (const record of records) for (const key of Object.keys(record)) keys.add(key);
+		columns = Array.from(keys).map((k) => ({
+			key: k,
+			header: k
+		}));
+	}
+	const lines = [];
+	lines.push(columns.map((c) => escapeCsvCell(c.header)).join(","));
+	for (const record of records) {
+		const rowCells = columns.map((col) => {
+			const val = record[col.key];
+			return escapeCsvCell(formatCsvValue(val));
+		});
+		lines.push(rowCells.join(","));
+	}
+	return lines.join("\r\n");
+}
+function formatCsvValue(val) {
+	if (val === void 0 || val === null) return "";
+	if (typeof val === "object") {
+		if (val instanceof Date) return val.toISOString();
+		return JSON.stringify(val);
+	}
+	return String(val);
+}
+function escapeCsvCell(cell) {
+	if (cell.includes(",") || cell.includes("\"") || cell.includes("\n") || cell.includes("\r")) return `"${cell.replace(/"/g, "\"\"")}"`;
+	return cell;
+}
+//#endregion
+//#region src/plugins/transfer/serializers/excel.ts
+/**
+* @azlib/cms - Universal Excel (.xlsx) Serializer using ExcelJS
+*/
+async function serializeExcel(records, options = {}) {
+	const workbook = new exceljs.default.Workbook();
+	const sheetName = (options.sheetName || "Export").replace(/[:\\/?*\[\]]/g, "_");
+	const worksheet = workbook.addWorksheet(sheetName.slice(0, 31));
+	let columns = options.columns;
+	if (!columns || columns.length === 0) {
+		const keys = /* @__PURE__ */ new Set();
+		for (const record of records) for (const key of Object.keys(record)) keys.add(key);
+		columns = Array.from(keys).map((k) => ({
+			key: k,
+			header: formatHeaderLabel(k)
+		}));
+	}
+	worksheet.columns = columns.map((col) => {
+		let maxLen = col.header.length;
+		for (let i = 0; i < Math.min(records.length, 100); i++) {
+			const val = records[i][col.key];
+			if (val !== void 0 && val !== null) {
+				const str = typeof val === "object" ? JSON.stringify(val) : String(val);
+				if (str.length > maxLen) maxLen = Math.min(str.length, 50);
+			}
+		}
+		return {
+			header: col.header,
+			key: col.key,
+			width: Math.max(maxLen + 4, col.width ?? 12)
+		};
+	});
+	const headerRow = worksheet.getRow(1);
+	headerRow.height = 28;
+	headerRow.eachCell((cell) => {
+		cell.font = {
+			bold: true,
+			color: { argb: "FF1E293B" },
+			size: 11
+		};
+		cell.fill = {
+			type: "pattern",
+			pattern: "solid",
+			fgColor: { argb: "FFF1F5F9" }
+		};
+		cell.alignment = {
+			vertical: "middle",
+			horizontal: "center",
+			wrapText: true
+		};
+		cell.border = {
+			top: {
+				style: "thin",
+				color: { argb: "FFE2E8F0" }
+			},
+			bottom: {
+				style: "medium",
+				color: { argb: "FFCBD5E1" }
+			},
+			left: {
+				style: "thin",
+				color: { argb: "FFE2E8F0" }
+			},
+			right: {
+				style: "thin",
+				color: { argb: "FFE2E8F0" }
+			}
+		};
+	});
+	for (const record of records) {
+		const rowValues = {};
+		for (const col of columns) {
+			const val = record[col.key];
+			rowValues[col.key] = formatExcelCellValue(val);
+		}
+		const row = worksheet.addRow(rowValues);
+		row.height = 20;
+		row.eachCell((cell) => {
+			cell.alignment = { vertical: "middle" };
+			cell.border = {
+				top: {
+					style: "thin",
+					color: { argb: "FFF1F5F9" }
+				},
+				bottom: {
+					style: "thin",
+					color: { argb: "FFF1F5F9" }
+				},
+				left: {
+					style: "thin",
+					color: { argb: "FFF1F5F9" }
+				},
+				right: {
+					style: "thin",
+					color: { argb: "FFF1F5F9" }
+				}
+			};
+		});
+	}
+	const arrayBuffer = await workbook.xlsx.writeBuffer();
+	return new Uint8Array(arrayBuffer);
+}
+function formatHeaderLabel(key) {
+	return key.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function formatExcelCellValue(val) {
+	if (val === void 0 || val === null) return "";
+	if (typeof val === "number" || typeof val === "boolean") return val;
+	if (val instanceof Date) return val;
+	if (typeof val === "object") return JSON.stringify(val);
+	return String(val);
+}
+//#endregion
+//#region src/plugins/transfer/serializers/index.ts
+async function serializeSource(records, options = {}) {
+	const format = options.format || "json";
+	const baseName = options.fileName || "export";
+	switch (format) {
+		case "excel": return {
+			format: "excel",
+			data: await serializeExcel(records, {
+				sheetName: options.sheetName,
+				columns: options.columns
+			}),
+			mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+			fileName: baseName.endsWith(".xlsx") ? baseName : `${baseName}.xlsx`,
+			totalRecords: records.length
+		};
+		case "csv": return {
+			format: "csv",
+			data: serializeCsv(records, { columns: options.columns }),
+			mimeType: "text/csv; charset=utf-8",
+			fileName: baseName.endsWith(".csv") ? baseName : `${baseName}.csv`,
+			totalRecords: records.length
+		};
+		default: return {
+			format: "json",
+			data: serializeJson(records, { pretty: true }),
+			mimeType: "application/json; charset=utf-8",
+			fileName: baseName.endsWith(".json") ? baseName : `${baseName}.json`,
+			totalRecords: records.length
+		};
+	}
+}
+//#endregion
+//#region src/plugins/transfer/inspect.ts
+/**
+* Inspect an uploaded source file or payload to discover its schema,
+* infer column types, and generate auto-mapping suggestions against a target collection.
+*/
+async function inspectSource(input, options = {}) {
+	const parsed = await parseSource(input, {
+		format: options.format,
+		fileName: options.fileName,
+		sheetName: options.sheetName
+	});
+	const records = parsed.records;
+	const totalRows = records.length;
+	const previewLimit = options.previewLimit ?? 5;
+	const previewRows = records.slice(0, previewLimit);
+	const fieldKeys = /* @__PURE__ */ new Set();
+	for (const row of records) for (const key of Object.keys(row)) fieldKeys.add(key);
+	const sourceFields = [];
+	for (const key of fieldKeys) {
+		let nullCount = 0;
+		const samples = [];
+		const detectedTypes = [];
+		for (const row of records) {
+			const val = row[key];
+			if (val === void 0 || val === null || val === "") nullCount++;
+			else {
+				if (samples.length < 5) samples.push(val);
+				detectedTypes.push(inferValueType(val));
+			}
+		}
+		sourceFields.push({
+			name: key,
+			inferredType: resolveDominantType(detectedTypes),
+			sampleValues: samples,
+			nullCount,
+			totalCount: totalRows
+		});
+	}
+	let targetSchema;
+	let suggestedMapping;
+	if (options.collectionConfig) {
+		targetSchema = summarizeCollection(options.collectionConfig);
+		suggestedMapping = generateSuggestedMapping(sourceFields.map((f) => f.name), targetSchema);
+	}
+	return {
+		format: parsed.format,
+		sheets: parsed.sheets,
+		selectedSheet: parsed.selectedSheet,
+		totalRows,
+		sourceFields,
+		targetSchema,
+		suggestedMapping,
+		previewRows
+	};
+}
+/**
+* Summarize a CMS CollectionConfig into consumer-friendly schema details.
+*/
+function summarizeCollection(config) {
+	return {
+		slug: config.slug,
+		label: config.label,
+		singularLabel: config.singularLabel || config.label,
+		description: config.description,
+		taxonomies: config.taxonomies || [],
+		fields: config.fields.map((f) => ({
+			name: f.name,
+			label: f.label || f.name,
+			type: f.type,
+			required: Boolean(f.required),
+			unique: Boolean(f.unique),
+			description: f.description,
+			defaultValue: f.defaultValue,
+			targetCollection: f.targetCollection,
+			options: f.options
+		}))
+	};
+}
+/**
+* Generates intelligent auto-mapping suggestions matching source headers to CMS fields.
+*/
+function generateSuggestedMapping(sourceHeaders, targetSchema) {
+	const suggestions = [];
+	const matchedTargets = /* @__PURE__ */ new Set();
+	for (const sourceHeader of sourceHeaders) {
+		let bestMatch = null;
+		for (const targetField of targetSchema.fields) {
+			if (matchedTargets.has(targetField.name)) continue;
+			const score = calculateMatchConfidence(sourceHeader, targetField);
+			if (score >= .6 && (!bestMatch || score > bestMatch.confidence)) bestMatch = {
+				field: targetField.name,
+				confidence: score
+			};
+		}
+		if (bestMatch) {
+			matchedTargets.add(bestMatch.field);
+			suggestions.push({
+				sourceField: sourceHeader,
+				targetField: bestMatch.field,
+				confidence: Number(bestMatch.confidence.toFixed(2))
+			});
+		}
+	}
+	return suggestions;
+}
+function normalize(str) {
+	return str.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+/**
+* Common field synonyms dictionary for intuitive fuzzy matching.
+*/
+const SYNONYMS = {
+	employeeNumber: [
+		"empid",
+		"employeeid",
+		"empnumber",
+		"staffid",
+		"badgenumber",
+		"staffno",
+		"empno"
+	],
+	companyName: [
+		"company",
+		"organization",
+		"employer",
+		"businessname",
+		"employername",
+		"firm"
+	],
+	firstName: [
+		"fname",
+		"givenname",
+		"first"
+	],
+	lastName: [
+		"lname",
+		"surname",
+		"familyname",
+		"last"
+	],
+	email: [
+		"mail",
+		"workemail",
+		"primaryemail",
+		"emailaddress"
+	],
+	phone: [
+		"mobile",
+		"cell",
+		"telephone",
+		"phonenumber",
+		"contactnumber",
+		"tel"
+	],
+	employerId: [
+		"employer",
+		"companyid",
+		"company",
+		"organizationid",
+		"orgid"
+	],
+	hireDate: [
+		"startdate",
+		"joiningdate",
+		"hired",
+		"dateofjoining"
+	],
+	jobTitle: [
+		"title",
+		"position",
+		"role",
+		"designation"
+	],
+	employmentType: [
+		"contracttype",
+		"worktype",
+		"jobtype"
+	],
+	salary: [
+		"compensation",
+		"wage",
+		"pay",
+		"rate",
+		"annualsalary"
+	],
+	taxId: [
+		"ein",
+		"vat",
+		"taxnumber",
+		"tin"
+	],
+	status: ["state", "active"]
+};
+function calculateMatchConfidence(sourceHeader, targetField) {
+	const normSource = normalize(sourceHeader);
+	const normTargetName = normalize(targetField.name);
+	const normTargetLabel = normalize(targetField.label);
+	if (sourceHeader === targetField.name) return 1;
+	if (normSource === normTargetName) return .95;
+	if (sourceHeader.toLowerCase() === targetField.label.toLowerCase()) return .92;
+	if (normSource === normTargetLabel) return .9;
+	const synonyms = SYNONYMS[targetField.name];
+	if (synonyms && synonyms.includes(normSource)) return .85;
+	if (normSource.includes(normTargetName) || normTargetName.includes(normSource)) return .7;
+	if (normSource.includes(normTargetLabel) || normTargetLabel.includes(normSource)) return .65;
+	return 0;
+}
+function inferValueType(val) {
+	if (typeof val === "boolean") return "boolean";
+	if (typeof val === "number") return "number";
+	if (Array.isArray(val)) return "array";
+	if (val && typeof val === "object") return "object";
+	if (typeof val === "string") {
+		const s = val.trim();
+		if (s.toLowerCase() === "true" || s.toLowerCase() === "false") return "boolean";
+		if (/^-?\d+(\.\d+)?$/.test(s) && !/^0\d+/.test(s)) return "number";
+		if (/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2})?(\.\d+)?(Z|[+-]\d{2}:?\d{2})?)?$/.test(s)) {
+			const parsed = Date.parse(s);
+			if (!Number.isNaN(parsed)) return "date";
+		}
+	}
+	return "string";
+}
+function resolveDominantType(types) {
+	if (types.length === 0) return "string";
+	const counts = /* @__PURE__ */ new Map();
+	for (const t of types) counts.set(t, (counts.get(t) || 0) + 1);
+	let dominant = "string";
+	let maxCount = 0;
+	for (const [t, count] of counts) if (count > maxCount) {
+		maxCount = count;
+		dominant = t;
+	}
+	return dominant;
+}
+//#endregion
+//#region src/plugins/transfer/mapping.ts
+/**
+* Apply a mapping definition to transform an external raw record into a CMS content payload.
+*/
+function mapSourceRecord(rawRecord, mapping) {
+	const mappedData = {};
+	const mappedTargetFields = /* @__PURE__ */ new Set();
+	for (const rule of mapping.fields) {
+		mappedTargetFields.add(rule.targetField);
+		const sourceVal = rawRecord[rule.sourceField];
+		const transformed = applyFieldTransform(rule, sourceVal, rawRecord);
+		if (transformed !== void 0) mappedData[rule.targetField] = transformed;
+	}
+	if (mapping.options?.ignoreUnmappedFields === false) {
+		for (const [key, val] of Object.entries(rawRecord)) if (!mapping.fields.some((r) => r.sourceField === key)) mappedData[key] = val;
+	}
+	let title = typeof mappedData.title === "string" ? mappedData.title : void 0;
+	if (!title) {
+		if (typeof mappedData.companyName === "string") title = mappedData.companyName;
+		else if (typeof mappedData.name === "string") title = mappedData.name;
+		else if (typeof mappedData.firstName === "string" || typeof mappedData.lastName === "string") {
+			const parts = [mappedData.firstName, mappedData.lastName].filter(Boolean);
+			if (parts.length > 0) title = parts.join(" ");
+		}
+	}
+	let slug = typeof mappedData.slug === "string" ? mappedData.slug : void 0;
+	if (!slug && mapping.options?.autoGenerateSlug !== false && title) slug = slugify(title);
+	let status = mapping.options?.defaultStatus;
+	if (mapping.options?.statusField && mappedData[mapping.options.statusField]) status = String(mappedData[mapping.options.statusField]);
+	return {
+		data: mappedData,
+		title,
+		slug,
+		status
+	};
+}
+/**
+* Applies transform preset or custom function to a field value.
+*/
+function applyFieldTransform(rule, value, rawRecord) {
+	let val = value;
+	if (typeof rule.transform === "function") try {
+		val = rule.transform(val, rawRecord);
+	} catch (err) {
+		throw new Error(`Transform error on field '${rule.sourceField}': ${err instanceof Error ? err.message : String(err)}`);
+	}
+	else if (rule.transform && typeof rule.transform === "string") val = applyPresetTransform(rule.transform, val);
+	if (val === void 0 || val === null || val === "") {
+		if (rule.defaultValue !== void 0) val = rule.defaultValue;
+	}
+	return val;
+}
+function applyPresetTransform(preset, val) {
+	if (val === void 0 || val === null) return val;
+	switch (preset) {
+		case "trim": return typeof val === "string" ? val.trim() : val;
+		case "lowercase": return typeof val === "string" ? val.toLowerCase() : val;
+		case "uppercase": return typeof val === "string" ? val.toUpperCase() : val;
+		case "number": {
+			if (typeof val === "number") return val;
+			const parsed = Number(val);
+			return Number.isNaN(parsed) ? val : parsed;
+		}
+		case "boolean": {
+			if (typeof val === "boolean") return val;
+			const s = String(val).toLowerCase().trim();
+			if (s === "true" || s === "1" || s === "yes") return true;
+			if (s === "false" || s === "0" || s === "no") return false;
+			return Boolean(val);
+		}
+		case "date": {
+			if (val instanceof Date) return val.toISOString();
+			const s = String(val).trim();
+			const parsed = Date.parse(s);
+			return Number.isNaN(parsed) ? s : new Date(parsed).toISOString();
+		}
+		case "json":
+			if (typeof val === "object") return val;
+			try {
+				return JSON.parse(String(val));
+			} catch {
+				return val;
+			}
+		case "slug": return slugify(String(val));
+		case "split_comma":
+			if (Array.isArray(val)) return val;
+			return String(val).split(",").map((s) => s.trim()).filter(Boolean);
+		default: return val;
+	}
+}
+/**
+* Reverse mapping for export: transforms a CMS ContentItem into an external export record.
+*/
+function mapCmsItemForExport(item, mapping, options = {}) {
+	const exportRecord = {};
+	if (mapping && mapping.fields.length > 0) {
+		for (const rule of mapping.fields) {
+			const val = item.data[rule.targetField] !== void 0 ? item.data[rule.targetField] : item[rule.targetField];
+			exportRecord[rule.sourceField] = val !== void 0 ? val : rule.defaultValue ?? "";
+		}
+		return exportRecord;
+	}
+	if (options.includeId !== false) exportRecord.id = item.id;
+	if (item.title) exportRecord.title = item.title;
+	if (item.slug) exportRecord.slug = item.slug;
+	if (item.status) exportRecord.status = item.status;
+	for (const [k, v] of Object.entries(item.data)) exportRecord[k] = v;
+	if (options.includeTimestamps) {
+		exportRecord.createdAt = item.createdAt;
+		exportRecord.updatedAt = item.updatedAt;
+	}
+	return exportRecord;
+}
+//#endregion
+//#region src/plugins/transfer/validator.ts
+/**
+* Validates a batch of source records against a target CMS collection configuration
+* and live database constraints.
+*/
+async function validateTransferBatch(rawRecords, mapping, collectionConfig, options = {}) {
+	const errors = [];
+	const previewRows = [];
+	const previewLimit = options.previewLimit ?? 10;
+	const onDuplicate = options.onDuplicate ?? mapping.options?.onDuplicate ?? "error";
+	const uniqueFields = collectionConfig.fields.filter((f) => Boolean(f.unique) || f.name === "slug");
+	const relationshipFields = collectionConfig.fields.filter((f) => f.type === "relationship" && Boolean(f.targetCollection));
+	const seenUniqueValues = /* @__PURE__ */ new Map();
+	for (const uf of uniqueFields) seenUniqueValues.set(uf.name, /* @__PURE__ */ new Map());
+	let validCount = 0;
+	for (let i = 0; i < rawRecords.length; i++) {
+		const rowNumber = i + 1;
+		const raw = rawRecords[i];
+		const rowErrors = [];
+		let mappedResult;
+		try {
+			mappedResult = mapSourceRecord(raw, mapping);
+		} catch (err) {
+			const errDetail = {
+				rowNumber,
+				code: "TRANSFORM_ERROR",
+				reason: err instanceof Error ? err.message : String(err)
+			};
+			rowErrors.push(errDetail);
+			errors.push(errDetail);
+			if (previewRows.length < previewLimit) previewRows.push({
+				rowNumber,
+				raw,
+				mapped: {},
+				valid: false,
+				errors: rowErrors
+			});
+			continue;
+		}
+		const data = mappedResult.data;
+		for (const field of collectionConfig.fields) validateField(field, data, rowNumber, rowErrors);
+		for (const rule of mapping.fields) if (rule.required && !collectionConfig.fields.some((f) => f.name === rule.targetField)) {
+			const val = data[rule.targetField];
+			if (val === void 0 || val === null || val === "") rowErrors.push({
+				rowNumber,
+				field: rule.targetField,
+				value: val,
+				code: "REQUIRED_FIELD_MISSING",
+				reason: `Field '${rule.targetField}' is required by mapping definition.`
+			});
+		}
+		for (const uf of uniqueFields) {
+			const val = data[uf.name] ?? (uf.name === "slug" ? mappedResult.slug : void 0);
+			if (val !== void 0 && val !== null && val !== "") {
+				const seenMap = seenUniqueValues.get(uf.name);
+				if (seenMap.has(val)) {
+					const prevRow = seenMap.get(val);
+					rowErrors.push({
+						rowNumber,
+						field: uf.name,
+						value: val,
+						code: "CONSTRAINT_UNIQUE_VIOLATION",
+						reason: `${uf.label || uf.name} value '${val}' is duplicated in row ${prevRow} and row ${rowNumber}.`
+					});
+				} else seenMap.set(val, rowNumber);
+				if (options.storage && onDuplicate === "error") {
+					if (await checkExistingUnique(options.storage, collectionConfig.slug, uf.name, val)) rowErrors.push({
+						rowNumber,
+						field: uf.name,
+						value: val,
+						code: "CONSTRAINT_UNIQUE_VIOLATION",
+						reason: `${uf.label || uf.name} value '${val}' already exists in database.`
+					});
+				}
+			}
+		}
+		if (options.storage) for (const rf of relationshipFields) {
+			const targetColl = rf.targetCollection;
+			const refVal = data[rf.name];
+			if (refVal !== void 0 && refVal !== null && refVal !== "") {
+				if (!await checkRelationshipExists(options.storage, targetColl, refVal)) rowErrors.push({
+					rowNumber,
+					field: rf.name,
+					value: refVal,
+					code: "CONSTRAINT_FOREIGN_KEY_VIOLATION",
+					reason: `Referenced ${rf.label || rf.name} with identifier '${refVal}' does not exist in collection '${targetColl}'.`
+				});
+			}
+		}
+		if (rowErrors.length === 0) validCount++;
+		else errors.push(...rowErrors);
+		if (previewRows.length < previewLimit) previewRows.push({
+			rowNumber,
+			raw,
+			mapped: data,
+			valid: rowErrors.length === 0,
+			errors: rowErrors.length > 0 ? rowErrors : void 0
+		});
+	}
+	return {
+		valid: errors.length === 0,
+		totalRows: rawRecords.length,
+		validCount,
+		errorCount: errors.length,
+		errors,
+		previewRows
+	};
+}
+/**
+* Validates a single field against its FieldDefinition.
+*/
+function validateField(field, data, rowNumber, errors) {
+	const val = data[field.name];
+	const label = field.label || field.name;
+	if (field.required && (val === void 0 || val === null || val === "")) {
+		errors.push({
+			rowNumber,
+			field: field.name,
+			value: val,
+			code: "REQUIRED_FIELD_MISSING",
+			reason: `${label} is required.`
+		});
+		return;
+	}
+	if (val === void 0 || val === null || val === "") return;
+	switch (field.type) {
+		case "number": {
+			const num = typeof val === "number" ? val : Number(val);
+			if (Number.isNaN(num)) errors.push({
+				rowNumber,
+				field: field.name,
+				value: val,
+				code: "INVALID_DATA_TYPE",
+				reason: `${label} must be a valid number, received '${val}'.`
+			});
+			else {
+				data[field.name] = num;
+				const min = field.min;
+				const max = field.max;
+				if (min !== void 0 && num < min) errors.push({
+					rowNumber,
+					field: field.name,
+					value: val,
+					code: "VALIDATION_RULE_FAILED",
+					reason: `${label} must be greater than or equal to ${min}.`
+				});
+				if (max !== void 0 && num > max) errors.push({
+					rowNumber,
+					field: field.name,
+					value: val,
+					code: "VALIDATION_RULE_FAILED",
+					reason: `${label} must be less than or equal to ${max}.`
+				});
+			}
+			break;
+		}
+		case "boolean":
+			if (typeof val !== "boolean") {
+				const s = String(val).toLowerCase().trim();
+				if (s === "true" || s === "1" || s === "yes") data[field.name] = true;
+				else if (s === "false" || s === "0" || s === "no") data[field.name] = false;
+				else errors.push({
+					rowNumber,
+					field: field.name,
+					value: val,
+					code: "INVALID_DATA_TYPE",
+					reason: `${label} must be a boolean (true/false), received '${val}'.`
+				});
+			}
+			break;
+		case "date": {
+			const parsed = Date.parse(String(val));
+			if (Number.isNaN(parsed)) errors.push({
+				rowNumber,
+				field: field.name,
+				value: val,
+				code: "INVALID_DATA_TYPE",
+				reason: `${label} must be a valid date, received '${val}'.`
+			});
+			break;
+		}
+		case "select": {
+			const options = field.options;
+			if (options && options.length > 0) {
+				const allowedValues = options.map((opt) => typeof opt === "object" ? String(opt.value) : String(opt));
+				if (!allowedValues.includes(String(val))) errors.push({
+					rowNumber,
+					field: field.name,
+					value: val,
+					code: "INVALID_SELECT_OPTION",
+					reason: `${label} value '${val}' is not a valid option (allowed: ${allowedValues.join(", ")}).`
+				});
+			}
+			break;
+		}
+		case "json":
+			if (typeof val === "string") try {
+				data[field.name] = JSON.parse(val);
+			} catch {
+				errors.push({
+					rowNumber,
+					field: field.name,
+					value: val,
+					code: "INVALID_DATA_TYPE",
+					reason: `${label} must be a valid JSON structure.`
+				});
+			}
+			break;
+	}
+	if (typeof field.validate === "function") try {
+		const res = field.validate(val, data);
+		if (typeof res === "string") errors.push({
+			rowNumber,
+			field: field.name,
+			value: val,
+			code: "VALIDATION_RULE_FAILED",
+			reason: res
+		});
+		else if (res === false) errors.push({
+			rowNumber,
+			field: field.name,
+			value: val,
+			code: "VALIDATION_RULE_FAILED",
+			reason: `${label} failed custom validation constraint.`
+		});
+	} catch (err) {
+		errors.push({
+			rowNumber,
+			field: field.name,
+			value: val,
+			code: "VALIDATION_RULE_FAILED",
+			reason: err instanceof Error ? err.message : String(err)
+		});
+	}
+}
+async function checkExistingUnique(storage, collectionSlug, fieldName, value) {
+	if (fieldName === "slug") return await storage.getContentBySlug(collectionSlug, String(value)) !== null;
+	return (await storage.findContent(collectionSlug, {
+		where: { [fieldName]: value },
+		limit: 1
+	})).items.length > 0;
+}
+async function checkRelationshipExists(storage, targetCollection, refId) {
+	const idStr = String(refId);
+	if (await storage.getContent(targetCollection, idStr) !== null) return true;
+	return await storage.getContentBySlug(targetCollection, idStr) !== null;
+}
+//#endregion
+//#region src/plugins/transfer/presets/hrms.ts
+/**
+* Preconfigured mapping definition for importing and exporting HRMS Employers.
+*/
+const HRMS_EMPLOYER_TRANSFER_PRESET = {
+	id: "hrms_employers_preset",
+	name: "HRMS Employers Standard Mapping",
+	collectionSlug: "employers",
+	fields: [
+		{
+			sourceField: "Company Name",
+			targetField: "companyName",
+			required: true
+		},
+		{
+			sourceField: "Legal Name",
+			targetField: "legalName"
+		},
+		{
+			sourceField: "Tax ID",
+			targetField: "taxId"
+		},
+		{
+			sourceField: "Primary Email",
+			targetField: "email",
+			transform: "trim"
+		},
+		{
+			sourceField: "Phone",
+			targetField: "phone",
+			transform: "trim"
+		},
+		{
+			sourceField: "Website",
+			targetField: "website"
+		},
+		{
+			sourceField: "Timezone",
+			targetField: "timezone",
+			defaultValue: "UTC"
+		},
+		{
+			sourceField: "Status",
+			targetField: "status",
+			defaultValue: "active"
+		}
+	],
+	options: {
+		autoGenerateSlug: true,
+		defaultStatus: "published",
+		onDuplicate: "update",
+		uniqueIdentifierField: "taxId"
+	}
+};
+/**
+* Preconfigured mapping definition for importing and exporting HRMS Employees.
+*/
+const HRMS_EMPLOYEE_TRANSFER_PRESET = {
+	id: "hrms_employees_preset",
+	name: "HRMS Employees Standard Mapping",
+	collectionSlug: "employees",
+	fields: [
+		{
+			sourceField: "Employer ID",
+			targetField: "employerId",
+			required: true
+		},
+		{
+			sourceField: "Employee Number",
+			targetField: "employeeNumber",
+			required: true,
+			transform: "trim"
+		},
+		{
+			sourceField: "First Name",
+			targetField: "firstName",
+			required: true,
+			transform: "trim"
+		},
+		{
+			sourceField: "Last Name",
+			targetField: "lastName",
+			required: true,
+			transform: "trim"
+		},
+		{
+			sourceField: "Work Email",
+			targetField: "email",
+			required: true,
+			transform: "lowercase"
+		},
+		{
+			sourceField: "Phone",
+			targetField: "phone",
+			transform: "trim"
+		},
+		{
+			sourceField: "Job Title",
+			targetField: "jobTitle"
+		},
+		{
+			sourceField: "Employment Type",
+			targetField: "employmentType",
+			defaultValue: "full_time"
+		},
+		{
+			sourceField: "Hire Date",
+			targetField: "hireDate",
+			required: true,
+			transform: "date"
+		},
+		{
+			sourceField: "Status",
+			targetField: "status",
+			defaultValue: "active"
+		}
+	],
+	options: {
+		autoGenerateSlug: true,
+		defaultStatus: "published",
+		onDuplicate: "error",
+		uniqueIdentifierField: "employeeNumber"
+	}
+};
+//#endregion
+//#region src/plugins/transfer/service.ts
+var TransferService = class {
+	engine;
+	options;
+	presets = /* @__PURE__ */ new Map();
+	constructor(engine, options = {}) {
+		this.engine = engine;
+		this.options = options;
+		this.registerPreset(HRMS_EMPLOYER_TRANSFER_PRESET);
+		this.registerPreset(HRMS_EMPLOYEE_TRANSFER_PRESET);
+	}
+	/**
+	* List all registered collections across all active plugins in the engine.
+	*/
+	listCollections() {
+		return this.engine.getCollections().map(summarizeCollection);
+	}
+	/**
+	* Get the collection schema summary for a specific collection slug.
+	*/
+	getCollectionSchema(collectionSlug) {
+		return summarizeCollection(this.getCollectionConfigOrThrow(collectionSlug));
+	}
+	/**
+	* Register a reusable data mapping preset.
+	*/
+	registerPreset(preset) {
+		const id = preset.id || `${preset.collectionSlug}_${preset.name || "preset"}`;
+		this.presets.set(id, {
+			...preset,
+			id
+		});
+	}
+	/**
+	* Get a registered preset by ID.
+	*/
+	getPreset(id) {
+		return this.presets.get(id);
+	}
+	/**
+	* Get all registered presets, optionally filtered by target collection.
+	*/
+	getPresets(collectionSlug) {
+		const all = Array.from(this.presets.values());
+		if (collectionSlug) return all.filter((p) => p.collectionSlug === collectionSlug);
+		return all;
+	}
+	/**
+	* Generate a 1:1 default mapping template for any collection.
+	*/
+	getMappingTemplate(collectionSlug) {
+		const config = this.getCollectionConfigOrThrow(collectionSlug);
+		return {
+			id: `${collectionSlug}_default_template`,
+			name: `${config.label} Default Template`,
+			collectionSlug,
+			fields: config.fields.map((f) => ({
+				sourceField: f.name,
+				targetField: f.name,
+				required: Boolean(f.required),
+				defaultValue: f.defaultValue
+			})),
+			options: {
+				autoGenerateSlug: true,
+				defaultStatus: config.draftable ? "draft" : "published",
+				onDuplicate: "error"
+			}
+		};
+	}
+	/**
+	* Inspect any source payload or file (JSON, Excel, CSV) to extract headers,
+	* infer data types, and generate auto-mapping suggestions against a target collection.
+	*/
+	async inspectSource(input, options = {}) {
+		const config = options.collectionSlug ? this.engine.getCollectionConfig(options.collectionSlug) : void 0;
+		return inspectSource(input, {
+			...options,
+			collectionConfig: config
+		});
+	}
+	/**
+	* Dry-run validation of a source batch against a target collection's schema
+	* and live database constraints without committing any changes.
+	*/
+	async validateImport(collectionSlug, input, mapping, options = {}) {
+		const config = this.getCollectionConfigOrThrow(collectionSlug);
+		const parsed = await parseSource(input, {
+			format: options.format,
+			fileName: options.fileName,
+			sheetName: options.sheetName
+		});
+		const activeMapping = mapping || this.getMappingTemplate(collectionSlug);
+		return validateTransferBatch(parsed.records, activeMapping, config, {
+			storage: this.engine.storage,
+			onDuplicate: options.onDuplicate,
+			previewLimit: options.previewLimit
+		});
+	}
+	/**
+	* Execute an import batch from raw data or an external file (JSON, Excel, CSV)
+	* into a target CMS collection.
+	*/
+	async importData(collectionSlug, input, mapping, options = {}) {
+		const config = this.getCollectionConfigOrThrow(collectionSlug);
+		const parsed = await parseSource(input, {
+			format: options.format,
+			fileName: options.fileName,
+			sheetName: options.sheetName
+		});
+		const activeMapping = mapping || this.getMappingTemplate(collectionSlug);
+		const rawRecords = parsed.records;
+		const onDuplicate = options.onDuplicate ?? activeMapping.options?.onDuplicate ?? "error";
+		const abortOnError = options.abortOnError ?? activeMapping.options?.abortOnError ?? false;
+		const validation = await validateTransferBatch(rawRecords, activeMapping, config, {
+			storage: this.engine.storage,
+			onDuplicate
+		});
+		if (options.dryRun) return {
+			success: validation.valid,
+			collectionSlug,
+			totalRows: rawRecords.length,
+			importedCount: validation.validCount,
+			updatedCount: 0,
+			skippedCount: 0,
+			failedCount: validation.errorCount,
+			createdIds: [],
+			updatedIds: [],
+			errors: validation.errors
+		};
+		if (abortOnError && !validation.valid) return {
+			success: false,
+			collectionSlug,
+			totalRows: rawRecords.length,
+			importedCount: 0,
+			updatedCount: 0,
+			skippedCount: 0,
+			failedCount: validation.errorCount,
+			createdIds: [],
+			updatedIds: [],
+			errors: validation.errors
+		};
+		await this.engine.hooks.doAction("cms.transfer_import_started", {
+			collectionSlug,
+			totalRows: rawRecords.length
+		});
+		const createdIds = [];
+		const updatedIds = [];
+		const errors = [...validation.errors];
+		let importedCount = 0;
+		let updatedCount = 0;
+		let skippedCount = 0;
+		const rowErrorsMap = /* @__PURE__ */ new Map();
+		for (const err of validation.errors) {
+			const list = rowErrorsMap.get(err.rowNumber) || [];
+			list.push(err);
+			rowErrorsMap.set(err.rowNumber, list);
+		}
+		const collService = this.engine.collection(collectionSlug);
+		for (let i = 0; i < rawRecords.length; i++) {
+			const rowNumber = i + 1;
+			const rowErrors = rowErrorsMap.get(rowNumber);
+			if (rowErrors && rowErrors.length > 0) {
+				if (rowErrors.some((e) => e.code !== "CONSTRAINT_UNIQUE_VIOLATION" || onDuplicate === "error")) continue;
+			}
+			const raw = rawRecords[i];
+			let mapped;
+			try {
+				mapped = mapSourceRecord(raw, activeMapping);
+			} catch (err) {
+				errors.push({
+					rowNumber,
+					code: "TRANSFORM_ERROR",
+					reason: err instanceof Error ? err.message : String(err)
+				});
+				continue;
+			}
+			mapped = await this.engine.hooks.applyFilters("cms.transfer_before_import_row", mapped, {
+				collectionSlug,
+				rowNumber,
+				raw
+			});
+			const identifierField = options.uniqueIdentifierField || activeMapping.options?.uniqueIdentifierField || this.detectUniqueField(config);
+			let existingItem = null;
+			if (identifierField && mapped.data[identifierField] !== void 0) {
+				const val = mapped.data[identifierField];
+				if (identifierField === "slug") existingItem = await this.engine.storage.getContentBySlug(collectionSlug, String(val));
+				else existingItem = (await this.engine.storage.findContent(collectionSlug, {
+					where: { [identifierField]: val },
+					limit: 1
+				})).items[0] || null;
+			}
+			if (existingItem) {
+				if (onDuplicate === "skip") {
+					skippedCount++;
+					continue;
+				}
+				if (onDuplicate === "update") {
+					try {
+						const updated = await collService.update(existingItem.id, {
+							title: mapped.title ?? existingItem.title,
+							slug: mapped.slug ?? existingItem.slug,
+							status: mapped.status ?? existingItem.status,
+							data: {
+								...existingItem.data,
+								...mapped.data
+							}
+						}, options.authorId, options.revisionNote || "Import transfer update");
+						if (updated) {
+							updatedIds.push(updated.id);
+							updatedCount++;
+							await this.engine.hooks.doAction("cms.transfer_row_imported", {
+								collectionSlug,
+								action: "update",
+								item: updated
+							});
+						}
+					} catch (err) {
+						errors.push({
+							rowNumber,
+							code: "VALIDATION_RULE_FAILED",
+							reason: err instanceof Error ? err.message : String(err)
+						});
+					}
+					continue;
+				}
+			}
+			try {
+				const created = await collService.create({
+					title: mapped.title,
+					slug: mapped.slug,
+					status: mapped.status,
+					data: mapped.data
+				}, options.authorId);
+				createdIds.push(created.id);
+				importedCount++;
+				await this.engine.hooks.doAction("cms.transfer_row_imported", {
+					collectionSlug,
+					action: "create",
+					item: created
+				});
+			} catch (err) {
+				errors.push({
+					rowNumber,
+					code: "VALIDATION_RULE_FAILED",
+					reason: err instanceof Error ? err.message : String(err)
+				});
+			}
+		}
+		const result = {
+			success: errors.length === 0,
+			collectionSlug,
+			totalRows: rawRecords.length,
+			importedCount,
+			updatedCount,
+			skippedCount,
+			failedCount: rawRecords.length - (importedCount + updatedCount + skippedCount),
+			createdIds,
+			updatedIds,
+			errors
+		};
+		await this.engine.hooks.doAction("cms.transfer_import_completed", result);
+		await this.engine.hooks.doAction(`cms.${collectionSlug}_transferred`, result);
+		return result;
+	}
+	/**
+	* Export CMS collection records to JSON, Excel (.xlsx), or CSV.
+	*/
+	async exportData(collectionSlug, options = {}) {
+		const config = this.getCollectionConfigOrThrow(collectionSlug);
+		const collService = this.engine.collection(collectionSlug);
+		const query = options.query || { limit: 1e4 };
+		const items = (await collService.find(query)).items;
+		const exportRecords = [];
+		for (const item of items) {
+			let mappedRow = mapCmsItemForExport(item, options.mapping, {
+				includeId: options.includeId,
+				includeTimestamps: options.includeTimestamps
+			});
+			mappedRow = await this.engine.hooks.applyFilters("cms.transfer_before_export_row", mappedRow, {
+				collectionSlug,
+				item
+			});
+			exportRecords.push(mappedRow);
+		}
+		return serializeSource(exportRecords, {
+			format: options.format || "json",
+			fileName: options.fileName || `${collectionSlug}_export_${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
+			sheetName: options.sheetName || config.label
+		});
+	}
+	getCollectionConfigOrThrow(collectionSlug) {
+		const config = this.engine.getCollectionConfig(collectionSlug);
+		if (!config) throw new Error(`[TransferService] Collection '${collectionSlug}' is not registered in the CMS engine.`);
+		return config;
+	}
+	detectUniqueField(config) {
+		const unique = config.fields.find((f) => Boolean(f.unique));
+		if (unique) return unique.name;
+		const slugField = config.fields.find((f) => f.type === "slug" || f.name === "slug");
+		if (slugField) return slugField.name;
+	}
+};
+//#endregion
+//#region src/plugins/transfer/routes.ts
+function json(data, status = 200, headers = {}) {
+	return new Response(JSON.stringify(data), {
+		status,
+		headers: {
+			"Content-Type": "application/json",
+			"Access-Control-Allow-Origin": "*",
+			...headers
+		}
+	});
+}
+function badRequest(message) {
+	return json({ error: message }, 400);
+}
+function notFound(message) {
+	return json({ error: message }, 404);
+}
+function registerTransferRoutes(ctx, service, options = {}) {
+	const prefix = (options.apiPrefix ?? "/api/transfer").replace(/\/+$/, "");
+	ctx.registerRoute("GET", `${prefix}/collections`, async () => {
+		try {
+			return json({ collections: service.listCollections() });
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/presets`, async (_req, { url }) => {
+		try {
+			const collectionSlug = url.searchParams.get("collection") || void 0;
+			return json({ presets: service.getPresets(collectionSlug) });
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/presets`, async (req) => {
+		try {
+			const body = await req.json();
+			if (!body.collectionSlug || !Array.isArray(body.fields)) return badRequest("collectionSlug and fields array are required.");
+			service.registerPreset(body);
+			return json({
+				success: true,
+				preset: body
+			}, 201);
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/:collection/schema`, async (_req, { params }) => {
+		try {
+			return json({
+				schema: service.getCollectionSchema(params.collection),
+				template: service.getMappingTemplate(params.collection)
+			});
+		} catch (err) {
+			return notFound(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/inspect`, async (req) => {
+		try {
+			const payload = await extractPayload(req);
+			return json(await service.inspectSource(payload.data, {
+				collectionSlug: payload.collectionSlug,
+				format: payload.format,
+				fileName: payload.fileName,
+				sheetName: payload.sheetName
+			}));
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/:collection/preview`, async (req, { params }) => {
+		try {
+			const payload = await extractPayload(req);
+			return json(await service.validateImport(params.collection, payload.data, payload.mapping, {
+				format: payload.format,
+				fileName: payload.fileName,
+				sheetName: payload.sheetName,
+				onDuplicate: payload.onDuplicate
+			}));
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/:collection/import`, async (req, { params }) => {
+		try {
+			const payload = await extractPayload(req);
+			const result = await service.importData(params.collection, payload.data, payload.mapping, {
+				format: payload.format,
+				fileName: payload.fileName,
+				sheetName: payload.sheetName,
+				onDuplicate: payload.onDuplicate,
+				uniqueIdentifierField: payload.uniqueIdentifierField,
+				abortOnError: payload.abortOnError,
+				authorId: payload.authorId,
+				revisionNote: payload.revisionNote
+			});
+			return json(result, result.success ? 200 : 207);
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("POST", `${prefix}/:collection/export`, async (req, { params }) => {
+		try {
+			const body = await req.json();
+			const result = await service.exportData(params.collection, {
+				format: body.format,
+				mapping: body.mapping,
+				query: body.query,
+				fileName: body.fileName,
+				sheetName: body.sheetName,
+				includeId: body.includeId,
+				includeTimestamps: body.includeTimestamps
+			});
+			return new Response(result.data, {
+				status: 200,
+				headers: {
+					"Content-Type": result.mimeType,
+					"Content-Disposition": `attachment; filename="${result.fileName}"`,
+					"Access-Control-Allow-Origin": "*"
+				}
+			});
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+	ctx.registerRoute("GET", `${prefix}/:collection/export`, async (_req, { params, url }) => {
+		try {
+			const format = url.searchParams.get("format") || "json";
+			const fileName = url.searchParams.get("fileName") || void 0;
+			const status = url.searchParams.get("status") || void 0;
+			const search = url.searchParams.get("search") || void 0;
+			const result = await service.exportData(params.collection, {
+				format,
+				fileName,
+				query: {
+					status,
+					search
+				}
+			});
+			return new Response(result.data, {
+				status: 200,
+				headers: {
+					"Content-Type": result.mimeType,
+					"Content-Disposition": `attachment; filename="${result.fileName}"`,
+					"Access-Control-Allow-Origin": "*"
+				}
+			});
+		} catch (err) {
+			return badRequest(err instanceof Error ? err.message : String(err));
+		}
+	});
+}
+/**
+* Helper to extract payload and options from JSON or Multipart requests.
+*/
+async function extractPayload(req) {
+	if ((req.headers.get("content-type") || "").includes("multipart/form-data")) {
+		const formData = await req.formData();
+		const file = formData.get("file");
+		let data = null;
+		let fileName;
+		if (file && typeof file === "object" && "arrayBuffer" in file) {
+			data = new Uint8Array(await file.arrayBuffer());
+			fileName = file.name;
+		}
+		const mappingRaw = formData.get("mapping");
+		const mapping = mappingRaw ? JSON.parse(String(mappingRaw)) : void 0;
+		return {
+			data,
+			collectionSlug: formData.get("collectionSlug") || void 0,
+			format: formData.get("format") || void 0,
+			fileName: formData.get("fileName") || fileName,
+			sheetName: formData.get("sheetName") || void 0,
+			mapping,
+			onDuplicate: formData.get("onDuplicate") || void 0,
+			uniqueIdentifierField: formData.get("uniqueIdentifierField") || void 0,
+			abortOnError: formData.get("abortOnError") === "true",
+			authorId: formData.get("authorId") || void 0,
+			revisionNote: formData.get("revisionNote") || void 0
+		};
+	}
+	const body = await req.json();
+	let data = body.data;
+	if (typeof body.base64 === "string") data = Buffer.from(body.base64, "base64");
+	return {
+		data: data !== void 0 ? data : body,
+		collectionSlug: body.collectionSlug,
+		format: body.format,
+		fileName: body.fileName,
+		sheetName: body.sheetName,
+		mapping: body.mapping,
+		onDuplicate: body.onDuplicate,
+		uniqueIdentifierField: body.uniqueIdentifierField,
+		abortOnError: body.abortOnError,
+		authorId: body.authorId,
+		revisionNote: body.revisionNote
+	};
+}
+//#endregion
+//#region src/plugins/transfer/client.ts
+var TransferClient = class {
+	client;
+	options;
+	service;
+	prefix;
+	constructor(client, options = {}) {
+		this.client = client;
+		this.options = options;
+		this.prefix = (options.apiPrefix ?? "/api/transfer").replace(/\/+$/, "");
+		const engine = client.getEngine();
+		if (engine) this.service = new TransferService(engine, options);
+	}
+	/**
+	* List all registered collections across all active plugins.
+	*/
+	async listCollections() {
+		if (this.service) return this.service.listCollections();
+		return (await this.client.request(`${this.prefix}/collections`)).collections;
+	}
+	/**
+	* Get the collection schema and default mapping template.
+	*/
+	async getSchema(collectionSlug) {
+		if (this.service) return {
+			schema: this.service.getCollectionSchema(collectionSlug),
+			template: this.service.getMappingTemplate(collectionSlug)
+		};
+		return this.client.request(`${this.prefix}/${collectionSlug}/schema`);
+	}
+	/**
+	* Inspect a source file or payload.
+	*/
+	async inspect(data, options = {}) {
+		if (this.service) return this.service.inspectSource(data, options);
+		return this.client.request(`${this.prefix}/inspect`, {
+			method: "POST",
+			body: JSON.stringify({
+				data,
+				...options
+			})
+		});
+	}
+	/**
+	* Dry-run validation of a source batch against a target collection and database constraints.
+	*/
+	async preview(collectionSlug, data, mapping, options = {}) {
+		if (this.service) return this.service.validateImport(collectionSlug, data, mapping, options);
+		return this.client.request(`${this.prefix}/${collectionSlug}/preview`, {
+			method: "POST",
+			body: JSON.stringify({
+				data,
+				mapping,
+				...options
+			})
+		});
+	}
+	/**
+	* Execute an import batch into a target collection.
+	*/
+	async import(collectionSlug, data, mapping, options = {}) {
+		if (this.service) return this.service.importData(collectionSlug, data, mapping, options);
+		return this.client.request(`${this.prefix}/${collectionSlug}/import`, {
+			method: "POST",
+			body: JSON.stringify({
+				data,
+				mapping,
+				...options
+			})
+		});
+	}
+	/**
+	* Export collection records to JSON, Excel, or CSV.
+	*/
+	async export(collectionSlug, options = {}) {
+		if (this.service) return this.service.exportData(collectionSlug, options);
+		return await this.client.request(`${this.prefix}/${collectionSlug}/export`, {
+			method: "POST",
+			body: JSON.stringify(options)
+		});
+	}
+};
+/**
+* Access or instantiate the TransferClient associated with a CMSClient instance.
+*/
+function getTransferClient(client, options) {
+	if (client.__transferClient) return client.__transferClient;
+	const tc = new TransferClient(client, options);
+	client.__transferClient = tc;
+	return tc;
+}
+//#endregion
+//#region src/plugins/transfer/index.ts
+/**
+* @azlib/cms - Built-in Universal Transfer Plugin
+*/
+/**
+* Built-in Universal Data Transfer plugin factory for @azlib/cms.
+* Equips the CMS engine with dynamic, schema-driven import and export capabilities
+* across all collections, featuring file schema discovery, definition mapping,
+* multi-level data validation, database constraint verification, and multi-format support.
+*/
+const transferPlugin = definePlugin((options) => {
+	const opts = options || {};
+	return {
+		name: "transfer",
+		version: "1.0.0",
+		description: "Universal schema-driven data transfer plugin supporting import/export, definition mapping, and constraint validation",
+		setup(ctx) {
+			const service = new TransferService(ctx.engine, opts);
+			ctx.engine.__transferService = service;
+			if (opts.enableRoutes !== false) registerTransferRoutes(ctx, service, opts);
+		}
+	};
+});
+/**
+* Retrieve the active TransferService instance associated with a CMSEngine.
+*/
+function getTransferService(engine, options) {
+	if (engine.__transferService) return engine.__transferService;
+	const service = new TransferService(engine, options);
+	engine.__transferService = service;
+	return service;
+}
+//#endregion
 exports.CMSClient = CMSClient;
 exports.CMSEngine = CMSEngine;
 exports.CMSRouter = CMSRouter;
@@ -4836,6 +6664,8 @@ exports.EcommerceClient = EcommerceClient;
 exports.EcommerceService = EcommerceService;
 exports.HRMSClient = HRMSClient;
 exports.HRMSService = HRMSService;
+exports.HRMS_EMPLOYEE_TRANSFER_PRESET = HRMS_EMPLOYEE_TRANSFER_PRESET;
+exports.HRMS_EMPLOYER_TRANSFER_PRESET = HRMS_EMPLOYER_TRANSFER_PRESET;
 exports.HooksManager = HooksManager;
 exports.MediaManager = MediaManager;
 exports.MemoryStorageAdapter = MemoryStorageAdapter;
@@ -4843,7 +6673,10 @@ exports.OptionsManager = OptionsManager;
 exports.RBACManager = RBACManager;
 exports.RevisionManager = RevisionManager;
 exports.TaxonomyManager = TaxonomyManager;
+exports.TransferClient = TransferClient;
+exports.TransferService = TransferService;
 exports.VALID_STATUS_TRANSITIONS = VALID_STATUS_TRANSITIONS;
+exports.applyFieldTransform = applyFieldTransform;
 exports.collection = collection;
 exports.createAttendanceCollection = createAttendanceCollection;
 exports.createCMSEngine = createCMSEngine;
@@ -4861,14 +6694,32 @@ exports.createProductCollection = createProductCollection;
 exports.defaultHooks = defaultHooks;
 exports.defineConfig = defineConfig;
 exports.definePlugin = definePlugin;
+exports.detectFormat = detectFormat;
 exports.ecommercePlugin = ecommercePlugin;
 exports.fields = fields;
+exports.generateSuggestedMapping = generateSuggestedMapping;
 exports.getEcommerceClient = getEcommerceClient;
 exports.getEcommerceService = getEcommerceService;
 exports.getHRMSClient = getHRMSClient;
 exports.getHRMSService = getHRMSService;
+exports.getTransferClient = getTransferClient;
+exports.getTransferService = getTransferService;
 exports.hrmsPlugin = hrmsPlugin;
+exports.inspectSource = inspectSource;
+exports.mapCmsItemForExport = mapCmsItemForExport;
+exports.mapSourceRecord = mapSourceRecord;
 exports.normalizeConfig = normalizeConfig;
+exports.parseCsvSource = parseCsvSource;
+exports.parseExcelSource = parseExcelSource;
+exports.parseJsonSource = parseJsonSource;
+exports.parseSource = parseSource;
 exports.resolveUniqueSlug = resolveUniqueSlug;
+exports.serializeCsv = serializeCsv;
+exports.serializeExcel = serializeExcel;
+exports.serializeJson = serializeJson;
+exports.serializeSource = serializeSource;
 exports.slugify = slugify;
+exports.summarizeCollection = summarizeCollection;
+exports.transferPlugin = transferPlugin;
 exports.validateAndNormalizeData = validateAndNormalizeData;
+exports.validateTransferBatch = validateTransferBatch;