@7365admin1/module-hygiene 1.7.0

package/dist/index.d.ts

@@ -0,0 +1,549 @@
+import * as mongodb from 'mongodb';
+import { ObjectId, ClientSession } from 'mongodb';
+import { Request, Response, NextFunction } from 'express';
+import Joi from 'joi';
+import * as bson from 'bson';
+
+declare const allowedTypes: string[];
+declare const allowedStatus: string[];
+declare const allowedPeriods: string[];
+
+declare function useHygieneDashboardRepository(): {
+    getHygieneDashboard: ({ site, feedbackPeriod, commonAreaPeriod, toiletAreaPeriod, scheduleTaskPeriod, supplyPeriod, requestItemPeriod, }: {
+        site: string | ObjectId;
+        feedbackPeriod?: string | undefined;
+        commonAreaPeriod?: string | undefined;
+        toiletAreaPeriod?: string | undefined;
+        scheduleTaskPeriod?: string | undefined;
+        supplyPeriod?: string | undefined;
+        requestItemPeriod?: string | undefined;
+    }) => Promise<{}>;
+};
+
+declare function useHygieneDashboardController(): {
+    getHygieneDashboard: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+};
+
+type TAreaUnits = {
+    unit: string | ObjectId;
+    name: string;
+};
+type TArea = {
+    _id?: ObjectId;
+    site: string | ObjectId;
+    name: string;
+    type: (typeof allowedTypes)[number];
+    set?: number;
+    units?: TAreaUnits[];
+    status?: "active" | "deleted";
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+    deletedAt?: Date | string;
+};
+type TAreaCreate = Pick<TArea, "site" | "name" | "type" | "set" | "units">;
+type TAreaGetQuery = {
+    page?: number;
+    limit?: number;
+    search?: string;
+    type?: (typeof allowedTypes)[number] | "all";
+} & Pick<TArea, "site">;
+type TAreaUpdate = Partial<Pick<TArea, "name" | "type" | "set" | "units">>;
+type TAreaUpdateChecklist = {
+    units: TAreaUnits[];
+};
+declare const areaSchema: Joi.ObjectSchema<any>;
+declare function MArea(value: TAreaCreate): {
+    site: string | ObjectId;
+    name: string;
+    type: string;
+    set: number;
+    units: TAreaUnits[];
+    status: string;
+    createdAt: Date;
+    updatedAt: string;
+    deletedAt: string;
+};
+
+declare function useAreaRepo(): {
+    createIndex: () => Promise<void>;
+    createTextIndex: () => Promise<void>;
+    createUniqueIndex: () => Promise<void>;
+    createArea: (value: TAreaCreate, session?: ClientSession) => Promise<ObjectId>;
+    getAreas: ({ page, limit, search, type, site, }: TAreaGetQuery) => Promise<{}>;
+    getAreasForChecklist: (site: string | ObjectId) => Promise<{}>;
+    getAreaById: (_id: string | ObjectId) => Promise<{}>;
+    getAreaByMultipleId: (_id: string[] | ObjectId[]) => Promise<bson.Document[]>;
+    verifyAreaByUnitId: (unitId: string | ObjectId) => Promise<{}>;
+    updateArea: (_id: string | ObjectId, value: TAreaUpdate, session?: ClientSession) => Promise<number>;
+    updateAreaChecklist: (unitId: string | ObjectId, name: string, session?: ClientSession) => Promise<number>;
+    deleteArea: (_id: string | ObjectId, session?: ClientSession) => Promise<number>;
+};
+
+declare function useAreaService(): {
+    importArea: ({ dataJson, site, }: {
+        dataJson: string;
+        site: string | ObjectId;
+    }) => Promise<{
+        message: string;
+    }>;
+};
+
+interface MulterRequest extends Request {
+    file?: {
+        buffer: Buffer;
+        originalname: string;
+        mimetype: string;
+        size: number;
+    };
+}
+
+declare function useAreaController(): {
+    createArea: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getAreas: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getAreaById: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    updateArea: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    deleteArea: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    importArea: (req: MulterRequest, res: Response, next: NextFunction) => Promise<Response<any, Record<string, any>> | undefined>;
+};
+
+type TUnit = {
+    _id?: ObjectId;
+    site: string | ObjectId;
+    name: string;
+    createdAt?: string;
+    updatedAt?: string;
+    deletedAt?: string;
+    status?: "active" | "deleted";
+};
+type TUnitCreate = Pick<TUnit, "site" | "name">;
+type TUnitGetQuery = {
+    page?: number;
+    limit?: number;
+    search?: string;
+} & Pick<TUnit, "site">;
+type TUnitUpdate = Pick<TUnit, "name">;
+declare const unitSchema: Joi.ObjectSchema<any>;
+declare function MUnit(value: TUnitCreate): {
+    site: string | ObjectId;
+    name: string;
+    status: string;
+    createdAt: Date;
+    updatedAt: string;
+    deletedAt: string;
+};
+
+declare function useUnitService(): {
+    importUnit: ({ dataJson, site, }: {
+        dataJson: string;
+        site: string | ObjectId;
+    }) => Promise<{
+        message: string;
+    }>;
+    updateUnit: (_id: string | ObjectId, value: TUnitUpdate) => Promise<number>;
+    deleteUnit: (_id: string | ObjectId) => Promise<number>;
+};
+
+declare function useUnitRepository(): {
+    createIndex: () => Promise<void>;
+    createTextIndex: () => Promise<void>;
+    createUniqueIndex: () => Promise<void>;
+    createUnit: (value: TUnitCreate, session?: ClientSession) => Promise<ObjectId>;
+    getUnits: ({ page, limit, search, site, }: TUnitGetQuery) => Promise<{}>;
+    updateUnit: (_id: string | ObjectId, value: TUnitUpdate, session?: ClientSession) => Promise<number>;
+    deleteUnit: (_id: string | ObjectId, session?: ClientSession) => Promise<number>;
+};
+
+declare function useUnitController(): {
+    createUnit: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getUnits: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    updateUnit: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    deleteUnit: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    importUnit: (req: MulterRequest, res: Response, next: NextFunction) => Promise<Response<any, Record<string, any>> | undefined>;
+};
+
+type TParentChecklist = {
+    _id?: ObjectId;
+    site?: string | ObjectId;
+    status?: (typeof allowedStatus)[number];
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+};
+type TParentChecklistGetQuery = {
+    page?: number;
+    limit?: number;
+    search?: string;
+    site: string | ObjectId;
+    startDate?: string | Date;
+    endDate?: string | Date;
+} & Pick<TParentChecklist, "status">;
+declare const parentChecklistSchema: Joi.ObjectSchema<any>;
+declare function MParentChecklist(value: TParentChecklist): {
+    site: string | ObjectId | undefined;
+    status: string;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+};
+
+declare function useParentChecklistRepo(): {
+    createIndex: () => Promise<void>;
+    createParentChecklist: (value: TParentChecklist, session?: ClientSession) => Promise<ObjectId | ObjectId[]>;
+    getAllParentChecklist: ({ page, limit, search, site, startDate, endDate, status, }: TParentChecklistGetQuery) => Promise<{}>;
+    updateParentChecklistStatuses: (_id: string | ObjectId, status: (typeof allowedStatus)[number], session?: ClientSession) => Promise<number>;
+};
+
+declare function useParentChecklistController(): {
+    createParentChecklist: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getAllParentChecklist: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+};
+
+declare const allowedChecklistStatus: string[];
+type TCleaningScheduleArea = {
+    _id?: ObjectId;
+    schedule: string | ObjectId;
+    area: string | ObjectId;
+    name: string;
+    type: (typeof allowedTypes)[number];
+    checklist: TAreaChecklist[];
+    status?: (typeof allowedStatus)[number];
+    createdAt?: Date | string;
+    completedAt?: Date | string;
+    updatedAt?: Date | string;
+};
+type TAreaChecklist = {
+    set: number;
+    units: TAreaChecklistUnits[];
+};
+type TAreaChecklistUnits = {
+    unit: string | ObjectId;
+    name: string;
+    status?: (typeof allowedChecklistStatus)[number];
+    remarks?: string;
+    completedBy?: string | ObjectId;
+    timestamp?: Date | string;
+};
+type TAreaChecklistCreate = Pick<TCleaningScheduleArea, "schedule" | "area"> & {
+    site: string | ObjectId;
+};
+type TAreaChecklistBatchCreate = Pick<TCleaningScheduleArea, "schedule"> & {
+    site: string | ObjectId;
+};
+type TCleaningScheduleAreaGetQuery = {
+    page?: number;
+    limit?: number;
+    search?: string;
+    type?: (typeof allowedTypes)[number] | "all";
+    status?: (typeof allowedStatus)[number] | "all";
+} & Pick<TCleaningScheduleArea, "schedule">;
+type TAreaChecklistUpdate = Pick<TCleaningScheduleArea, "checklist">;
+type TAreaChecklistUnitsUpdate = Pick<TAreaChecklistUnits, "remarks" | "completedBy">;
+declare const areaChecklistSchema: Joi.ObjectSchema<any>;
+declare function MAreaChecklist(value: TCleaningScheduleArea): {
+    schedule: string | ObjectId;
+    area: string | ObjectId;
+    name: string;
+    type: string;
+    checklist: TAreaChecklist[];
+    status: string;
+    createdAt: Date;
+    completedAt: string;
+    updatedAt: string;
+};
+
+declare function useAreaChecklistService(): {
+    createAreaChecklist: (value: TAreaChecklistBatchCreate) => Promise<ObjectId[]>;
+    completeAreaChecklistUnits: (_id: string | ObjectId, set: number, unitId: string | ObjectId, value: TAreaChecklistUnitsUpdate) => Promise<void>;
+};
+
+declare function useAreaChecklistRepo(): {
+    createIndex: () => Promise<void>;
+    createTextIndex: () => Promise<void>;
+    createAreaChecklist: (value: TCleaningScheduleArea, session?: ClientSession) => Promise<ObjectId>;
+    getAllAreaChecklist: ({ page, limit, search, type, status, schedule, }: TCleaningScheduleAreaGetQuery, session?: ClientSession) => Promise<{}>;
+    getAreaChecklistHistory: ({ page, limit, search, type, schedule, status, createdAt, }: {
+        page?: number | undefined;
+        limit?: number | undefined;
+        search?: string | undefined;
+        type?: string | undefined;
+        schedule: string | ObjectId;
+        status?: string | undefined;
+        createdAt?: string | Date | undefined;
+    }) => Promise<{}>;
+    getAreaChecklistHistoryDetails: (_id: string | ObjectId) => Promise<{}>;
+    getAreaChecklistUnits: ({ page, limit, search, _id, }: {
+        page?: number | undefined;
+        limit?: number | undefined;
+        search?: string | undefined;
+        _id: string | ObjectId;
+    }, session?: ClientSession) => Promise<{}>;
+    getAreaChecklistById: (_id: string | ObjectId, session?: ClientSession) => Promise<mongodb.WithId<bson.Document>>;
+    getAreaChecklistByAreaAndSchedule: (schedule: string | ObjectId, area: string | ObjectId, session?: ClientSession) => Promise<mongodb.WithId<bson.Document>>;
+    updateAreaChecklist: (_id: string | ObjectId, value: TAreaChecklistUpdate, session?: ClientSession) => Promise<number>;
+    updateAreaChecklistStatus: (_id: string | ObjectId, status: (typeof allowedStatus)[number], session?: ClientSession) => Promise<number>;
+    completeAreaChecklistUnits: (_id: string | ObjectId, set: number, unitId: string | ObjectId, value: TAreaChecklistUnitsUpdate, session?: ClientSession) => Promise<number>;
+};
+
+declare function useAreaChecklistController(): {
+    createAreaChecklist: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getAllAreaChecklist: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getAreaChecklistHistory: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getAreaChecklistHistoryDetails: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getAreaChecklistUnits: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    completeAreaChecklistUnits: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+};
+
+type TSupply = {
+    _id?: ObjectId;
+    site: string | ObjectId;
+    name: string;
+    unitOfMeasurement: string;
+    qty: number;
+    status?: "active" | "deleted";
+    createdAt?: string;
+    updatedAt?: string;
+    deletedAt?: string;
+};
+type TSupplyCreate = Pick<TSupply, "site" | "name" | "unitOfMeasurement">;
+type TSupplyGetQuery = {
+    page?: number;
+    limit?: number;
+    search?: string;
+} & Pick<TSupply, "site">;
+type TSupplyGetById = Pick<TSupply, "_id" | "name" | "unitOfMeasurement" | "qty">;
+type TSupplyUpdate = Partial<Pick<TSupply, "name" | "unitOfMeasurement" | "qty">>;
+declare const supplySchema: Joi.ObjectSchema<any>;
+declare function MSupply(value: TSupplyCreate): {
+    site: string | ObjectId;
+    name: string;
+    unitOfMeasurement: string;
+    qty: number;
+    status: string;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string;
+};
+
+declare function useSupplyRepository(): {
+    createIndex: () => Promise<void>;
+    createTextIndex: () => Promise<void>;
+    createUniqueIndex: () => Promise<void>;
+    createSupply: (value: TSupplyCreate, session?: ClientSession) => Promise<ObjectId>;
+    getSupplies: ({ page, limit, search, site, }: TSupplyGetQuery) => Promise<{}>;
+    getSupplyById: (_id: string | ObjectId, session?: ClientSession) => Promise<TSupplyGetById>;
+    updateSupply: (_id: string | ObjectId, value: TSupplyUpdate, session?: ClientSession) => Promise<number>;
+    deleteSupply: (_id: string | ObjectId, session?: ClientSession) => Promise<number>;
+};
+
+declare function useSupplyController(): {
+    createSupply: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getSupplies: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getSupplyById: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    updateSupply: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    deleteSupply: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+};
+
+type TStock = {
+    _id?: ObjectId;
+    site: string | ObjectId;
+    supply: string | ObjectId;
+    in?: number;
+    out?: number;
+    balance: number;
+    remarks?: string;
+    status?: "active" | "deleted";
+    createdAt?: string;
+    updatedAt?: string;
+    deletedAt?: string;
+};
+type TStockCreate = Pick<TStock, "site" | "supply" | "in" | "out" | "balance" | "remarks">;
+type TStockCreateService = Pick<TStock, "site" | "supply" | "remarks"> & {
+    qty: number;
+};
+type TGetStocksQuery = {
+    page?: number;
+    limit?: number;
+    search?: string;
+} & Pick<TStock, "site" | "supply">;
+declare const stockSchema: Joi.ObjectSchema<any>;
+declare function MStock(value: TStockCreate): {
+    site: string | ObjectId;
+    supply: string | ObjectId;
+    in: number;
+    out: number;
+    balance: number;
+    remarks: string;
+    createdAt: string;
+    status: string;
+    updatedAt: string;
+    deletedAt: string;
+};
+
+declare function useStockRepository(): {
+    createIndex: () => Promise<void>;
+    createStock: (value: TStockCreate, session?: ClientSession) => Promise<ObjectId>;
+    getStocksBySupplyId: ({ page, limit, search, site, supply, }: TGetStocksQuery) => Promise<{}>;
+};
+
+declare function useStockService(): {
+    createStock: (value: TStockCreateService, out?: boolean) => Promise<bson.ObjectId>;
+};
+
+declare function useStockController(): {
+    createStock: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getStocksBySupplyId: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+};
+
+declare const allowedRequestItemStatus: string[];
+type TRequestItem = {
+    _id?: ObjectId;
+    site: string | ObjectId;
+    supply: string | ObjectId;
+    supplyName: string;
+    qty: number;
+    remarks?: string;
+    createdBy: string | ObjectId;
+    createdByName: string;
+    status?: (typeof allowedRequestItemStatus)[number];
+    createdAt?: string;
+    updatedAt?: string;
+    deletedAt?: string;
+};
+type TRequestItemCreate = Pick<TRequestItem, "site" | "supply" | "supplyName" | "qty" | "createdBy" | "createdByName">;
+type TRequestItemCreateService = Pick<TRequestItem, "site" | "supply" | "qty" | "createdBy">;
+type TRequestItemCreateByBatchService = Pick<TRequestItem, "site" | "createdBy"> & {
+    items: Pick<TRequestItem, "supply" | "qty">[];
+};
+type TRequestItemGetQuery = {
+    page?: number;
+    limit?: number;
+    search?: string;
+} & Pick<TRequestItem, "site">;
+type TRequestItemGetById = Pick<TRequestItem, "_id" | "site" | "supply" | "supplyName" | "qty" | "status"> & {
+    unitOfMeasurement?: string;
+};
+declare const requestItemSchema: Joi.ObjectSchema<any>;
+declare function MRequestItem(value: TRequestItemCreate): {
+    site: string | ObjectId;
+    supply: string | ObjectId;
+    supplyName: string;
+    qty: number;
+    remarks: string;
+    createdBy: string | ObjectId;
+    createdByName: string;
+    status: string;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string;
+};
+
+declare function useRequestItemRepository(): {
+    createIndex: () => Promise<void>;
+    createTextIndex: () => Promise<void>;
+    createRequestItem: (value: TRequestItemCreate, session?: ClientSession) => Promise<ObjectId>;
+    getRequestItems: ({ page, limit, search, site, }: TRequestItemGetQuery) => Promise<{}>;
+    getRequestItemById: (_id: string | ObjectId, session?: ClientSession) => Promise<TRequestItemGetById>;
+    approveRequestItem: (_id: string | ObjectId, remarks?: string, session?: ClientSession) => Promise<number>;
+    disapproveRequestItem: (_id: string | ObjectId, remarks?: string, session?: ClientSession) => Promise<number>;
+};
+
+declare function useRequestItemService(): {
+    createRequestItem: (value: TRequestItemCreateService) => Promise<bson.ObjectId>;
+    createRequestItemByBatch: (value: TRequestItemCreateByBatchService) => Promise<bson.ObjectId[]>;
+    approveRequestItem: (id: string, remarks?: string) => Promise<bson.ObjectId>;
+    disapproveRequestItem: (id: string, remarks?: string) => Promise<number>;
+};
+
+declare function useRequestItemController(): {
+    createRequestItem: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    createRequestItemByBatch: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getRequestItems: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getRequestItemById: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    approveRequestItem: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    disapproveRequestItem: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+};
+
+declare const allowedFrequency: string[];
+declare const allowedDays: string[];
+declare const allowedWeekOfMonth: string[];
+declare const allowedMonths: string[];
+type TScheduleTask = {
+    _id?: ObjectId;
+    site: string | ObjectId;
+    title: string;
+    frequency: (typeof allowedFrequency)[number];
+    time: string;
+    day?: (typeof allowedDays)[number][];
+    weekOfMonth?: (typeof allowedWeekOfMonth)[number];
+    month?: (typeof allowedMonths)[number];
+    date?: number;
+    description?: string;
+    areas: {
+        name: string;
+        value: Object;
+    }[];
+    status?: "active" | "deleted";
+    createdAt?: string | Date;
+    updatedAt?: string | Date;
+    deletedAt?: string | Date;
+};
+type TScheduleTaskCreate = Pick<TScheduleTask, "site" | "title" | "frequency" | "time" | "day" | "weekOfMonth" | "month" | "date" | "description" | "areas">;
+type TScheduleTaskGetQuery = {
+    page?: number;
+    limit?: number;
+    search?: string;
+} & Pick<TScheduleTask, "site">;
+type TScheduleTaskGetById = Pick<TScheduleTask, "title" | "frequency" | "time" | "day" | "weekOfMonth" | "month" | "date" | "description" | "areas" | "status" | "createdAt">;
+type TScheduleTaskUpdate = Partial<Pick<TScheduleTask, "title" | "frequency" | "time" | "day" | "weekOfMonth" | "month" | "date" | "description" | "areas">>;
+declare const scheduleTaskSchema: Joi.ObjectSchema<any>;
+declare function MScheduleTask(value: TScheduleTaskCreate): {
+    site: string | ObjectId;
+    title: string;
+    frequency: string;
+    time: string;
+    day: string[] | undefined;
+    weekOfMonth: string | undefined;
+    month: string | undefined;
+    date: number | undefined;
+    description: string | undefined;
+    areas: {
+        name: string;
+        value: Object;
+    }[];
+    status: string;
+    createdAt: Date;
+    updatedAt: string;
+    deletedAt: string;
+};
+
+declare function useScheduleTaskRepository(): {
+    createIndex: () => Promise<void>;
+    createTextIndex: () => Promise<void>;
+    createScheduleTask: (value: TScheduleTaskCreate, session?: ClientSession) => Promise<ObjectId>;
+    getScheduleTasks: ({ page, limit, search, site, }: TScheduleTaskGetQuery) => Promise<{}>;
+    getAllScheduleTask: () => Promise<TScheduleTask[]>;
+    getTasksForScheduleTask: ({ page, limit, search, site, }: TScheduleTaskGetQuery) => Promise<{}>;
+    getScheduleTaskById: (_id: string | ObjectId, session?: ClientSession) => Promise<TScheduleTaskGetById>;
+    updateScheduleTask: (_id: string | ObjectId, value: TScheduleTaskUpdate, session?: ClientSession) => Promise<number>;
+};
+
+declare function useScheduleTaskService(): {
+    checkScheduleConditions: (schedule: any, currentDate?: Date) => boolean;
+    processScheduledTasks: (currentDate?: Date) => Promise<{
+        processed: number;
+        validated: number;
+        tasks?: undefined;
+    } | {
+        processed: number;
+        validated: number;
+        tasks: TScheduleTask[];
+    }>;
+};
+
+declare function useScheduleTaskController(): {
+    createScheduleTask: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getScheduleTasks: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getTasksForScheduleTask: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getScheduleTaskById: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    updateScheduleTask: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+};
+
+export { MArea, MAreaChecklist, MParentChecklist, MRequestItem, MScheduleTask, MStock, MSupply, MUnit, TArea, TAreaChecklist, TAreaChecklistBatchCreate, TAreaChecklistCreate, TAreaChecklistUnits, TAreaChecklistUnitsUpdate, TAreaChecklistUpdate, TAreaCreate, TAreaGetQuery, TAreaUnits, TAreaUpdate, TAreaUpdateChecklist, TCleaningScheduleArea, TCleaningScheduleAreaGetQuery, TGetStocksQuery, TParentChecklist, TParentChecklistGetQuery, TRequestItem, TRequestItemCreate, TRequestItemCreateByBatchService, TRequestItemCreateService, TRequestItemGetById, TRequestItemGetQuery, TScheduleTask, TScheduleTaskCreate, TScheduleTaskGetById, TScheduleTaskGetQuery, TScheduleTaskUpdate, TStock, TStockCreate, TStockCreateService, TSupply, TSupplyCreate, TSupplyGetById, TSupplyGetQuery, TSupplyUpdate, TUnit, TUnitCreate, TUnitGetQuery, TUnitUpdate, allowedChecklistStatus, allowedDays, allowedFrequency, allowedMonths, allowedPeriods, allowedRequestItemStatus, allowedStatus, allowedTypes, allowedWeekOfMonth, areaChecklistSchema, areaSchema, parentChecklistSchema, requestItemSchema, scheduleTaskSchema, stockSchema, supplySchema, unitSchema, useAreaChecklistController, useAreaChecklistRepo, useAreaChecklistService, useAreaController, useAreaRepo, useAreaService, useHygieneDashboardController, useHygieneDashboardRepository, useParentChecklistController, useParentChecklistRepo, useRequestItemController, useRequestItemRepository, useRequestItemService, useScheduleTaskController, useScheduleTaskRepository, useScheduleTaskService, useStockController, useStockRepository, useStockService, useSupplyController, useSupplyRepository, useUnitController, useUnitRepository, useUnitService };