dt-common-device 14.0.1 → 14.0.2

package/dist/cronicle/ICronicle.interface.d.ts

@@ -17,3 +17,70 @@ export interface ICronicle {
     enabled?: boolean;
     notes?: string;
 }
+export interface CronicleJob {
+    id: string;
+    title: string;
+    category: string;
+    plugin: string;
+    timeZone?: string;
+    timezone?: string;
+    enabled: number;
+    max_children: number;
+    target: string;
+    params: {
+        timeout: number;
+        headers: {
+            "Content-Type": string;
+            "x-api-key": string;
+            "User-Agent": string;
+            [key: string]: string;
+        };
+        url: string;
+        method: string;
+        data: string;
+        follow: number;
+        ssl_cert_bypass: number;
+        success_match: string;
+        error_match: string;
+    };
+    data: {
+        name: string;
+        cronJobId: string;
+        apiUrl: string;
+        method: string;
+        target: string;
+        schedule: {
+            years?: number[];
+            months?: number[];
+            days?: number[];
+            weekdays?: number[];
+            hours?: number[];
+            minutes?: number[];
+        };
+        notes: string;
+    };
+    timing: {
+        years?: number[];
+        months?: number[];
+        days?: number[];
+        weekdays?: number[];
+        hours?: number[];
+        minutes?: number[];
+    };
+    timeout: number;
+    notes: string;
+    modified: number;
+    created: number;
+    api_key: string;
+}
+export interface ListSchedules {
+    code: number;
+    list: {
+        page_size: number;
+        first_page: number;
+        last_page: number;
+        length: number;
+        type: string;
+    };
+    rows: CronicleJob[];
+}

package/dist/db/db.js

@@ -11,45 +11,49 @@ exports.getWebhookPostgresClient = getWebhookPostgresClient;
 const pg_1 = require("pg");
 const config_1 = require("../config/config");
 const mongoose_1 = __importDefault(require("mongoose"));
