@7365admin1/module-hygiene 4.0.0 → 4.2.0

package/dist/index.mjs

@@ -2273,7 +2273,8 @@ var areaChecklistSchema = Joi8.object({
         }).required()
       ).min(1).required()
     }).required()
-  ).optional().default([])
+  ).optional().default([]),
+  createdBy: Joi8.string().hex().required()
 });
 function MAreaChecklist(value) {
   const { error } = areaChecklistSchema.validate(value);
@@ -2310,6 +2311,13 @@ function MAreaChecklist(value) {
       };
     });
   }
+  if (value.createdBy) {
+    try {
+      value.createdBy = new ObjectId8(value.createdBy);
+    } catch (error2) {
+      throw new BadRequestError14("Invalid createdBy ID format.");
+    }
+  }
   return {
     schedule: value.schedule,
     area: value.area,
@@ -2317,6 +2325,7 @@ function MAreaChecklist(value) {
     type: value.type,
     checklist: value.checklist || [],
     status: "ready",
+    createdBy: value.createdBy,
     createdAt: /* @__PURE__ */ new Date(),
     completedAt: "",
     updatedAt: ""
@@ -2455,6 +2464,32 @@ function useAreaChecklistRepo() {
     try {
       const pipeline = [
         { $match: query },
+        {
+          $lookup: {
+            from: "users",
+            let: { createdById: "$createdBy" },
+            pipeline: [
+              {
+                $match: {
+                  $expr: {
+                    $and: [
+                      { $ne: ["$$createdById", ""] },
+                      { $eq: ["$_id", "$$createdById"] }
+                    ]
+                  }
+                }
+              },
+              { $project: { name: 1 } }
+            ],
+            as: "createdByDoc"
+          }
+        },
+        {
+          $unwind: {
+            path: "$createdByDoc",
+            preserveNullAndEmptyArrays: true
+          }
+        },
         {
           $project: {
             name: 1,
@@ -2486,7 +2521,8 @@ function useAreaChecklistRepo() {
                 },
                 else: 0
               }
-            }
+            },
+            createdByName: "$createdByDoc.name"
           }
         },
         { $sort: { _id: -1 } },
@@ -3119,7 +3155,8 @@ function useAreaChecklistService() {
                   unit: unit.unit.toString(),
                   name: unit.name
                 }))