+let adminPool = null;
+let accessPool = null;
+let pmsPool = null;
+let webhookPool = null;
 function getPostgresClient() {
     const URI = (0, config_1.getAdminPostgresDbUri)();
-    let pool = null;
-    if (!pool) {
-        pool = new pg_1.Pool({
-            connectionString: URI,
-        });
-    }
-    return pool;
+    adminPool ?? (adminPool = new pg_1.Pool({
+        connectionString: URI,
+        connectionTimeoutMillis: 5000,
+        idleTimeoutMillis: 30000,
+    }).on("error", (err) => (0, config_1.getLogger)().error(err, `[Postgres] Admin Pool connection error`)));
+    (0, config_1.getLogger)().info(`[Postgres] Admin Pool initialized`);
+    return adminPool;
 }
 function getAccessPostgresClient() {
     const URI = (0, config_1.getAccessPostgresDbUri)();
-    let pool = null;
-    if (!pool) {
-        pool = new pg_1.Pool({
-            connectionString: URI,
-        });
-    }
-    return pool;
+    accessPool ?? (accessPool = new pg_1.Pool({
+        connectionString: URI,
+        connectionTimeoutMillis: 5000,
+        idleTimeoutMillis: 30000,
+    }).on("error", (err) => (0, config_1.getLogger)().error(err, `[Postgres] Access Pool connection error`)));
+    (0, config_1.getLogger)().info(`[Postgres] Access Pool initialized`);
+    return accessPool;
 }
 function getPmsPostgresClient() {
     const URI = (0, config_1.getPmsPostgresDbUri)();
-    let pool = null;
-    if (!pool) {
-        pool = new pg_1.Pool({
-            connectionString: URI,
-        });
-    }
-    return pool;
+    pmsPool ?? (pmsPool = new pg_1.Pool({
+        connectionString: URI,
+        connectionTimeoutMillis: 5000,
+        idleTimeoutMillis: 30000,
+    }).on("error", (err) => (0, config_1.getLogger)().error(err, `[Postgres] PMS Pool connection error`)));
+    (0, config_1.getLogger)().info(`[Postgres] PMS Pool initialized`);
+    return pmsPool;
 }
 function getWebhookPostgresClient() {
     const URI = (0, config_1.getWebhookPostgresDbUri)();
-    let pool = null;
-    if (!pool) {
-        pool = new pg_1.Pool({
-            connectionString: URI,
-        });
-    }
-    return pool;
+    webhookPool ?? (webhookPool = new pg_1.Pool({
+        connectionString: URI,
+        connectionTimeoutMillis: 5000,
+        idleTimeoutMillis: 30000,
+    }).on("error", (err) => (0, config_1.getLogger)().error(err, `[Postgres] Webhook Pool connection error`)));
+    (0, config_1.getLogger)().info(`[Postgres] Webhook Pool initialized`);
+    return webhookPool;
 }
 const connectDatabase = async () => {
     try {

package/dist/emails/emailService.js

@@ -236,61 +236,43 @@ let EmailService = (() => {
                 else {
                     imageURL = `https://api-sandbox-new.devicethread.com/dt-logo.png`;
                 }
-                const CONTACT_US_DETAILS = (0, Email_1.getContactUsDetails)();
-                const from = CONTACT_US_DETAILS?.FROM_EMAIL_ADDRESS;
-                if (!process.env.AWS_ACCESS_KEY_ID ||
-                    !process.env.AWS_SECRET_ACCESS_KEY) {
-                    throw new Error("AWS credentials are not set");
-                }
-                // Section below is replacing the global variables from template like contact us email, phone and current year.
+                const fromEmail = typeof mailData.fromEmail === "string" ? mailData.fromEmail.trim() : "";
                 const currentYear = new Date().getFullYear().toString();
-                // const logo: any = await GetLogo(ctx);
-                let finalMessage = message
+                const finalMessage = message
                     .replaceAll("{{year}}", currentYear)
-                    .replaceAll("{{contactUsPhone}}", `${CONTACT_US_DETAILS?.PHONE}`)
-                    .replaceAll("{{contactUsEmail}}", `${CONTACT_US_DETAILS?.TO_EMAIL_ADDRESS}`)
+                    .replaceAll("{{contactUsEmail}}", fromEmail)
                     .replaceAll("{{logo}}", `${imageURL}`);
-                // .replaceAll('{{logo}}', `${logo}`);
-                //
-                const params = {
+                (0, config_1.getLogger)().info(`sending email (SES) with params: ${JSON.stringify(toAddr)}`);
+                if (ccAddr && Array.isArray(ccAddr) && ccAddr.length > 0) {
+                    (0, config_1.getLogger)().info(`CC addresses: ${JSON.stringify(ccAddr)}`);
+                }
+                mailData.from = fromEmail;
+                if (pdfBuffer) {
+                    return;
+                }
+                await this.sesClient.send(new client_ses_1.SendEmailCommand({
+                    Source: fromEmail,
                     Destination: {
                         ToAddresses: toAddr,
+                        ...(ccAddr && Array.isArray(ccAddr) && ccAddr.length > 0
+                            ? {
+                                CcAddresses: ccAddr.filter((e) => typeof e === "string" && e.trim()),
+                            }
+                            : {}),
                     },
                     Message: {
+                        Subject: { Data: subject, Charset: "UTF-8" },
                         Body: {
-                            Html: {
-                                Charset: "UTF-8",
-                                Data: finalMessage,
-                            },
-                        },
-                        Subject: {
-                            Charset: "UTF-8",
-                            Data: subject,
+                            Html: { Data: finalMessage, Charset: "UTF-8" },
                         },
                     },
-                    Source: from, // SENDER_ADDRESS
-                    ReplyToAddresses: [CONTACT_US_DETAILS?.TO_EMAIL_ADDRESS],
-                };
-                // Add CC addresses if present
-                if (ccAddr && Array.isArray(ccAddr) && ccAddr.length > 0) {
-                    params.Destination.CcAddresses = ccAddr;
-                }
-                (0, config_1.getLogger)().info(`sending email with params: ${JSON.stringify(toAddr)}`);
-                if (ccAddr && ccAddr.length > 0) {
-                    (0, config_1.getLogger)().info(`CC addresses: ${JSON.stringify(ccAddr)}`);
-                }
-                mailData.from = CONTACT_US_DETAILS?.FROM_EMAIL_ADDRESS;
-                if (pdfBuffer) {
-                    // this.sendEmailWithAttachments(this.sesClient, mailData, finalMessage, pdfBuffer)
-                }
-                else {
-                    await this.sesClient.send(new client_ses_1.SendEmailCommand(params));
-                }
+                    ...(fromEmail ? { ReplyToAddresses: [fromEmail] } : {}),
+                }));
                 const maskedEmailsList = toAddr.map((email) => (0, Email_1.GetMaskedEmail)(email));
                 (0, config_1.getLogger)().info(`Sending email to: ${maskedEmailsList.join(", ")}`);
             }
             catch (error) {
-                (0, config_1.getLogger)().error("sendMail: Error", error);
+                (0, config_1.getLogger)().error("sendMail: Error", JSON.stringify(error));
             }
         }
     };

package/dist/entities/admin/Admin.repository.d.ts

@@ -1,11 +1,20 @@
-import { IAccessGroup, IUser, IZone, IZoneAccessGroup } from "./IAdmin";
+import { IAccessGroup, IDeliverableLocksByAccessGroupResult, IUser, IZone, IZoneAccessGroup, ILocksAndZonesByAccessGroup } from "./IAdmin";
 export declare class AdminRepository {
     private readonly deviceRepository;
     private readonly postgres;
     private readonly localDeviceService;
     private readonly redisUtils;
     constructor();
-    getZonesByAccessGroupIds(accessGroupIds: string[], propertyId: string): Promise<any[]>;
+    /**
+     * Raw zones + devices for access groups (all non-HUB devices). Used when callers need the full list (e.g. UI).
+     */
+    private loadCollectionZonesDevicesByAccessGroupIds;
+    getZonesByAccessGroupIds(accessGroupIds: string[], propertyId: string): Promise<ILocksAndZonesByAccessGroup[]>;
+    /**
+     * ZN-2: same data as {@link getZonesByAccessGroupIds}, but `devices` are only LOCKs that are not
+     * under maintenance (zone or device). `maintenanceSkips` is structured data for audit emission.
+     */
+    getDeliverableLockDevicesByAccessGroupIds(accessGroupIds: string[], propertyId: string): Promise<IDeliverableLocksByAccessGroupResult>;
     getZonesByAccessGroups(accessGroupIds: string[], type?: string[]): Promise<any[]>;
     getAccessGroup(accessGroupId: string, propertyId?: string): Promise<IAccessGroup | null>;
     getZoneAccessGroupByZoneId(zoneId: string): Promise<IZoneAccessGroup[] | null>;

package/dist/entities/admin/Admin.repository.js

@@ -91,7 +91,13 @@ let AdminRepository = (() => {
             this.localDeviceService = typedi_1.default.get(services_1.LocalDeviceService);
             this.redisUtils = typedi_1.default.get(utils_1.RedisUtils);
         }
-        async getZonesByAccessGroupIds(accessGroupIds, propertyId) {
+        /**
+         * Raw zones + devices for access groups (all non-HUB devices). Used when callers need the full list (e.g. UI).
+         */
+        async loadCollectionZonesDevicesByAccessGroupIds(accessGroupIds, propertyId) {
+            if (!accessGroupIds?.length) {
+                return [];
+            }
             // If not cached, get the result from the database
             const result = await this.postgres.query(`SELECT 
         "zc"."id" AS "zoneCollectionMapId",
@@ -100,7 +106,8 @@ let AdminRepository = (() => {
         "z"."id" AS "zoneId",
         "z"."name" AS "zoneName",
         "z"."zoneTypeId",
-        "zt"."name" AS "zoneTypeName"
+        "zt"."name" AS "zoneTypeName",
+        "z"."isUnderMaintenance"
       FROM "dt_zones_collection_map" AS "zc"
       INNER JOIN "dt_zones" AS "z" ON "zc"."zoneId" = "z"."id"
       LEFT JOIN "dt_zoneTypes" AS "zt" ON "z"."zoneTypeId" = "zt"."id"
@@ -171,6 +178,14 @@ let AdminRepository = (() => {
                 zoneIds: _zoneIds,
                 excludeDeviceType: interfaces_1.DeviceType.HUB,
             });
+            // Fetch isUnderMaintenance for ALL zone IDs (including child zones not in the collection map)
+            const allCollectionIds = collectionZone.map((e) => e.collectionId);
+            const [allZoneMaintenanceResult, collectionMaintenanceResult] = await Promise.all([
+                this.postgres.query(`SELECT "id", "isUnderMaintenance" FROM "dt_zones" WHERE "id" = ANY($1)`, [_zoneIds]),
+                this.postgres.query(`SELECT "id", "isUnderMaintenance" FROM "dt_collections" WHERE "id" = ANY($1)`, [allCollectionIds]),
+            ]);
+            const zoneMaintenanceMap = new Map(allZoneMaintenanceResult.rows.map((r) => [r.id, r.isUnderMaintenance ?? false]));
+            const collectionMaintenanceMap = new Map(collectionMaintenanceResult.rows.map((r) => [r.id, r.isUnderMaintenance ?? false]));
             const _collectionZone = collectionZone.map((e) => {
                 const zones = e.zoneIds;
                 let devices = [];
@@ -184,18 +199,21 @@ let AdminRepository = (() => {
                     const _devices = devices.concat(device);
                     devices = _devices;
                     // Create zone data for each zone
+                    // Use zoneMaintenanceMap for isUnderMaintenance so child zones are also covered
                     const zoneInfo = response.find((r) => r.zoneId === element);
                     const zoneData = {
                         zoneId: element,
                         deviceIds: device?.map((d) => d.deviceId), // Get first device ID if available
                         zoneName: zoneInfo?.zoneName || "",
                         zoneType: zoneInfo?.zoneTypeName || null,
+                        isUnderMaintenance: zoneMaintenanceMap.get(element) ?? false,
                     };
                     zonesData.push(zoneData);
                 });
                 e.devices = devices;
                 e.zones = zonesData;
                 e.parentZone = response;
+                e.isUnderMaintenance = collectionMaintenanceMap.get(e.collectionId) ?? false;
                 return e;
             });
             const collectionZoneDevices = Array.from(new Set(_collectionZone));
@@ -207,6 +225,59 @@ let AdminRepository = (() => {
             // );
             return collectionZoneDevices;
         }
+        async getZonesByAccessGroupIds(accessGroupIds, propertyId) {
+            return await this.loadCollectionZonesDevicesByAccessGroupIds(accessGroupIds, propertyId);
+        }
+        /**
+         * ZN-2: same data as {@link getZonesByAccessGroupIds}, but `devices` are only LOCKs that are not
+         * under maintenance (zone or device). `maintenanceSkips` is structured data for audit emission.
+         */
+        async getDeliverableLockDevicesByAccessGroupIds(accessGroupIds, propertyId) {
+            if (!accessGroupIds?.length) {
+                return { collections: [], maintenanceSkips: [] };
+            }
+            const raw = await this.loadCollectionZonesDevicesByAccessGroupIds(accessGroupIds, propertyId);
+            const maintenanceSkips = [];
+            const collections = raw.map((cz) => {
+                const inactiveIds = new Set();
+                for (const zone of cz.zones || []) {
+                    if (zone.isUnderMaintenance) {
+                        (zone.deviceIds || []).forEach((id) => {
+                            if (id != null && id !== "")
+                                inactiveIds.add(String(id));
+                        });
+                        maintenanceSkips.push({
+                            accessGroupId: cz.collectionId,
+                            zoneId: zone.zoneId,
+                            deviceIds: (zone.deviceIds || [])
+                                .map((x) => String(x))
+                                .filter((x) => x !== ""),
+                            reason: "zone inactive",
+                        });
+                    }
+                }
+                for (const dev of cz.devices || []) {
+                    if (dev.deviceType?.type !== "LOCK" || !dev.isUnderMaintenance) {
+                        continue;
+                    }
+                    const did = String(dev.deviceId);
+                    if (inactiveIds.has(did)) {
+                        continue;
+                    }
+                    inactiveIds.add(did);
+                    maintenanceSkips.push({
+                        accessGroupId: cz.collectionId,
+                        zoneId: dev.zoneId,
+                        deviceIds: [did],
+                        reason: "device under maintenance",
+                    });
+                }
+                const deliverableDevices = (cz.devices || []).filter((d) => d.deviceType?.type === "LOCK" &&
+                    !inactiveIds.has(String(d.deviceId)));
+                return { ...cz, devices: deliverableDevices, skippedDevices: cz.devices.filter((device) => device.deviceType?.type === "LOCK" && inactiveIds.has(String(device.deviceId))) };
+            });
+            return { collections, maintenanceSkips };
+        }
         async getZonesByAccessGroups(accessGroupIds, type) {
             // Fetch zone IDs associated with these access groups
             const zonesIdsQuery = `

package/dist/entities/admin/Admin.service.d.ts

@@ -3,7 +3,8 @@ export declare class AdminService {
     private readonly adminRepository;
     private readonly redisUtils;
     constructor();
-    getZonesByAccessGroupIds(accessGroupIds: string[], propertyId: string): Promise<any[]>;
+    getZonesByAccessGroupIds(accessGroupIds: string[], propertyId: string): Promise<import("./IAdmin").ILocksAndZonesByAccessGroup[]>;
+    getDeliverableLockDevicesByAccessGroupIds(accessGroupIds: string[], propertyId: string): Promise<import("./IAdmin").IDeliverableLocksByAccessGroupResult>;
     getZonesByAccessGroups(accessGroupIds: string[], type?: string[]): Promise<any[]>;
     getAccessGroup(accessGroupId: string, propertyId?: string): Promise<IAccessGroup | null>;
     getAccessGroupByZoneId(zoneId: string): Promise<IAccessGroup[] | []>;

package/dist/entities/admin/Admin.service.js

@@ -95,6 +95,15 @@ let AdminService = (() => {
                 return [];
             }
         }
+        async getDeliverableLockDevicesByAccessGroupIds(accessGroupIds, propertyId) {
+            try {
+                return await this.adminRepository.getDeliverableLockDevicesByAccessGroupIds(accessGroupIds, propertyId);
+            }
+            catch (error) {
+                console.log(error);
+                return { collections: [], maintenanceSkips: [] };
+            }
+        }
         async getZonesByAccessGroups(accessGroupIds, type) {
             try {
                 return await this.adminRepository.getZonesByAccessGroups(accessGroupIds, type);
@@ -307,7 +316,9 @@ let AdminService = (() => {
         }
         async propertyHasSaltoConnection(propertyId) {
             const connections = await typedi_1.default.get(connection_1.LocalConnectionService).getConnectionsByPropertyId(propertyId);
-            return connections.every((connection) => connection.connectionProvider === connection_1.ConnectionProvider.SaltoKS ||
+            // using 'some' to check, because property may have TV, Thermostats connections as well,
+            // In that case 'every' will return false and that breaks the SaltoKS check implementation
+            return connections.some((connection) => connection.connectionProvider === connection_1.ConnectionProvider.SaltoKS ||
                 connection.connectionProvider === connection_1.ConnectionProvider.SaltoSpace);
         }
     };

package/dist/entities/admin/IAdmin.d.ts

@@ -1,3 +1,4 @@
+import { IDevice } from "../device/local/interfaces";
 export interface IAccessGroup {
     id: string;
     propertyId: string;
@@ -48,3 +49,42 @@ export interface IUser {
     deletedAt?: Date | null;
     imageURL?: string | null;
 }
+/** ZN-2 skip metadata for callers that emit maintenance audits (e.g. smart-access-node). */
+export type IZn2MaintenanceSkipReason = "zone inactive" | "device under maintenance";
+export interface IZn2MaintenanceSkip {
+    accessGroupId: string;
+    zoneId: string;
+    deviceIds: string[];
+    reason: IZn2MaintenanceSkipReason;
+}
+/** LOCK devices eligible for guest programming after zone + device maintenance rules. */
+export interface IDeliverableLocksByAccessGroupResult {
+    collections: {
+        collectionId: string;
+        devices: IDevice[];
+        skippedDevices: IDevice[];
+        zones: {
+            zoneId: string;
+            deviceIds: string[];
+            zoneName: string;
+            zoneTypeName: string;
+            isUnderMaintenance: boolean;
+        }[];
+        parentZone: any;
+        isUnderMaintenance: boolean;
+    }[];
+    maintenanceSkips: IZn2MaintenanceSkip[];
+}
+export interface ILocksAndZonesByAccessGroup {
+    collectionId: string;
+    devices: IDevice[];
+    zones: {
+        zoneId: string;
+        deviceIds: string[];
+        zoneName: string;
+        zoneTypeName: string;
+        isUnderMaintenance: boolean;
+    }[];
+    parentZone: any;
+    isUnderMaintenance: boolean;
+}

package/dist/entities/connection/Connection.repository.js

@@ -83,7 +83,15 @@ let ConnectionRepository = (() => {
             // Build conditions dynamically based on provided query parameters
             Object.keys(query).forEach((key) => {
                 const value = query[key];
-                if (value !== undefined && value !== null) {
+                if (value === undefined || value === null)
+                    return;
+                // ✅ Special handling for metaData (JSON)
+                if (key === "metaData" && typeof value === "object") {
+                    conditions.push(`"metaData" @> $${paramIndex}`);
+                    values.push(JSON.stringify(value));
+                    paramIndex++;
+                }
+                else {
                     conditions.push(`"${key}" = $${paramIndex}`);
                     values.push(value);
                     paramIndex++;
@@ -117,9 +125,9 @@ let ConnectionRepository = (() => {
                 .join(", ");
             const values = Object.values(data);
             const result = await this.pool.query(`UPDATE dt_connections
-      SET ${setClause}, "updatedAt" = NOW()
-      WHERE id = $1 AND "propertyId" = $2
-      RETURNING *`, [connectionId, propertyId, ...values]);
+     SET ${setClause}, "updatedAt" = NOW()
+     WHERE id = $1 AND "propertyId" = $2
+     RETURNING *`, [connectionId, propertyId, ...values]);
             if (result.rowCount === 0) {
                 return null;
             }

package/dist/entities/connection/Connection.service.d.ts

@@ -1,7 +1,8 @@
 import { IConnection } from "./IConnection";
+import { RedisUtils } from "../../utils";
 export declare class LocalConnectionService {
     private readonly connectionRepository;
-    private readonly redisUtils;
+    protected readonly redisUtils: RedisUtils;
     constructor();
     createConnection(data: Partial<IConnection>): Promise<IConnection>;
     getConnection(connectionId: string): Promise<IConnection>;

package/dist/entities/connection/IConnection.d.ts

@@ -29,5 +29,8 @@ export declare enum ConnectionProvider {
     Dusaw = "Dusaw",
     Lockly = "Lockly",
     Sifely = "Sifely",
-    Twilio = "Twilio"
+    Twilio = "Twilio",
+    Daikin = "Daikin",
+    HoneyWell = "HoneyWell",
+    UltraLock = "UltraLock"
 }

package/dist/entities/connection/IConnection.js

@@ -20,4 +20,7 @@ var ConnectionProvider;
     ConnectionProvider["Lockly"] = "Lockly";
     ConnectionProvider["Sifely"] = "Sifely";
     ConnectionProvider["Twilio"] = "Twilio";
+    ConnectionProvider["Daikin"] = "Daikin";
+    ConnectionProvider["HoneyWell"] = "HoneyWell";
+    ConnectionProvider["UltraLock"] = "UltraLock";
 })(ConnectionProvider || (exports.ConnectionProvider = ConnectionProvider = {}));

package/dist/entities/device/cloud/interfaces/IRawDevice.d.ts

@@ -4,7 +4,9 @@ export declare enum DeviceType {
     LOCK = "LOCK",
     ELEVATOR_LOCK = "ELEVATOR LOCK",
     THERMOSTAT = "THERMOSTAT",
-    TV = "TV"
+    TV = "TV",
+    LIGHT = "LIGHT",
+    ENCODER = "ENCODER"
 }
 export interface IRawDevice {
     deviceId?: string;

package/dist/entities/device/cloud/interfaces/IRawDevice.js

@@ -8,4 +8,6 @@ var DeviceType;
     DeviceType["ELEVATOR_LOCK"] = "ELEVATOR LOCK";
     DeviceType["THERMOSTAT"] = "THERMOSTAT";
     DeviceType["TV"] = "TV";
+    DeviceType["LIGHT"] = "LIGHT";
+    DeviceType["ENCODER"] = "ENCODER";
 })(DeviceType || (exports.DeviceType = DeviceType = {}));

package/dist/entities/device/local/interfaces/IDevice.d.ts

@@ -1,6 +1,7 @@
 export interface IDevice {
     deviceId: string;
     propertyId: string;
+    collectionId?: string;
     zoneId: string;
     name: string;
     hubId: string[];
@@ -48,6 +49,11 @@ export interface IDevice {
     capabilities?: Record<string, any>;
     isDeleted?: boolean;
     deletedAt?: Date;
+    /** Persisted maintenance; ZONE-sourced rows mirror parent zone toggles (smart-cloud). */
+    isUnderMaintenance?: boolean;
+    underMaintenanceSince?: string | Date | null;
+    maintenanceReason?: string | null;
+    maintenanceSource?: "ZONE" | "DEVICE" | null;
 }
 export declare class IStatus {
     online: boolean;

package/dist/entities/device/local/repository/Device.repository.d.ts

@@ -8,6 +8,13 @@ export declare class DeviceRepository {
     getDevice(deviceId: string, withHubDetails?: boolean): Promise<IDevice>;
     updateDevice(deviceId: string, body: any): Promise<IDevice>;
     updateDevices(query: any, updateData: any): Promise<any>;
+    /** Sync Mongo `devices_v2` when smart-cloud toggles zone maintenance (operational device-service). */
+    syncDevicesZoneMaintenance(body: {
+        zoneId: string;
+        enabled: boolean;
+        maintenanceReason?: string | null;
+        underMaintenanceSince?: string | null;
+    }): Promise<any>;
     deleteDevice(deviceId: string): Promise<void>;
     getDevices(deviceIds: string[], withHubDetails?: boolean): Promise<IDevice[]>;
     getPropertyDevices(propertyId: string, selectDeviceId?: boolean, type?: string, withHubDetails?: boolean): Promise<IDevice[]>;

package/dist/entities/device/local/repository/Device.repository.js

@@ -96,6 +96,17 @@ let DeviceRepository = (() => {
                 throw new Error(`Failed to update devices: ${error.message}`);
             }
         }
+        /** Sync Mongo `devices_v2` when smart-cloud toggles zone maintenance (operational device-service). */
+        async syncDevicesZoneMaintenance(body) {
+            try {
+                const response = await this.axiosInstance.put(`/devices/maintenance/zone`, body);
+                return response.data;
+            }
+            catch (error) {
+                (0, config_1.getConfig)().LOGGER.error("Failed to sync zone maintenance to devices:", error);
+                throw new Error(`Failed to sync zone maintenance: ${error.message || "Unknown error"}`);
+            }
+        }
         async deleteDevice(deviceId) {
             try {
                 await this.axiosInstance.delete(`/devices/${deviceId}`);

package/dist/entities/device/local/services/Device.service.d.ts

@@ -13,6 +13,14 @@ export declare class LocalDeviceService {
     getDevices(deviceIds: string[], withHubDetails?: boolean): Promise<IDevice[]>;
     getPropertyDevices(propertyId: string, selectDeviceId?: boolean, type?: string, withHubDetails?: boolean): Promise<IDevice[]>;
     updateDevice(deviceId: string, body: Partial<IDevice>, auditBody: IAuditProperties): Promise<any>;
+    /**
+     * When a zone’s maintenance flag changes in smart-cloud, mirror the same rules as `dt_devices`
+     * onto operational Mongo (`devices_v2`) via device-service.
+     */
+    syncDevicesZoneMaintenance(zoneId: string, enabled: boolean, options?: {
+        maintenanceReason?: string | null;
+        underMaintenanceSince?: string | Date | null;
+    }): Promise<any>;
     updateDevices(query: any, updateData: any): Promise<any>;
     deleteDevice(deviceId: string, auditBody: IAuditProperties): Promise<any>;
     getState(deviceId: string): Promise<any>;

package/dist/entities/device/local/services/Device.service.js

@@ -154,6 +154,27 @@ let LocalDeviceService = (() => {
             await this.deviceRepository.updateDevice(deviceId, body);
             return await this.eventHandler.onDeviceUpdate(deviceId, body, auditBody);
         }
+        /**
+         * When a zone’s maintenance flag changes in smart-cloud, mirror the same rules as `dt_devices`
+         * onto operational Mongo (`devices_v2`) via device-service.
+         */
+        async syncDevicesZoneMaintenance(zoneId, enabled, options) {
+            if (!zoneId) {
+                throw new Error("Zone ID is required");
+            }
+            const body = { zoneId, enabled };
+            if (enabled && options) {
+                if (options.maintenanceReason !== undefined) {
+                    body.maintenanceReason = options.maintenanceReason;
+                }
+                const since = options.underMaintenanceSince;
+                if (since !== undefined && since !== null) {
+                    body.underMaintenanceSince =
+                        since instanceof Date ? since.toISOString() : since;
+                }
+            }
+            return await this.deviceRepository.syncDevicesZoneMaintenance(body);
+        }
         async updateDevices(query, updateData) {
             if (!query || !updateData) {
                 throw new Error("Query and update data are required");