-              }))
+              })),
+              createdBy: value.createdBy
             };
             const insertedId = await _createAreaChecklist(
               checklistData,
@@ -3254,13 +3291,20 @@ function useAreaChecklistController() {
     completeAreaChecklistUnits: _completeAreaChecklistUnits
   } = useAreaChecklistService();
   async function createAreaChecklist(req, res, next) {
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value2]) => ({ ...acc, [key]: value2 }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
     const payload = {
       site: req.params.site,
-      schedule: req.params.schedule
+      schedule: req.params.schedule,
+      createdBy
     };
     const validation = Joi9.object({
       site: Joi9.string().hex().required(),
-      schedule: Joi9.string().hex().required()
+      schedule: Joi9.string().hex().required(),
+      createdBy: Joi9.string().hex().required()
     });
     const { error, value } = validation.validate(payload);
     if (error) {
@@ -4069,10 +4113,15 @@ import {
 function useStockService() {
   const { createStock: _createStock } = useStockRepository();
   const { getSupplyById, updateSupply } = useSupplyRepository();
-  async function createStock(value, out = false) {
-    const session = useAtlas10.getClient()?.startSession();
+  async function createStock(value, out = false, session) {
+    let ownSession = false;
+    if (!session) {
+      session = useAtlas10.getClient()?.startSession();
+      ownSession = true;
+    }
     try {
-      session?.startTransaction();
+      if (ownSession)
+        session?.startTransaction();
       const { qty, ...stockData } = value;
       const supply = await getSupplyById(value.supply, session);
       if (!supply || supply.qty === void 0) {
@@ -4094,13 +4143,16 @@ function useStockService() {
         },
         session
       );
-      await session?.commitTransaction();
+      if (ownSession)
+        await session?.commitTransaction();
       return createdStock;
     } catch (error) {
-      await session?.abortTransaction();
+      if (ownSession)
+        await session?.abortTransaction();
       throw error;
     } finally {
-      await session?.endSession();
+      if (ownSession)
+        await session?.endSession();
     }
   }
   return { createStock };
@@ -4789,28 +4841,24 @@ function useRequestItemController() {
   };
 }
 
-// src/models/hygiene-schedule-task.model.ts
-import { BadRequestError as BadRequestError28, logger as logger27 } from "@7365admin1/node-server-utils";
+// src/models/hygiene-checkout-item.model.ts
 import Joi16 from "joi";
 import { ObjectId as ObjectId16 } from "mongodb";
-var scheduleTaskSchema = Joi16.object({
+import { BadRequestError as BadRequestError28, logger as logger27 } from "@7365admin1/node-server-utils";
+var allowedCheckOutItemStatus = ["pending", "completed"];
+var checkOutItemSchema = Joi16.object({
   site: Joi16.string().hex().required(),
-  title: Joi16.string().required(),
-  time: Joi16.string().pattern(/^([0-1]\d|2[0-3]):([0-5]\d)$/).required(),
-  startDate: Joi16.string().pattern(/^\d{4}-\d{2}-\d{2}$/).required(),
-  endDate: Joi16.string().pattern(/^\d{4}-\d{2}-\d{2}$/).optional().allow("", null),
-  description: Joi16.string().optional().allow("", null),
-  areas: Joi16.array().min(1).items(
-    Joi16.object({
-      name: Joi16.string().required(),
-      value: Joi16.any().required()
-    })
-  ).required()
+  supply: Joi16.string().hex().required(),
+  supplyName: Joi16.string().required(),
+  qty: Joi16.number().min(0).required(),
+  attachment: Joi16.string().optional().allow("", null),
+  createdBy: Joi16.string().hex().required(),
+  createdByName: Joi16.string().required()
 });
-function MScheduleTask(value) {
-  const { error } = scheduleTaskSchema.validate(value);
+function MCheckOutItem(value) {
+  const { error } = checkOutItemSchema.validate(value);
   if (error) {
-    logger27.info(`Hygiene Schedule Task Model: ${error.message}`);
+    logger27.info(`Hygiene Check Out Item Model: ${error.message}`);
     throw new BadRequestError28(error.message);
   }
   if (value.site) {
@@ -4820,18 +4868,557 @@ function MScheduleTask(value) {
       throw new BadRequestError28("Invalid site ID format.");
     }
   }
+  if (value.supply) {
+    try {
+      value.supply = new ObjectId16(value.supply);
+    } catch (error2) {
+      throw new BadRequestError28("Invalid supply ID format.");
+    }
+  }
+  return {
+    site: value.site,
+    supply: value.supply,
+    supplyName: value.supplyName,
+    qty: value.qty,
+    attachment: "",
+    createdBy: value.createdBy,
+    createdByName: value.createdByName,
+    status: "pending",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: "",
+    deletedAt: ""
+  };
+}
+
+// src/repositories/hygiene-checkout-item.repository.ts
+import { ObjectId as ObjectId17 } from "mongodb";
+import {
+  useAtlas as useAtlas13,
+  InternalServerError as InternalServerError9,
+  useCache as useCache9,
+  logger as logger28,
+  makeCacheKey as makeCacheKey9,
+  paginate as paginate8,
+  BadRequestError as BadRequestError29,
+  NotFoundError as NotFoundError7
+} from "@7365admin1/node-server-utils";
+function useCheckOutItemRepository() {
+  const db = useAtlas13.getDb();
+  if (!db) {
+    throw new InternalServerError9("Unable to connect to server.");
+  }
+  const namespace_collection = "site.supply.checkouts";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace, setCache, getCache } = useCache9(namespace_collection);
+  async function createIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { site: 1 } },
+        { key: { supply: 1 } },
+        { key: { status: 1 } }
+      ]);
+    } catch (error) {
+      throw new InternalServerError9(
+        "Failed to create index on hygiene check out item."
+      );
+    }
+  }
+  async function createTextIndex() {
+    try {
+      await collection.createIndex({ supplyName: "text" });
+    } catch (error) {
+      throw new InternalServerError9(
+        "Failed to create text index on hygiene supply."
+      );
+    }
+  }
+  async function createCheckOutItem(value, session) {
+    try {
+      value = MCheckOutItem(value);
+      const res = await collection.insertOne(value, { session });
+      delNamespace().then(() => {
+        logger28.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger28.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.insertedId;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getCheckOutItems({
+    page = 1,
+    limit = 10,
+    search = "",
+    site
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      status: { $ne: "deleted" }
+    };
+    const cacheOptions = {
+      page,
+      limit
+    };
+    try {
+      site = new ObjectId17(site);
+      query.site = site;
+      cacheOptions.site = site.toString();
+    } catch (error) {
+      throw new BadRequestError29("Invalid site ID format.");
+    }
+    if (search) {
+      query.$text = { $search: search };
+      cacheOptions.search = search;
+    }
+    const cacheKey = makeCacheKey9(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      logger28.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const items = await collection.aggregate([
+        { $match: query },
+        {
+          $lookup: {
+            from: "site.supplies",
+            let: { supplyId: "$supply" },
+            pipeline: [
+              {
+                $match: {
+                  $expr: {
+                    $and: [
+                      { $ne: ["$$supplyId", ""] },
+                      { $eq: ["$_id", "$$supplyId"] }
+                    ]
+                  }
+                }
+              },
+              { $project: { qty: 1 } }
+            ],
+            as: "supplyDoc"
+          }
+        },
+        {
+          $unwind: {
+            path: "$supplyDoc",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $lookup: {
+            from: "users",
+            let: { createdById: "$createdBy" },
+            pipeline: [
+              {
+                $match: {
+                  $expr: {
+                    $and: [
+                      { $ne: ["$$createdById", ""] },
+                      { $eq: ["$_id", "$$createdById"] }
+                    ]
+                  }
+                }
+              },
+              { $project: { name: 1 } }
+            ],
+            as: "createdByDoc"
+          }
+        },
+        {
+          $unwind: {
+            path: "$createdByDoc",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $project: {
+            supplyName: 1,
+            supplyQty: "$supplyDoc.qty",
+            checkOutByName: "$createdByDoc.name",
+            checkOutQty: "$qty",
+            createdAt: 1,
+            status: 1
+          }
+        },
+        { $sort: { _id: -1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = paginate8(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        logger28.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        logger28.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getCheckOutItemById(_id, session) {
+    try {
+      _id = new ObjectId17(_id);
+    } catch (error) {
+      throw new BadRequestError29("Invalid check out item ID format.");
+    }
+    const query = { _id };
+    const cacheKey = makeCacheKey9(namespace_collection, {
+      _id: _id.toString()
+    });
+    if (!session) {
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        logger28.info(`Cache hit for key: ${cacheKey}`);
+        return cachedData;
+      }
+    } else {
+      logger28.info(`Skipping cache during transaction for key: ${cacheKey}`);
+    }
+    try {
+      const data = await collection.aggregate([
+        { $match: query },
+        {
+          $lookup: {
+            from: "site.supply.items",
+            localField: "supply",
+            foreignField: "_id",
+            as: "supplyDetails"
+          }
+        },
+        {
+          $unwind: {
+            path: "$supplyDetails",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $project: {
+            site: 1,
+            supply: 1,
+            supplyName: 1,
+            qty: 1,
+            status: 1,
+            unitOfMeasurement: "$supplyDetails.unitOfMeasurement"
+          }
+        }
+      ]).toArray();
+      if (!data || data.length === 0) {
+        throw new NotFoundError7("Check out item not found.");
+      }
+      setCache(cacheKey, data[0], 15 * 60).then(() => {
+        logger28.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        logger28.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data[0];
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    createIndex,
+    createTextIndex,
+    createCheckOutItem,
+    getCheckOutItems,
+    getCheckOutItemById
+  };
+}
+
+// src/services/hygiene-checkout-item.service.ts
+import { useUserRepo as useUserRepo2 } from "@7365admin1/core";
+import { BadRequestError as BadRequestError30, useAtlas as useAtlas14 } from "@7365admin1/node-server-utils";
+function useCheckOutItemService() {
+  const {
+    createCheckOutItem: _createCheckOutItem,
+    getCheckOutItemById: _getCheckOutItemById
+  } = useCheckOutItemRepository();
+  const { getSupplyById } = useSupplyRepository();
+  const { getUserById } = useUserRepo2();
+  const { createStock } = useStockService();
+  async function createCheckOutItem(value) {
+    const session = useAtlas14.getClient()?.startSession();
+    try {
+      session?.startTransaction();
+      const supplyData = await getSupplyById(value.supply);
+      const createdByData = await getUserById(value.createdBy);
+      const checkOutItemId = await _createCheckOutItem(
+        {
+          ...value,
+          supplyName: supplyData?.name || "",
+          createdByName: createdByData?.name || ""
+        },
+        session
+      );
+      const checkOutItem = await _getCheckOutItemById(checkOutItemId, session);
+      if (!checkOutItem) {
+        throw new BadRequestError30("Failed to create check out item.");
+      }
+      const createdStocks = await createStock(
+        {
+          site: checkOutItem.site.toString(),
+          supply: checkOutItem.supply.toString(),
+          qty: checkOutItem.qty
+        },
+        true,
+        session
+      );
+      await session?.commitTransaction();
+      return createdStocks;
+    } catch (error) {
+      await session?.abortTransaction();
+      throw error;
+    } finally {
+      await session?.endSession();
+    }
+  }
+  async function createCheckOutItemByBatch(value) {
+    const session = useAtlas14.getClient()?.startSession();
+    try {
+      session?.startTransaction();
+      const { site, createdBy, items } = value;
+      const createdByData = await getUserById(createdBy);
+      const createdCheckOutItemIds = [];
+      for (const item of items) {
+        const supplyData = await getSupplyById(item.supply, session);
+        const createdId = await _createCheckOutItem(
+          {
+            site,
+            supply: item.supply,
+            supplyName: supplyData?.name || "",
+            qty: item.qty,
+            attachment: item.attachment || "",
+            createdBy,
+            createdByName: createdByData?.name || ""
+          },
+          session
+        );
+        await createStock(
+          {
+            site,
+            supply: item.supply,
+            qty: item.qty
+          },
+          true,
+          session
+        );
+        createdCheckOutItemIds.push(createdId);
+      }
+      await session?.commitTransaction();
+      return createdCheckOutItemIds;
+    } catch (error) {
+      await session?.abortTransaction();
+      throw error;
+    } finally {
+      await session?.endSession();
+    }
+  }
+  return {
+    createCheckOutItem,
+    createCheckOutItemByBatch
+  };
+}
+
+// src/controllers/hygiene-checkout-item.controller.ts
+import Joi17 from "joi";
+import { BadRequestError as BadRequestError31, logger as logger29 } from "@7365admin1/node-server-utils";
+function useCheckOutItemController() {
+  const {
+    getCheckOutItems: _getCheckOutItems,
+    getCheckOutItemById: _getCheckOutItemById
+  } = useCheckOutItemRepository();
+  const {
+    createCheckOutItem: _createCheckOutItem,
+    createCheckOutItemByBatch: _createCheckOutItemByBatch
+  } = useCheckOutItemService();
+  async function createCheckOutItem(req, res, next) {
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const payload = {
+      ...req.body,
+      ...req.params,
+      createdBy
+    };
+    const validation = Joi17.object({
+      site: Joi17.string().hex().required(),
+      supply: Joi17.string().hex().required(),
+      qty: Joi17.number().min(0).required(),
+      attachment: Joi17.string().optional().allow("", null),
+      createdBy: Joi17.string().hex().required()
+    });
+    const { error } = validation.validate(payload);
+    if (error) {
+      logger29.log({ level: "error", message: error.message });
+      next(new BadRequestError31(error.message));
+      return;
+    }
+    try {
+      const id = await _createCheckOutItem(payload);
+      res.status(201).json({ message: "Check out item created successfully.", id });
+      return;
+    } catch (error2) {
+      logger29.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function createCheckOutItemByBatch(req, res, next) {
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const payload = {
+      ...req.body,
+      ...req.params,
+      createdBy
+    };
+    const validation = Joi17.object({
+      site: Joi17.string().hex().required(),
+      createdBy: Joi17.string().hex().required(),
+      items: Joi17.array().items(
+        Joi17.object({
+          supply: Joi17.string().hex().required(),
+          qty: Joi17.number().min(0).required(),
+          attachment: Joi17.string().optional().allow("", null)
+        })
+      ).min(1).required()
+    });
+    const { error } = validation.validate(payload);
+    if (error) {
+      logger29.log({ level: "error", message: error.message });
+      next(new BadRequestError31(error.message));
+      return;
+    }
+    try {
+      await _createCheckOutItemByBatch(payload);
+      res.status(201).json({ message: "Check out items created successfully." });
+      return;
+    } catch (error2) {
+      logger29.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getCheckOutItems(req, res, next) {
+    const query = { ...req.query, ...req.params };
+    const validation = Joi17.object({
+      page: Joi17.number().min(1).optional().allow("", null),
+      limit: Joi17.number().min(1).optional().allow("", null),
+      search: Joi17.string().optional().allow("", null),
+      site: Joi17.string().hex().required()
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      logger29.log({ level: "error", message: error.message });
+      next(new BadRequestError31(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    const limit = parseInt(req.query.limit) ?? 10;
+    const search = req.query.search ?? "";
+    const site = req.params.site ?? "";
+    try {
+      const data = await _getCheckOutItems({
+        page,
+        limit,
+        search,
+        site
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      logger29.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getCheckOutItemById(req, res, next) {
+    const validation = Joi17.string().hex().required();
+    const _id = req.params.id;
+    const { error, value } = validation.validate(_id);
+    if (error) {
+      logger29.log({ level: "error", message: error.message });
+      next(new BadRequestError31(error.message));
+      return;
+    }
+    try {
+      const data = await _getCheckOutItemById(value);
+      res.json(data);
+      return;
+    } catch (error2) {
+      logger29.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  return {
+    createCheckOutItem,
+    createCheckOutItemByBatch,
+    getCheckOutItems,
+    getCheckOutItemById
+  };
+}
+
+// src/models/hygiene-schedule-task.model.ts
+import { BadRequestError as BadRequestError32, logger as logger30 } from "@7365admin1/node-server-utils";
+import Joi18 from "joi";
+import { ObjectId as ObjectId18 } from "mongodb";
+var scheduleTaskSchema = Joi18.object({
+  site: Joi18.string().hex().required(),
+  title: Joi18.string().required(),
+  time: Joi18.string().pattern(/^([0-1]\d|2[0-3]):([0-5]\d)$/).required(),
+  startDate: Joi18.string().pattern(/^\d{4}-\d{2}-\d{2}$/).required(),
+  endDate: Joi18.string().pattern(/^\d{4}-\d{2}-\d{2}$/).optional().allow("", null),
+  description: Joi18.string().optional().allow("", null),
+  areas: Joi18.array().min(1).items(
+    Joi18.object({
+      name: Joi18.string().required(),
+      value: Joi18.any().required()
+    })
+  ).required(),
+  createdBy: Joi18.string().hex().required()
+});
+function MScheduleTask(value) {
+  const { error } = scheduleTaskSchema.validate(value);
+  if (error) {
+    logger30.info(`Hygiene Schedule Task Model: ${error.message}`);
+    throw new BadRequestError32(error.message);
+  }
+  if (value.site) {
+    try {
+      value.site = new ObjectId18(value.site);
+    } catch (error2) {
+      throw new BadRequestError32("Invalid site ID format.");
+    }
+  }
   if (value.areas && Array.isArray(value.areas)) {
     value.areas = value.areas.map((area) => {
       try {
         return {
           name: area.name,
-          value: new ObjectId16(area.value.toString())
+          value: new ObjectId18(area.value.toString())
         };
       } catch (error2) {
-        throw new BadRequestError28(`Invalid area value format: ${area.name}`);
+        throw new BadRequestError32(`Invalid area value format: ${area.name}`);
       }
     });
   }
+  if (value.createdBy) {
+    try {
+      value.createdBy = new ObjectId18(value.createdBy);
+    } catch (error2) {
+      throw new BadRequestError32("Invalid createdBy ID format.");
+    }
+  }
   return {
     site: value.site,
     title: value.title,
@@ -4841,6 +5428,7 @@ function MScheduleTask(value) {
     description: value.description,
     areas: value.areas,
     status: "active",
+    createdBy: value.createdBy,
     createdAt: /* @__PURE__ */ new Date(),
     updatedAt: "",
     deletedAt: ""
@@ -4848,25 +5436,25 @@ function MScheduleTask(value) {
 }
 
 // src/repositories/hygiene-schedule-task.repository.ts
-import { ObjectId as ObjectId17 } from "mongodb";
+import { ObjectId as ObjectId19 } from "mongodb";
 import {
-  useAtlas as useAtlas13,
-  InternalServerError as InternalServerError9,
-  paginate as paginate8,
-  BadRequestError as BadRequestError29,
-  useCache as useCache9,
-  logger as logger28,
-  makeCacheKey as makeCacheKey9,
-  NotFoundError as NotFoundError7
+  useAtlas as useAtlas15,
+  InternalServerError as InternalServerError10,
+  paginate as paginate9,
+  BadRequestError as BadRequestError33,
+  useCache as useCache10,
+  logger as logger31,
+  makeCacheKey as makeCacheKey10,
+  NotFoundError as NotFoundError8
 } from "@7365admin1/node-server-utils";
 function useScheduleTaskRepository() {
-  const db = useAtlas13.getDb();
+  const db = useAtlas15.getDb();
   if (!db) {
-    throw new InternalServerError9("Unable to connect to server.");
+    throw new InternalServerError10("Unable to connect to server.");
   }
   const namespace_collection = "site.schedule-tasks";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, setCache, getCache } = useCache9(namespace_collection);
+  const { delNamespace, setCache, getCache } = useCache10(namespace_collection);
   async function createIndex() {
     try {
       await collection.createIndexes([
@@ -4874,7 +5462,7 @@ function useScheduleTaskRepository() {
         { key: { status: 1 } }
       ]);
     } catch (error) {
-      throw new InternalServerError9(
+      throw new InternalServerError10(
         "Failed to create index on hygiene schedule task."
       );
     }
@@ -4883,7 +5471,7 @@ function useScheduleTaskRepository() {
     try {
       await collection.createIndex({ title: "text", description: "text" });
     } catch (error) {
-      throw new InternalServerError9(
+      throw new InternalServerError10(
         "Failed to create text index on hygiene schedule task."
       );
     }
@@ -4893,9 +5481,9 @@ function useScheduleTaskRepository() {
       value = MScheduleTask(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        logger28.info(`Cache cleared for namespace: ${namespace_collection}`);
+        logger31.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        logger28.error(
+        logger31.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -4920,20 +5508,20 @@ function useScheduleTaskRepository() {
       limit
     };
     try {
-      site = new ObjectId17(site);
+      site = new ObjectId19(site);
       query.site = site;
       cacheOptions.site = site.toString();
     } catch (error) {
-      throw new BadRequestError29("Invalid site ID format.");
+      throw new BadRequestError33("Invalid site ID format.");
     }
     if (search) {
       query.$or = [{ name: { $regex: search, $options: "i" } }];
       cacheOptions.search = search;
     }
-    const cacheKey = makeCacheKey9(namespace_collection, cacheOptions);
+    const cacheKey = makeCacheKey10(namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
-      logger28.info(`Cache hit for key: ${cacheKey}`);
+      logger31.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
@@ -4951,11 +5539,11 @@ function useScheduleTaskRepository() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = paginate8(items, page, limit, length);
+      const data = paginate9(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
-        logger28.info(`Cache set for key: ${cacheKey}`);
+        logger31.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        logger28.error(`Failed to set cache for key: ${cacheKey}`, err);
+        logger31.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
@@ -4988,20 +5576,20 @@ function useScheduleTaskRepository() {
       limit
     };
     try {
-      site = new ObjectId17(site);
+      site = new ObjectId19(site);
       query.site = site;
       cacheOptions.site = site.toString();
     } catch (error) {
-      throw new BadRequestError29("Invalid site ID format.");
+      throw new BadRequestError33("Invalid site ID format.");
     }
     if (search) {
       query.$or = [{ name: { $regex: search, $options: "i" } }];
       cacheOptions.search = search;
     }
-    const cacheKey = makeCacheKey9(namespace_collection, cacheOptions);
+    const cacheKey = makeCacheKey10(namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
-      logger28.info(`Cache hit for key: ${cacheKey}`);
+      logger31.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
@@ -5018,11 +5606,11 @@ function useScheduleTaskRepository() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = paginate8(items, page, limit, length);
+      const data = paginate9(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
-        logger28.info(`Cache set for key: ${cacheKey}`);
+        logger31.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        logger28.error(`Failed to set cache for key: ${cacheKey}`, err);
+        logger31.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
@@ -5031,25 +5619,25 @@ function useScheduleTaskRepository() {
   }
   async function getScheduleTaskById(_id, session) {
     try {
-      _id = new ObjectId17(_id);
+      _id = new ObjectId19(_id);
     } catch (error) {
-      throw new BadRequestError29("Invalid schedule task ID format.");
+      throw new BadRequestError33("Invalid schedule task ID format.");
     }
     const query = {
       _id,
       status: { $ne: "deleted" }
     };
-    const cacheKey = makeCacheKey9(namespace_collection, {
+    const cacheKey = makeCacheKey10(namespace_collection, {
       _id: _id.toString()
     });
     if (!session) {
       const cachedData = await getCache(cacheKey);
       if (cachedData) {
-        logger28.info(`Cache hit for key: ${cacheKey}`);
+        logger31.info(`Cache hit for key: ${cacheKey}`);
         return cachedData;
       }
     } else {
-      logger28.info(`Skipping cache during transaction for key: ${cacheKey}`);
+      logger31.info(`Skipping cache during transaction for key: ${cacheKey}`);
     }
     try {
       const data = await collection.aggregate([
@@ -5068,12 +5656,12 @@ function useScheduleTaskRepository() {
         }
       ]).toArray();
       if (!data || data.length === 0) {
-        throw new NotFoundError7("Schedule task not found.");
+        throw new NotFoundError8("Schedule task not found.");
       }
       setCache(cacheKey, data[0], 15 * 60).then(() => {
-        logger28.info(`Cache set for key: ${cacheKey}`);
+        logger31.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        logger28.error(`Failed to set cache for key: ${cacheKey}`, err);
+        logger31.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data[0];
     } catch (error) {
@@ -5082,19 +5670,19 @@ function useScheduleTaskRepository() {
   }
   async function updateScheduleTask(_id, value, session) {
     try {
-      _id = new ObjectId17(_id);
+      _id = new ObjectId19(_id);
     } catch (error) {
-      throw new BadRequestError29("Invalid schedule task ID format.");
+      throw new BadRequestError33("Invalid schedule task ID format.");
     }
     if (value.areas && Array.isArray(value.areas)) {
       value.areas = value.areas.map((area) => {
         try {
           return {
             name: area.name,
-            value: new ObjectId17(area.value.toString())
+            value: new ObjectId19(area.value.toString())
           };
         } catch (error) {
-          throw new BadRequestError29(`Invalid area value format: ${area.name}`);
+          throw new BadRequestError33(`Invalid area value format: ${area.name}`);
         }
       });
     }
@@ -5106,14 +5694,14 @@ function useScheduleTaskRepository() {
         { session }
       );
       if (res.modifiedCount === 0) {
-        throw new InternalServerError9(
+        throw new InternalServerError10(
           "Unable to update hygiene schedule task."
         );
       }
       delNamespace().then(() => {
-        logger28.info(`Cache cleared for namespace: ${namespace_collection}`);
+        logger31.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        logger28.error(
+        logger31.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -5136,10 +5724,10 @@ function useScheduleTaskRepository() {
 }
 
 // src/services/hygiene-schedule-task.service.ts
-import { logger as logger29 } from "@7365admin1/node-server-utils";
+import { logger as logger32 } from "@7365admin1/node-server-utils";
 function useScheduleTaskService() {
   const { createParentChecklist } = useParentChecklistRepo();
-  const { getAllScheduleTask, getScheduleTaskById } = useScheduleTaskRepository();
+  const { getAllScheduleTask } = useScheduleTaskRepository();
   const {
     createAreaChecklist,
     getAreaChecklistByAreaAndSchedule,
@@ -5159,13 +5747,13 @@ function useScheduleTaskService() {
       const currentDateString = now.toLocaleDateString("en-US", {
         timeZone: "Asia/Singapore"
       });
-      logger29.info(
+      logger32.info(
         `Checking schedule ${schedule._id}: Current time ${currentHour}:${currentMinute}, Current date ${currentDateString}, Schedule time ${schedule.time}, Start date ${schedule.startDate}, End date ${schedule.endDate}`
       );
       const startDate = /* @__PURE__ */ new Date(schedule.startDate + "T00:00:00");
       const currentDateOnly = /* @__PURE__ */ new Date(currentDateString + "T00:00:00");
       if (currentDateOnly < startDate) {
-        logger29.info(
+        logger32.info(
           `Schedule ${schedule._id}: Current date ${currentDateString} is before start date ${schedule.startDate}`
         );
         return false;
@@ -5173,7 +5761,7 @@ function useScheduleTaskService() {
       if (schedule.endDate) {
         const endDate = /* @__PURE__ */ new Date(schedule.endDate + "T00:00:00");
         if (currentDateOnly > endDate) {
-          logger29.info(
+          logger32.info(
             `Schedule ${schedule._id}: Current date ${currentDateString} is after end date ${schedule.endDate}`
           );
           return false;
@@ -5182,17 +5770,17 @@ function useScheduleTaskService() {
       const [scheduleHour, scheduleMinute] = schedule.time.split(":").map(Number);
       const timeMatches = currentHour === scheduleHour && currentMinute === scheduleMinute;
       if (!timeMatches) {
-        logger29.info(
+        logger32.info(
           `Schedule ${schedule._id}: Time does not match. Current: ${currentHour}:${currentMinute}, Expected: ${scheduleHour}:${scheduleMinute}`
         );
         return false;
       }
-      logger29.info(
+      logger32.info(
         `Schedule ${schedule._id}: All conditions matched - Date is within range and time matches`
       );
       return true;
     } catch (error) {
-      logger29.error(
+      logger32.error(
         `Error checking schedule conditions for ${schedule._id}:`,
         error
       );
@@ -5201,40 +5789,40 @@ function useScheduleTaskService() {
   }
   async function processScheduledTasks(currentDate) {
     try {
-      logger29.info("Starting scheduled task processing...");
+      logger32.info("Starting scheduled task processing...");
       const scheduleTasks = await getAllScheduleTask();
       if (!scheduleTasks || scheduleTasks.length === 0) {
-        logger29.info("No schedule tasks found to process");
+        logger32.info("No schedule tasks found to process");
         return { processed: 0, validated: 0 };
       }
-      logger29.info(`Found ${scheduleTasks.length} schedule tasks to check`);
+      logger32.info(`Found ${scheduleTasks.length} schedule tasks to check`);
       let processedCount = 0;
       let validatedCount = 0;
       const validatedTasks = [];
       for (const scheduleTask of scheduleTasks) {
         try {
-          logger29.info(
+          logger32.info(
             `Checking schedule ${scheduleTask._id} - ${scheduleTask.title}: time=${scheduleTask.time}, startDate=${scheduleTask.startDate}, endDate=${scheduleTask.endDate}`
           );
           const shouldRun = checkScheduleConditions(scheduleTask, currentDate);
           if (!shouldRun) {
-            logger29.info(
+            logger32.info(
               `Schedule ${scheduleTask._id} conditions not met, skipping`
             );
             continue;
           }
-          logger29.info(
+          logger32.info(
             `Schedule ${scheduleTask._id} conditions validated, creating area checklists`
           );
           if (!scheduleTask._id) {
-            logger29.warn(`Schedule ${scheduleTask.title} has no _id, skipping`);
+            logger32.warn(`Schedule ${scheduleTask.title} has no _id, skipping`);
             continue;
           }
           if (!scheduleTask.site) {
-            logger29.warn(`Schedule ${scheduleTask._id} has no site, skipping`);
+            logger32.warn(`Schedule ${scheduleTask._id} has no site, skipping`);
             continue;
           }
-          logger29.info(
+          logger32.info(
             `Getting or creating parent checklist for schedule ${scheduleTask._id} in site ${scheduleTask.site}`
           );
           const parentChecklistIds = await createParentChecklist({
@@ -5242,7 +5830,7 @@ function useScheduleTaskService() {
             createdAt: /* @__PURE__ */ new Date()
           });
           const parentChecklistId = Array.isArray(parentChecklistIds) ? parentChecklistIds[0] : parentChecklistIds;
-          logger29.info(
+          logger32.info(
             `Using parent checklist ${parentChecklistId}, now creating/updating area checklists`
           );
           for (const area of scheduleTask.areas) {
@@ -5255,14 +5843,14 @@ function useScheduleTaskService() {
                   unit: unit.unit.toString(),
                   name: unit.name
                 }));
-                logger29.info(
+                logger32.info(
                   `Area ${area.name} (${areaId}): Using units from area details: ${JSON.stringify(
                     units
                   )}`
                 );
               }
               if (units.length === 0) {
-                logger29.warn(
+                logger32.warn(
                   `Area ${area.name} (${areaId}): No units found, skipping area.`
                 );
                 continue;
@@ -5273,11 +5861,11 @@ function useScheduleTaskService() {
                   parentChecklistId.toString(),
                   areaId
                 );
-                logger29.info(
+                logger32.info(
                   `Area ${area.name} (${areaId}): Existing area checklist found: ${existingAreaChecklist ? "Yes" : "No"}`
                 );
                 if (existingAreaChecklist) {
-                  logger29.info(
+                  logger32.info(
                     `Area ${area.name} (${areaId}): Existing checklist content: ${JSON.stringify(
                       existingAreaChecklist.checklist
                     )}`
@@ -5285,7 +5873,7 @@ function useScheduleTaskService() {
                 }
               } catch (error) {
                 existingAreaChecklist = null;
-                logger29.info(
+                logger32.info(
                   `Area ${area.name} (${areaId}): No existing area checklist found (exception).`
                 );
               }
@@ -5299,7 +5887,7 @@ function useScheduleTaskService() {
                   ...existingAreaChecklist.checklist || [],
                   newSet
                 ];
-                logger29.info(
+                logger32.info(
                   `Area ${area.name} (${areaId}): Appending new set ${newSet.set} to checklist. Updated checklist: ${JSON.stringify(
                     updatedChecklist
                   )}`
@@ -5307,7 +5895,7 @@ function useScheduleTaskService() {
                 await updateAreaChecklist(existingAreaChecklist._id, {
                   checklist: updatedChecklist
                 });
-                logger29.info(
+                logger32.info(
                   `Appended set ${newSet.set} to area checklist for area ${area.name}`
                 );
                 try {
@@ -5315,13 +5903,13 @@ function useScheduleTaskService() {
                     parentChecklistId.toString(),
                     areaId
                   );
-                  logger29.info(
+                  logger32.info(
                     `Area ${area.name} (${areaId}): Checklist after update: ${JSON.stringify(
                       verifyChecklist.checklist
                     )}`
                   );
                 } catch (verifyError) {
-                  logger29.warn(
+                  logger32.warn(
                     `Area ${area.name} (${areaId}): Error verifying checklist after update:`,
                     verifyError
                   );
@@ -5337,52 +5925,53 @@ function useScheduleTaskService() {
                       set: 1,
                       units
                     }
-                  ]
+                  ],
+                  createdBy: scheduleTask.createdBy
                 };
-                logger29.info(
+                logger32.info(
                   `Area ${area.name} (${areaId}): Creating new area checklist with data: ${JSON.stringify(
                     checklistData
                   )}`
                 );
                 await createAreaChecklist(checklistData);
-                logger29.info(`Created new area checklist for area ${area.name}`);
+                logger32.info(`Created new area checklist for area ${area.name}`);
                 try {
                   const verifyChecklist = await getAreaChecklistByAreaAndSchedule(
                     parentChecklistId.toString(),
                     areaId
                   );
-                  logger29.info(
+                  logger32.info(
                     `Area ${area.name} (${areaId}): Checklist after creation: ${JSON.stringify(
                       verifyChecklist.checklist
                     )}`
                   );
                 } catch (verifyError) {
-                  logger29.warn(
+                  logger32.warn(
                     `Area ${area.name} (${areaId}): Error verifying checklist after creation:`,
                     verifyError
                   );
                 }
               }
             } catch (error) {
-              logger29.error(`Error processing area ${area.name}:`, error);
+              logger32.error(`Error processing area ${area.name}:`, error);
               continue;
             }
           }
           processedCount++;
           validatedCount++;
           validatedTasks.push(scheduleTask);
-          logger29.info(
+          logger32.info(
             `Successfully processed schedule ${scheduleTask._id}, created/updated area checklists for all areas.`
           );
         } catch (error) {
-          logger29.error(
+          logger32.error(
             `Error processing schedule task ${scheduleTask._id}:`,
             error
           );
           continue;
         }
       }
-      logger29.info(
+      logger32.info(
         `Scheduled task processing completed. Processed: ${processedCount}, Validated: ${validatedCount} tasks`
       );
       return {
@@ -5391,7 +5980,7 @@ function useScheduleTaskService() {
         tasks: validatedTasks
       };
     } catch (error) {
-      logger29.error("Error processing scheduled tasks:", error);
+      logger32.error("Error processing scheduled tasks:", error);
       throw error;
     }
   }
@@ -5399,8 +5988,8 @@ function useScheduleTaskService() {
 }
 
 // src/controllers/hygiene-schedule-task.controller.ts
-import Joi17 from "joi";
-import { BadRequestError as BadRequestError30, logger as logger30 } from "@7365admin1/node-server-utils";
+import Joi19 from "joi";
+import { BadRequestError as BadRequestError34, logger as logger33 } from "@7365admin1/node-server-utils";
 function useScheduleTaskController() {
   const {
     createScheduleTask: _createScheduleTask,
@@ -5410,11 +5999,16 @@ function useScheduleTaskController() {
     updateScheduleTask: _updateScheduleTask
   } = useScheduleTaskRepository();
   async function createScheduleTask(req, res, next) {
-    const payload = { ...req.body, ...req.params };
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const payload = { ...req.body, ...req.params, createdBy };
     const { error } = scheduleTaskSchema.validate(payload);
     if (error) {
-      logger30.log({ level: "error", message: error.message });
-      next(new BadRequestError30(error.message));
+      logger33.log({ level: "error", message: error.message });
+      next(new BadRequestError34(error.message));
       return;
     }
     try {
@@ -5422,23 +6016,23 @@ function useScheduleTaskController() {
       res.status(201).json({ message: "Schedule task created successfully.", id });
       return;
     } catch (error2) {
-      logger30.log({ level: "error", message: error2.message });
+      logger33.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   async function getScheduleTasks(req, res, next) {
     const query = { ...req.query, ...req.params };
-    const validation = Joi17.object({
-      page: Joi17.number().min(1).optional().allow("", null),
-      limit: Joi17.number().min(1).optional().allow("", null),
-      search: Joi17.string().optional().allow("", null),
-      site: Joi17.string().hex().required()
+    const validation = Joi19.object({
+      page: Joi19.number().min(1).optional().allow("", null),
+      limit: Joi19.number().min(1).optional().allow("", null),
+      search: Joi19.string().optional().allow("", null),
+      site: Joi19.string().hex().required()
     });
     const { error } = validation.validate(query);
     if (error) {
-      logger30.log({ level: "error", message: error.message });
-      next(new BadRequestError30(error.message));
+      logger33.log({ level: "error", message: error.message });
+      next(new BadRequestError34(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -5455,23 +6049,23 @@ function useScheduleTaskController() {
       res.json(data);
       return;
     } catch (error2) {
-      logger30.log({ level: "error", message: error2.message });
+      logger33.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   async function getTasksForScheduleTask(req, res, next) {
     const query = { ...req.query, ...req.params };
-    const validation = Joi17.object({
-      page: Joi17.number().min(1).optional().allow("", null),
-      limit: Joi17.number().min(1).optional().allow("", null),
-      search: Joi17.string().optional().allow("", null),
-      site: Joi17.string().hex().required()
+    const validation = Joi19.object({
+      page: Joi19.number().min(1).optional().allow("", null),
+      limit: Joi19.number().min(1).optional().allow("", null),
+      search: Joi19.string().optional().allow("", null),
+      site: Joi19.string().hex().required()
     });
     const { error } = validation.validate(query);
     if (error) {
-      logger30.log({ level: "error", message: error.message });
-      next(new BadRequestError30(error.message));
+      logger33.log({ level: "error", message: error.message });
+      next(new BadRequestError34(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -5488,18 +6082,18 @@ function useScheduleTaskController() {
       res.json(data);
       return;
     } catch (error2) {
-      logger30.log({ level: "error", message: error2.message });
+      logger33.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   async function getScheduleTaskById(req, res, next) {
-    const validation = Joi17.string().hex().required();
+    const validation = Joi19.string().hex().required();
     const _id = req.params.id;
     const { error, value } = validation.validate(_id);
     if (error) {
-      logger30.log({ level: "error", message: error.message });
-      next(new BadRequestError30(error.message));
+      logger33.log({ level: "error", message: error.message });
+      next(new BadRequestError34(error.message));
       return;
     }
     try {
@@ -5507,31 +6101,31 @@ function useScheduleTaskController() {
       res.json(data);
       return;
     } catch (error2) {
-      logger30.log({ level: "error", message: error2.message });
+      logger33.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   async function updateScheduleTask(req, res, next) {
     const payload = { id: req.params.id, ...req.body };
-    const validation = Joi17.object({
-      id: Joi17.string().hex().required(),
-      title: Joi17.string().optional().allow("", null),
-      time: Joi17.string().pattern(/^([0-1]\d|2[0-3]):([0-5]\d)$/).optional().allow("", null),
-      startDate: Joi17.string().pattern(/^\d{4}-\d{2}-\d{2}$/).optional().allow("", null),
-      endDate: Joi17.string().pattern(/^\d{4}-\d{2}-\d{2}$/).optional().allow("", null),
-      description: Joi17.string().optional().allow("", null),
-      areas: Joi17.array().min(1).items(
-        Joi17.object({
-          name: Joi17.string().required(),
-          value: Joi17.any().required()
+    const validation = Joi19.object({
+      id: Joi19.string().hex().required(),
+      title: Joi19.string().optional().allow("", null),
+      time: Joi19.string().pattern(/^([0-1]\d|2[0-3]):([0-5]\d)$/).optional().allow("", null),
+      startDate: Joi19.string().pattern(/^\d{4}-\d{2}-\d{2}$/).optional().allow("", null),
+      endDate: Joi19.string().pattern(/^\d{4}-\d{2}-\d{2}$/).optional().allow("", null),
+      description: Joi19.string().optional().allow("", null),
+      areas: Joi19.array().min(1).items(
+        Joi19.object({
+          name: Joi19.string().required(),
+          value: Joi19.any().required()
         })
       ).optional()
     });
     const { error } = validation.validate(payload);
     if (error) {
-      logger30.log({ level: "error", message: error.message });
-      next(new BadRequestError30(error.message));
+      logger33.log({ level: "error", message: error.message });
+      next(new BadRequestError34(error.message));
       return;
     }
     try {
@@ -5540,7 +6134,7 @@ function useScheduleTaskController() {
       res.json({ message: "Schedule task updated successfully." });
       return;
     } catch (error2) {
-      logger30.log({ level: "error", message: error2.message });
+      logger33.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -5556,12 +6150,14 @@ function useScheduleTaskController() {
 export {
   MArea,
   MAreaChecklist,
+  MCheckOutItem,
   MParentChecklist,
   MRequestItem,
   MScheduleTask,
   MStock,
   MSupply,
   MUnit,
+  allowedCheckOutItemStatus,
   allowedChecklistStatus,
   allowedPeriods,
   allowedRequestItemStatus,
@@ -5569,6 +6165,7 @@ export {
   allowedTypes,
   areaChecklistSchema,
   areaSchema,
+  checkOutItemSchema,
   parentChecklistSchema,
   requestItemSchema,
   scheduleTaskSchema,
@@ -5581,6 +6178,9 @@ export {
   useAreaController,
   useAreaRepo,
   useAreaService,
+  useCheckOutItemController,
+  useCheckOutItemRepository,
+  useCheckOutItemService,
   useHygieneDashboardController,
   useHygieneDashboardRepository,
   useParentChecklistController,