myio-js-library 0.1.169 → 0.1.173

package/dist/myio-js-library.umd.js

@@ -1324,7 +1324,8 @@
     FAILURE: "failure",
     MAINTENANCE: "maintenance",
     NO_INFO: "no_info",
-    NOT_INSTALLED: "not_installed"
+    NOT_INSTALLED: "not_installed",
+    OFFLINE: "offline"
   };
   var ConnectionStatusType = {
     CONNECTED: "connected",
@@ -1333,39 +1334,42 @@
   var deviceStatusIcons = {
     [DeviceStatusType.POWER_ON]: "\u26A1",
     [DeviceStatusType.STANDBY]: "\u{1F50C}",
-    [DeviceStatusType.POWER_OFF]: "\u{1F534}",
+    [DeviceStatusType.POWER_OFF]: "\u26AB",
     [DeviceStatusType.WARNING]: "\u26A0\uFE0F",
     [DeviceStatusType.FAILURE]: "\u{1F6A8}",
     [DeviceStatusType.MAINTENANCE]: "\u{1F6E0}\uFE0F",
     [DeviceStatusType.NO_INFO]: "\u2753\uFE0F",
-    [DeviceStatusType.NOT_INSTALLED]: "\u{1F4E6}"
+    [DeviceStatusType.NOT_INSTALLED]: "\u{1F4E6}",
+    [DeviceStatusType.OFFLINE]: "\u{1F534}"
   };
   var waterDeviceStatusIcons = {
     [DeviceStatusType.POWER_ON]: "\u{1F4A7}",
     [DeviceStatusType.STANDBY]: "\u{1F6B0}",
-    [DeviceStatusType.POWER_OFF]: "\u{1F534}",
+    [DeviceStatusType.POWER_OFF]: "\u26AB",
     [DeviceStatusType.WARNING]: "\u26A0\uFE0F",
     [DeviceStatusType.FAILURE]: "\u{1F6A8}",
     [DeviceStatusType.MAINTENANCE]: "\u{1F6E0}\uFE0F",
     [DeviceStatusType.NO_INFO]: "\u2753\uFE0F",
-    [DeviceStatusType.NOT_INSTALLED]: "\u{1F4E6}"
+    [DeviceStatusType.NOT_INSTALLED]: "\u{1F4E6}",
+    [DeviceStatusType.OFFLINE]: "\u{1F534}"
   };
   var temperatureDeviceStatusIcons = {
     [DeviceStatusType.POWER_ON]: "\u{1F321}\uFE0F",
     [DeviceStatusType.STANDBY]: "\u{1F321}\uFE0F",
-    [DeviceStatusType.POWER_OFF]: "\u{1F534}",
+    [DeviceStatusType.POWER_OFF]: "\u26AB",
     [DeviceStatusType.WARNING]: "\u26A0\uFE0F",
     [DeviceStatusType.FAILURE]: "\u{1F6A8}",
     [DeviceStatusType.MAINTENANCE]: "\u{1F6E0}\uFE0F",
     [DeviceStatusType.NO_INFO]: "\u2753\uFE0F",
-    [DeviceStatusType.NOT_INSTALLED]: "\u{1F4E6}"
+    [DeviceStatusType.NOT_INSTALLED]: "\u{1F4E6}",
+    [DeviceStatusType.OFFLINE]: "\u{1F534}"
   };
   var connectionStatusIcons = {
     [ConnectionStatusType.CONNECTED]: "\u{1F7E2}",
     [ConnectionStatusType.OFFLINE]: "\u{1F6AB}"
   };
   function mapDeviceToConnectionStatus(deviceStatus) {
-    if (deviceStatus === DeviceStatusType.NO_INFO) {
+    if (deviceStatus === DeviceStatusType.NO_INFO || deviceStatus === DeviceStatusType.OFFLINE) {
       return ConnectionStatusType.OFFLINE;
     }
     return ConnectionStatusType.CONNECTED;
@@ -1389,15 +1393,16 @@
       [DeviceStatusType.FAILURE]: "fail",
       [DeviceStatusType.MAINTENANCE]: "alert",
       [DeviceStatusType.NO_INFO]: "unknown",
-      [DeviceStatusType.NOT_INSTALLED]: "not_installed"
+      [DeviceStatusType.NOT_INSTALLED]: "not_installed",
+      [DeviceStatusType.OFFLINE]: "offline"
     };
     return statusMap[deviceStatus] || "unknown";
   }
   function shouldFlashIcon(deviceStatus) {
-    return deviceStatus === DeviceStatusType.POWER_OFF || deviceStatus === DeviceStatusType.WARNING || deviceStatus === DeviceStatusType.FAILURE || deviceStatus === DeviceStatusType.MAINTENANCE;
+    return deviceStatus === DeviceStatusType.POWER_OFF || deviceStatus === DeviceStatusType.WARNING || deviceStatus === DeviceStatusType.FAILURE || deviceStatus === DeviceStatusType.MAINTENANCE || deviceStatus === DeviceStatusType.OFFLINE;
   }
   function isDeviceOffline(deviceStatus) {
-    return deviceStatus === DeviceStatusType.NO_INFO;
+    return deviceStatus === DeviceStatusType.NO_INFO || deviceStatus === DeviceStatusType.OFFLINE;
   }
   function getDeviceStatusIcon(deviceStatus, deviceType = null) {
     const normalizedType = deviceType?.toUpperCase() || "";
@@ -3953,15 +3958,30 @@
   --myio-chip-alert-fg: #b45309;
   --myio-border-alert: rgba(245, 158, 11, 0.5);
 
-  /* Status colors - Failure (red) */
+  /* Status colors - Failure (dark red) */
   --myio-chip-failure-bg: #fee2e2;
   --myio-chip-failure-fg: #b91c1c;
-  --myio-border-failure: rgba(239, 68, 68, 0.5);
+  --myio-border-failure: rgba(153, 27, 27, 0.6);
+
+  /* Status colors - Power Off (light red) */
+  --myio-chip-power-off-bg: #fecaca;
+  --myio-chip-power-off-fg: #dc2626;
+  --myio-border-power-off: rgba(239, 68, 68, 0.5);
+
+  /* Status colors - Offline (dark gray) */
+  --myio-chip-offline-bg: #e2e8f0;
+  --myio-chip-offline-fg: #475569;
+  --myio-border-offline: rgba(71, 85, 105, 0.6);
+
+  /* Status colors - No Info (dark orange) */
+  --myio-chip-no-info-bg: #fed7aa;
+  --myio-chip-no-info-fg: #c2410c;
+  --myio-border-no-info: rgba(194, 65, 12, 0.5);
 
-  /* Status colors - Offline (gray) */
-  --myio-chip-offline-bg: #f1f5f9;
-  --myio-chip-offline-fg: #64748b;
-  --myio-border-offline: rgba(100, 116, 139, 0.4);
+  /* Status colors - Not Installed (purple) */
+  --myio-chip-not-installed-bg: #e9d5ff;
+  --myio-chip-not-installed-fg: #7c3aed;
+  --myio-border-not-installed: rgba(124, 58, 237, 0.5);
 
   --myio-text-1: #0f172a;
   --myio-text-2: #4b5563;
@@ -4017,26 +4037,55 @@
 }
 
 /* Card border states based on device status */
-.myio-ho-card.is-ok {
+
+/* POWER_ON - Blue */
+.myio-ho-card.is-power-on {
   border-color: var(--myio-border-ok);
   box-shadow: 0 0 0 2px var(--myio-border-ok), var(--myio-card-shadow);
 }
 
+/* STANDBY - Green */
 .myio-ho-card.is-standby {
   border-color: var(--myio-border-standby);
   box-shadow: 0 0 0 2px var(--myio-border-standby), var(--myio-card-shadow);
 }
 
-.myio-ho-card.is-alert {
+/* WARNING - Yellow */
+.myio-ho-card.is-warning {
+  border-color: var(--myio-border-alert);
+  box-shadow: 0 0 0 2px var(--myio-border-alert), var(--myio-card-shadow);
+}
+
+/* MAINTENANCE - Yellow */
+.myio-ho-card.is-maintenance {
   border-color: var(--myio-border-alert);
   box-shadow: 0 0 0 2px var(--myio-border-alert), var(--myio-card-shadow);
 }
 
+/* FAILURE - Dark Red */
 .myio-ho-card.is-failure {
   border-color: var(--myio-border-failure);
   box-shadow: 0 0 0 2px var(--myio-border-failure), var(--myio-card-shadow);
 }
 
+/* POWER_OFF - Light Red */
+.myio-ho-card.is-power-off {
+  border-color: var(--myio-border-power-off);
+  box-shadow: 0 0 0 2px var(--myio-border-power-off), var(--myio-card-shadow);
+}
+
+/* NO_INFO - Dark Orange */
+.myio-ho-card.is-no-info {
+  border-color: var(--myio-border-no-info);
+  box-shadow: 0 0 0 2px var(--myio-border-no-info), var(--myio-card-shadow);
+}
+
+/* NOT_INSTALLED - Purple */
+.myio-ho-card.is-not-installed {
+  border-color: var(--myio-border-not-installed);
+  box-shadow: 0 0 0 2px var(--myio-border-not-installed), var(--myio-card-shadow);
+}
+
 /* Header section */
 .myio-ho-card__header {
   display: flex;
@@ -4054,7 +4103,9 @@
   margin-top: 2px;
 }
 
-.myio-ho-card.is-alert .myio-ho-card__icon {
+/* Icon colors based on status */
+.myio-ho-card.is-warning .myio-ho-card__icon,
+.myio-ho-card.is-maintenance .myio-ho-card__icon {
   color: var(--myio-chip-alert-fg);
 }
 
@@ -4062,14 +4113,28 @@
   color: var(--myio-chip-failure-fg);
 }
 
+.myio-ho-card.is-power-off .myio-ho-card__icon {
+  color: var(--myio-chip-power-off-fg);
+}
+
+.myio-ho-card.is-offline .myio-ho-card__icon {
+  color: var(--myio-chip-offline-fg);
+}
+
+.myio-ho-card.is-no-info .myio-ho-card__icon {
+  color: var(--myio-chip-no-info-fg);
+}
+
+.myio-ho-card.is-not-installed .myio-ho-card__icon {
+  color: var(--myio-chip-not-installed-fg);
+}
+
 .myio-ho-card__title {
   flex: 1;
   min-width: 0;
 }
 
-/* Adicione estas duas novas regras ao seu CSS_STRING */
-
-/* Estado Offline - borda cinza */
+/* OFFLINE - Dark Gray */
 .myio-ho-card.is-offline {
   border-color: var(--myio-border-offline);
   box-shadow: 0 0 0 2px var(--myio-border-offline), var(--myio-card-shadow);
@@ -4464,6 +4529,37 @@
   color: var(--myio-chip-offline-fg);
 }
 
+/* New chip classes aligned with getCardStateClass */
+.chip--power-on {
+  background: var(--myio-chip-ok-bg);
+  color: var(--myio-chip-ok-fg);
+}
+
+.chip--warning {
+  background: var(--myio-chip-alert-bg);
+  color: var(--myio-chip-alert-fg);
+}
+
+.chip--maintenance {
+  background: var(--myio-chip-alert-bg);
+  color: var(--myio-chip-alert-fg);
+}
+
+.chip--power-off {
+  background: var(--myio-chip-power-off-bg);
+  color: var(--myio-chip-power-off-fg);
+}
+
+.chip--no-info {
+  background: var(--myio-chip-no-info-bg);
+  color: var(--myio-chip-no-info-fg);
+}
+
+.chip--not-installed {
+  background: var(--myio-chip-not-installed-bg);
+  color: var(--myio-chip-not-installed-fg);
+}
+
 /* Status indicator dot for power metric */
 .status-dot {
   width: 8px;
@@ -4497,6 +4593,31 @@
   background: var(--myio-muted);
 }
 
+/* New dot classes aligned with getCardStateClass */
+.status-dot.dot--power-on {
+  background: var(--myio-chip-ok-fg);
+}
+
+.status-dot.dot--warning {
+  background: var(--myio-chip-alert-fg);
+}
+
+.status-dot.dot--maintenance {
+  background: var(--myio-chip-alert-fg);
+}
+
+.status-dot.dot--power-off {
+  background: var(--myio-chip-power-off-fg);
+}
+
+.status-dot.dot--no-info {
+  background: var(--myio-chip-no-info-fg);
+}
+
+.status-dot.dot--not-installed {
+  background: var(--myio-chip-not-installed-fg);
+}
+
 /* Primary metric */
 .myio-ho-card__primary {
   margin-bottom: 14px;
@@ -4679,6 +4800,215 @@
     transition: none;
   }
 }
+
+/* ============================================
+   DEBUG TOOLTIP STYLES (Premium)
+   ============================================ */
+
+.has-debug-tooltip {
+  cursor: help !important;
+}
+
+.has-debug-tooltip::after {
+  content: '\u{1F41B}';
+  position: absolute;
+  top: -4px;
+  right: -4px;
+  font-size: 10px;
+  z-index: 1;
+}
+
+.debug-tooltip-container {
+  position: absolute;
+  bottom: calc(100% + 8px);
+  left: 50%;
+  transform: translateX(-50%);
+  z-index: 10000;
+  pointer-events: none;
+  opacity: 0;
+  transition: opacity 0.2s ease, transform 0.2s ease;
+}
+
+.has-debug-tooltip:hover .debug-tooltip-container {
+  opacity: 1;
+  pointer-events: auto;
+}
+
+.debug-tooltip {
+  background: linear-gradient(135deg, #1e293b 0%, #0f172a 100%);
+  border: 1px solid rgba(99, 102, 241, 0.3);
+  border-radius: 12px;
+  box-shadow:
+    0 20px 40px rgba(0, 0, 0, 0.4),
+    0 0 0 1px rgba(255, 255, 255, 0.05),
+    inset 0 1px 0 rgba(255, 255, 255, 0.1);
+  min-width: 340px;
+  max-width: 420px;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  font-size: 12px;
+  color: #e2e8f0;
+  overflow: hidden;
+}
+
+.debug-tooltip__header {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 12px 16px;
+  background: linear-gradient(90deg, rgba(99, 102, 241, 0.2) 0%, rgba(139, 92, 246, 0.1) 100%);
+  border-bottom: 1px solid rgba(99, 102, 241, 0.2);
+}
+
+.debug-tooltip__icon {
+  font-size: 16px;
+}
+
+.debug-tooltip__title {
+  font-weight: 700;
+  font-size: 13px;
+  color: #f1f5f9;
+  letter-spacing: 0.5px;
+  text-transform: uppercase;
+}
+
+.debug-tooltip__content {
+  padding: 12px 16px;
+  max-height: 400px;
+  overflow-y: auto;
+}
+
+.debug-tooltip__section {
+  margin-bottom: 14px;
+  padding-bottom: 12px;
+  border-bottom: 1px solid rgba(148, 163, 184, 0.1);
+}
+
+.debug-tooltip__section:last-child {
+  margin-bottom: 0;
+  padding-bottom: 0;
+  border-bottom: none;
+}
+
+.debug-tooltip__section-title {
+  font-size: 11px;
+  font-weight: 600;
+  color: #94a3b8;
+  text-transform: uppercase;
+  letter-spacing: 0.8px;
+  margin-bottom: 10px;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.debug-tooltip__row {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  padding: 4px 0;
+  gap: 12px;
+}
+
+.debug-tooltip__row--full {
+  flex-direction: column;
+  gap: 4px;
+}
+
+.debug-tooltip__label {
+  color: #94a3b8;
+  font-size: 11px;
+  flex-shrink: 0;
+}
+
+.debug-tooltip__value {
+  color: #f1f5f9;
+  font-weight: 500;
+  text-align: right;
+  word-break: break-all;
+}
+
+.debug-tooltip__row--full .debug-tooltip__value {
+  text-align: left;
+  background: rgba(0, 0, 0, 0.3);
+  padding: 6px 10px;
+  border-radius: 6px;
+  font-size: 11px;
+  width: 100%;
+  box-sizing: border-box;
+}
+
+.debug-tooltip__value--mono {
+  font-family: 'SF Mono', 'Fira Code', 'Consolas', monospace;
+  font-size: 11px;
+  background: rgba(0, 0, 0, 0.3);
+  padding: 2px 6px;
+  border-radius: 4px;
+}
+
+.debug-tooltip__value--highlight {
+  color: #a5b4fc;
+  font-style: italic;
+}
+
+.debug-tooltip__badge {
+  display: inline-block;
+  padding: 2px 8px;
+  border-radius: 4px;
+  font-size: 10px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+  background: rgba(99, 102, 241, 0.3);
+  color: #a5b4fc;
+}
+
+.debug-tooltip__badge--energy {
+  background: rgba(59, 130, 246, 0.3);
+  color: #93c5fd;
+}
+
+.debug-tooltip__badge--water {
+  background: rgba(6, 182, 212, 0.3);
+  color: #67e8f9;
+}
+
+.debug-tooltip__badge--temperature {
+  background: rgba(249, 115, 22, 0.3);
+  color: #fdba74;
+}
+
+/* Tooltip arrow */
+.debug-tooltip::after {
+  content: '';
+  position: absolute;
+  bottom: -6px;
+  left: 50%;
+  transform: translateX(-50%) rotate(45deg);
+  width: 12px;
+  height: 12px;
+  background: #0f172a;
+  border-right: 1px solid rgba(99, 102, 241, 0.3);
+  border-bottom: 1px solid rgba(99, 102, 241, 0.3);
+}
+
+/* Scrollbar styling for tooltip content */
+.debug-tooltip__content::-webkit-scrollbar {
+  width: 6px;
+}
+
+.debug-tooltip__content::-webkit-scrollbar-track {
+  background: rgba(0, 0, 0, 0.2);
+  border-radius: 3px;
+}
+
+.debug-tooltip__content::-webkit-scrollbar-thumb {
+  background: rgba(99, 102, 241, 0.4);
+  border-radius: 3px;
+}
+
+.debug-tooltip__content::-webkit-scrollbar-thumb:hover {
+  background: rgba(99, 102, 241, 0.6);
+}
 `;
 
   // src/thingsboard/main-dashboard-shopping/v-4.0.0/head-office/card-head-office.icons.ts
@@ -4819,46 +5149,295 @@
     menu_settings: "Configura\xE7\xF5es"
   };
 
-  // src/thingsboard/main-dashboard-shopping/v-4.0.0/card/head-office/card-head-office.js
-  var CSS_TAG = "head-office-card-v1";
-  function ensureCss() {
-    if (!document.querySelector(`style[data-myio-css="${CSS_TAG}"]`)) {
-      const style = document.createElement("style");
-      style.setAttribute("data-myio-css", CSS_TAG);
-      style.textContent = CSS_STRING;
-      document.head.appendChild(style);
-    }
+  // src/components/temperature/utils.ts
+  var DAY_PERIODS = [
+    { id: "madrugada", label: "Madrugada (00h-06h)", startHour: 0, endHour: 6 },
+    { id: "manha", label: "Manh\xE3 (06h-12h)", startHour: 6, endHour: 12 },
+    { id: "tarde", label: "Tarde (12h-18h)", startHour: 12, endHour: 18 },
+    { id: "noite", label: "Noite (18h-24h)", startHour: 18, endHour: 24 }
+  ];
+  var DEFAULT_CLAMP_RANGE = { min: 15, max: 40 };
+  function getTodaySoFar() {
+    const now = /* @__PURE__ */ new Date();
+    const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0);
+    return {
+      startTs: startOfDay.getTime(),
+      endTs: now.getTime()
+    };
   }
-  function normalizeParams(params) {
-    if (!params || !params.entityObject) {
-      throw new Error("renderCardCompenteHeadOffice: entityObject is required");
+  var CHART_COLORS = [
+    "#1976d2",
+    // Blue
+    "#FF6B6B",
+    // Red
+    "#4CAF50",
+    // Green
+    "#FF9800",
+    // Orange
+    "#9C27B0",
+    // Purple
+    "#00BCD4",
+    // Cyan
+    "#E91E63",
+    // Pink
+    "#795548"
+    // Brown
+  ];
+  async function fetchTemperatureData(token, deviceId, startTs, endTs) {
+    const url = `/api/plugins/telemetry/DEVICE/${deviceId}/values/timeseries?keys=temperature&startTs=${encodeURIComponent(startTs)}&endTs=${encodeURIComponent(endTs)}&limit=50000&agg=NONE`;
+    const response = await fetch(url, {
+      headers: {
+        "X-Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch temperature data: ${response.status}`);
     }
-    const entityObject = params.entityObject;
-    if (!entityObject.entityId) {
-      console.warn("renderCardCompenteHeadOffice: entityId is missing, generating temporary ID");
-      entityObject.entityId = `temp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const data = await response.json();
+    return data?.temperature || [];
+  }
+  function clampTemperature(value, range = DEFAULT_CLAMP_RANGE) {
+    const num = Number(value || 0);
+    if (num < range.min) return range.min;
+    if (num > range.max) return range.max;
+    return num;
+  }
+  function calculateStats(data, clampRange = DEFAULT_CLAMP_RANGE) {
+    if (data.length === 0) {
+      return { avg: 0, min: 0, max: 0, count: 0 };
     }
+    const values = data.map((item) => clampTemperature(item.value, clampRange));
+    const sum = values.reduce((acc, v) => acc + v, 0);
     return {
-      entityObject,
-      i18n: { ...DEFAULT_I18N, ...params.i18n || {} },
-      enableSelection: Boolean(params.enableSelection),
-      enableDragDrop: Boolean(params.enableDragDrop),
-      useNewComponents: Boolean(params.useNewComponents),
-      // RFC-0091: Configurable delay time for connection status check (default 15 minutes)
-      delayTimeConnectionInMins: params.delayTimeConnectionInMins ?? 15,
-      callbacks: {
-        handleActionDashboard: params.handleActionDashboard,
-        handleActionReport: params.handleActionReport,
-        handleActionSettings: params.handleActionSettings,
-        handleSelect: params.handleSelect,
-        handInfo: params.handInfo,
-        handleClickCard: params.handleClickCard
-      }
+      avg: sum / values.length,
+      min: Math.min(...values),
+      max: Math.max(...values),
+      count: values.length
     };
   }
-  function getIconSvg(deviceType, domain) {
-    if (domain === "water") {
-      return Icons.waterDrop;
+  function interpolateTemperature(data, options) {
+    const { intervalMinutes, startTs, endTs, clampRange = DEFAULT_CLAMP_RANGE } = options;
+    const intervalMs = intervalMinutes * 60 * 1e3;
+    if (data.length === 0) {
+      return [];
+    }
+    const sortedData = [...data].sort((a, b) => a.ts - b.ts);
+    const result = [];
+    let lastKnownValue = clampTemperature(sortedData[0].value, clampRange);
+    let dataIndex = 0;
+    for (let ts = startTs; ts <= endTs; ts += intervalMs) {
+      while (dataIndex < sortedData.length - 1 && sortedData[dataIndex + 1].ts <= ts) {
+        dataIndex++;
+      }
+      const currentData = sortedData[dataIndex];
+      if (currentData && Math.abs(currentData.ts - ts) < intervalMs) {
+        lastKnownValue = clampTemperature(currentData.value, clampRange);
+      }
+      result.push({
+        ts,
+        value: lastKnownValue
+      });
+    }
+    return result;
+  }
+  function aggregateByDay(data, clampRange = DEFAULT_CLAMP_RANGE) {
+    if (data.length === 0) {
+      return [];
+    }
+    const dayMap = /* @__PURE__ */ new Map();
+    data.forEach((item) => {
+      const date = new Date(item.ts);
+      const dateKey = date.toISOString().split("T")[0];
+      if (!dayMap.has(dateKey)) {
+        dayMap.set(dateKey, []);
+      }
+      dayMap.get(dateKey).push(item);
+    });
+    const result = [];
+    dayMap.forEach((dayData, dateKey) => {
+      const values = dayData.map((item) => clampTemperature(item.value, clampRange));
+      const sum = values.reduce((acc, v) => acc + v, 0);
+      result.push({
+        date: dateKey,
+        dateTs: new Date(dateKey).getTime(),
+        avg: sum / values.length,
+        min: Math.min(...values),
+        max: Math.max(...values),
+        count: values.length
+      });
+    });
+    return result.sort((a, b) => a.dateTs - b.dateTs);
+  }
+  function filterByDayPeriods(data, selectedPeriods) {
+    if (selectedPeriods.length === 0 || selectedPeriods.length === DAY_PERIODS.length) {
+      return data;
+    }
+    return data.filter((item) => {
+      const date = new Date(item.ts);
+      const hour = date.getHours();
+      return selectedPeriods.some((periodId) => {
+        const period = DAY_PERIODS.find((p) => p.id === periodId);
+        if (!period) return false;
+        return hour >= period.startHour && hour < period.endHour;
+      });
+    });
+  }
+  function getSelectedPeriodsLabel(selectedPeriods) {
+    if (selectedPeriods.length === 0 || selectedPeriods.length === DAY_PERIODS.length) {
+      return "Todos os per\xEDodos";
+    }
+    if (selectedPeriods.length === 1) {
+      const period = DAY_PERIODS.find((p) => p.id === selectedPeriods[0]);
+      return period?.label || "";
+    }
+    return `${selectedPeriods.length} per\xEDodos selecionados`;
+  }
+  function formatTemperature(value, decimals = 1) {
+    if (value === null || value === void 0 || isNaN(value)) {
+      return "\u2014";
+    }
+    return `${value.toFixed(decimals)}\xB0C`;
+  }
+  function exportTemperatureCSV(data, deviceLabel, stats, startDate, endDate) {
+    if (data.length === 0) {
+      console.warn("No data to export");
+      return;
+    }
+    const BOM = "\uFEFF";
+    let csvContent = BOM;
+    csvContent += `Relat\xF3rio de Temperatura - ${deviceLabel}
+`;
+    csvContent += `Per\xEDodo: ${startDate} at\xE9 ${endDate}
+`;
+    csvContent += `M\xE9dia: ${formatTemperature(stats.avg)}
+`;
+    csvContent += `M\xEDnima: ${formatTemperature(stats.min)}
+`;
+    csvContent += `M\xE1xima: ${formatTemperature(stats.max)}
+`;
+    csvContent += `Total de leituras: ${stats.count}
+`;
+    csvContent += "\n";
+    csvContent += "Data/Hora,Temperatura (\xB0C)\n";
+    data.forEach((item) => {
+      const date = new Date(item.ts).toLocaleString("pt-BR");
+      const temp = Number(item.value).toFixed(2);
+      csvContent += `"${date}",${temp}
+`;
+    });
+    const blob = new Blob([csvContent], { type: "text/csv;charset=utf-8;" });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = `temperatura_${deviceLabel.replace(/\s+/g, "_")}_${startDate}_${endDate}.csv`;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+  }
+  var DARK_THEME = {
+    background: "rgba(0, 0, 0, 0.85)",
+    surface: "#1a1f28",
+    text: "#ffffff",
+    textMuted: "rgba(255, 255, 255, 0.7)",
+    border: "rgba(255, 255, 255, 0.1)",
+    primary: "#1976d2",
+    success: "#4CAF50",
+    warning: "#FF9800",
+    danger: "#f44336",
+    chartLine: "#1976d2",
+    chartGrid: "rgba(255, 255, 255, 0.1)"
+  };
+  var LIGHT_THEME = {
+    background: "rgba(0, 0, 0, 0.6)",
+    surface: "#ffffff",
+    text: "#333333",
+    textMuted: "#666666",
+    border: "#e0e0e0",
+    primary: "#1976d2",
+    success: "#4CAF50",
+    warning: "#FF9800",
+    danger: "#f44336",
+    chartLine: "#1976d2",
+    chartGrid: "#e0e0e0"
+  };
+  function getThemeColors(theme) {
+    return theme === "dark" ? DARK_THEME : LIGHT_THEME;
+  }
+
+  // src/utils/logHelper.js
+  function createLogHelper(debugActive = false) {
+    return {
+      log: function(...args) {
+        if (debugActive) {
+          console.log(...args);
+        }
+      },
+      warn: function(...args) {
+        if (debugActive) {
+          console.warn(...args);
+        }
+      },
+      error: function(...args) {
+        console.error(...args);
+      }
+    };
+  }
+
+  // src/thingsboard/main-dashboard-shopping/v-4.0.0/card/head-office/card-head-office.js
+  var LABEL_CHAR_LIMIT = 18;
+  var DEFAUL_DELAY_TIME_CONNECTION_IN_MINS = 1440;
+  var CSS_TAG = "head-office-card-v1";
+  function ensureCss() {
+    if (!document.querySelector(`style[data-myio-css="${CSS_TAG}"]`)) {
+      const style = document.createElement("style");
+      style.setAttribute("data-myio-css", CSS_TAG);
+      style.textContent = CSS_STRING;
+      document.head.appendChild(style);
+    }
+  }
+  function normalizeParams(params) {
+    if (!params || !params.entityObject) {
+      throw new Error("renderCardCompenteHeadOffice: entityObject is required");
+    }
+    const LogHelper2 = createLogHelper(params.debugActive ?? false);
+    const entityObject = params.entityObject;
+    if (!entityObject.entityId) {
+      LogHelper2.warn("[CardHeadOffice] entityId is missing, generating temporary ID");
+      entityObject.entityId = `temp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    if (!params.delayTimeConnectionInMins) {
+      LogHelper2.warn(
+        `[CardHeadOffice] delayTimeConnectionInMins is missing, defaulting to ${DEFAUL_DELAY_TIME_CONNECTION_IN_MINS} mins`
+      );
+    }
+    return {
+      entityObject,
+      i18n: { ...DEFAULT_I18N, ...params.i18n || {} },
+      enableSelection: Boolean(params.enableSelection),
+      enableDragDrop: Boolean(params.enableDragDrop),
+      useNewComponents: Boolean(params.useNewComponents),
+      // RFC-0091: Configurable delay time for connection status check (default 15 minutes)
+      delayTimeConnectionInMins: params.delayTimeConnectionInMins ?? DEFAUL_DELAY_TIME_CONNECTION_IN_MINS,
+      // Debug options
+      debugActive: params.debugActive ?? false,
+      activeTooltipDebug: params.activeTooltipDebug ?? false,
+      // LogHelper instance for this card
+      LogHelper: LogHelper2,
+      callbacks: {
+        handleActionDashboard: params.handleActionDashboard,
+        handleActionReport: params.handleActionReport,
+        handleActionSettings: params.handleActionSettings,
+        handleSelect: params.handleSelect,
+        handInfo: params.handInfo,
+        handleClickCard: params.handleClickCard
+      }
+    };
+  }
+  function getIconSvg(deviceType, domain) {
+    if (domain === "water") {
+      return Icons.waterDrop;
     }
     if (domain === "temperature") {
       return Icons.thermometer;
@@ -4883,16 +5462,10 @@
       return formatWaterVolumeM3(value);
     }
     if (domain === "temperature") {
-      return formatTemperature(value);
+      return formatTemperature(value, 0);
     }
     return formatEnergy(value);
   }
-  function formatTemperature(temp) {
-    if (temp === null || temp === void 0 || isNaN(temp)) {
-      return "\u2014";
-    }
-    return `${temp.toFixed(0)}\xB0C`;
-  }
   function calculateConsumptionPercentage(target, consumption) {
     const numericTarget = Number(target);
     const numericConsumption = Number(consumption);
@@ -4907,32 +5480,32 @@
       // --- Novos Status de Temperatura ---
       case "normal":
         return { chipClass: "chip--ok", label: "Normal" };
-      // Verde/Azul
       case "cold":
         return { chipClass: "chip--standby", label: "Frio" };
-      // Azul claro/Ciano
       case "hot":
         return { chipClass: "chip--alert", label: "Quente" };
-      // Laranja/Amarelo
-      // --- Status Existentes ---
+      // --- Status Existentes (aligned with getCardStateClass) ---
       case DeviceStatusType.POWER_ON:
         if (domain === "water") {
-          return { chipClass: "chip--ok", label: i18n.in_operation_water };
+          return { chipClass: "chip--power-on", label: i18n.in_operation_water };
         }
-        return { chipClass: "chip--ok", label: i18n.in_operation };
+        return { chipClass: "chip--power-on", label: i18n.in_operation };
       case DeviceStatusType.STANDBY:
         return { chipClass: "chip--standby", label: i18n.standby };
       case DeviceStatusType.WARNING:
-        return { chipClass: "chip--alert", label: i18n.alert };
+        return { chipClass: "chip--warning", label: i18n.alert };
+      case DeviceStatusType.MAINTENANCE:
+        return { chipClass: "chip--maintenance", label: i18n.maintenance };
       case DeviceStatusType.FAILURE:
-      case DeviceStatusType.POWER_OFF:
         return { chipClass: "chip--failure", label: i18n.failure };
-      case DeviceStatusType.MAINTENANCE:
-        return { chipClass: "chip--alert", label: i18n.maintenance };
-      case DeviceStatusType.NOT_INSTALLED:
-        return { chipClass: "chip--offline", label: i18n.not_installed };
-      // Default (Cai aqui se não achar 'normal', 'hot' etc)
+      case DeviceStatusType.POWER_OFF:
+        return { chipClass: "chip--power-off", label: i18n.power_off || i18n.failure };
+      case DeviceStatusType.OFFLINE:
+        return { chipClass: "chip--offline", label: i18n.offline };
       case DeviceStatusType.NO_INFO:
+        return { chipClass: "chip--no-info", label: i18n.no_info || i18n.offline };
+      case DeviceStatusType.NOT_INSTALLED:
+        return { chipClass: "chip--not-installed", label: i18n.not_installed };
       default:
         return { chipClass: "chip--offline", label: i18n.offline };
     }
@@ -4940,23 +5513,32 @@
   function getCardStateClass(deviceStatus) {
     switch (deviceStatus) {
       case DeviceStatusType.POWER_ON:
-        return "is-ok";
+        return "is-power-on";
       // Blue border
       case DeviceStatusType.STANDBY:
         return "is-standby";
       // Green border
       case DeviceStatusType.WARNING:
+        return "is-warning";
+      // Yellow border
       case DeviceStatusType.MAINTENANCE:
-        return "is-alert";
+        return "is-maintenance";
       // Yellow border
       case DeviceStatusType.FAILURE:
-      case DeviceStatusType.POWER_OFF:
         return "is-failure";
-      // Red border
+      // Dark Red border
+      case DeviceStatusType.POWER_OFF:
+        return "is-power-off";
+      // Light Red border
+      case DeviceStatusType.OFFLINE:
+        return "is-offline";
+      // Dark Gray border
       case DeviceStatusType.NO_INFO:
+        return "is-no-info";
+      // Dark Orange border
       case DeviceStatusType.NOT_INSTALLED:
-        return "is-offline";
-      // Gray border
+        return "is-not-installed";
+      // Purple border
       default:
         return "";
     }
@@ -4970,17 +5552,25 @@
         return "dot--standby";
       case "hot":
         return "dot--alert";
-      // --- Status Existentes ---
+      // --- Status Existentes (aligned with getCardStateClass) ---
       case DeviceStatusType.POWER_ON:
-        return "dot--ok";
+        return "dot--power-on";
       case DeviceStatusType.STANDBY:
         return "dot--standby";
       case DeviceStatusType.WARNING:
+        return "dot--warning";
       case DeviceStatusType.MAINTENANCE:
-        return "dot--alert";
+        return "dot--maintenance";
       case DeviceStatusType.FAILURE:
-      case DeviceStatusType.POWER_OFF:
         return "dot--failure";
+      case DeviceStatusType.POWER_OFF:
+        return "dot--power-off";
+      case DeviceStatusType.OFFLINE:
+        return "dot--offline";
+      case DeviceStatusType.NO_INFO:
+        return "dot--no-info";
+      case DeviceStatusType.NOT_INSTALLED:
+        return "dot--not-installed";
       default:
         return "dot--offline";
     }
@@ -5004,7 +5594,13 @@
     titleSection.className = "myio-ho-card__title";
     const nameEl = document.createElement("div");
     nameEl.className = "myio-ho-card__name";
-    nameEl.textContent = entityObject.labelOrName || "Unknown Device";
+    const fullName = entityObject.labelOrName || "Unknown Device";
+    if (fullName.length > LABEL_CHAR_LIMIT) {
+      nameEl.textContent = fullName.slice(0, LABEL_CHAR_LIMIT) + "\u2026";
+      nameEl.title = fullName;
+    } else {
+      nameEl.textContent = fullName;
+    }
     titleSection.appendChild(nameEl);
     if (entityObject.deviceIdentifier) {
       const codeEl = document.createElement("div");
@@ -5133,29 +5729,207 @@
     root.appendChild(footer);
     return root;
   }
-  function verifyOfflineStatus(entityObject, delayTimeInMins = 15) {
+  function buildDebugTooltipInfo(entityObject, statusInfo, stateClass, statusDecisionSource, delayTimeConnectionInMins) {
+    const formatTimestamp = (ts) => {
+      if (!ts) return "N/A";
+      const d = new Date(ts);
+      return d.toLocaleString("pt-BR", {
+        day: "2-digit",
+        month: "2-digit",
+        year: "numeric",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+      });
+    };
+    return {
+      // Entity identification
+      entityId: entityObject.entityId || "N/A",
+      name: entityObject.name || entityObject.nameEl || "N/A",
+      domain: entityObject.domain || "energy",
+      // Status decision chain
+      originalDeviceStatus: entityObject._originalDeviceStatus || entityObject.deviceStatus,
+      finalDeviceStatus: entityObject.deviceStatus,
+      connectionStatus: entityObject.connectionStatus || "N/A",
+      statusDecisionSource,
+      // Visual output
+      stateClass,
+      chipClass: statusInfo.chipClass,
+      chipLabel: statusInfo.label,
+      // Connection timestamps
+      lastConnectTime: formatTimestamp(entityObject.lastConnectTime),
+      lastDisconnectTime: formatTimestamp(entityObject.lastDisconnectTime),
+      delayTimeConnectionInMins,
+      // Raw values
+      val: entityObject.val,
+      consumptionTargetValue: entityObject.consumptionTargetValue,
+      deviceType: entityObject.deviceType || "N/A"
+    };
+  }
+  function attachDebugTooltip(element, debugInfo) {
+    const existingTooltip = element.querySelector(".debug-tooltip-container");
+    if (existingTooltip) {
+      existingTooltip.remove();
+    }
+    const tooltipContainer = document.createElement("div");
+    tooltipContainer.className = "debug-tooltip-container";
+    const tooltip = document.createElement("div");
+    tooltip.className = "debug-tooltip";
+    tooltip.innerHTML = `
+    <div class="debug-tooltip__header">
+      <span class="debug-tooltip__icon">\u{1F50D}</span>
+      <span class="debug-tooltip__title">Debug Info</span>
+    </div>
+    <div class="debug-tooltip__content">
+      <div class="debug-tooltip__section">
+        <div class="debug-tooltip__section-title">\u{1F4CB} Identifica\xE7\xE3o</div>
+        <div class="debug-tooltip__row">
+          <span class="debug-tooltip__label">Entity ID:</span>
+          <span class="debug-tooltip__value debug-tooltip__value--mono">${debugInfo.entityId}</span>
+        </div>
+        <div class="debug-tooltip__row">
+          <span class="debug-tooltip__label">Nome:</span>
+          <span class="debug-tooltip__value">${debugInfo.name}</span>
+        </div>
+        <div class="debug-tooltip__row">
+          <span class="debug-tooltip__label">Dom\xEDnio:</span>
+          <span class="debug-tooltip__value debug-tooltip__badge debug-tooltip__badge--${debugInfo.domain}">${debugInfo.domain}</span>
+        </div>
+      </div>
+
+      <div class="debug-tooltip__section">
+        <div class="debug-tooltip__section-title">\u26A1 Decis\xE3o de Status</div>
+        <div class="debug-tooltip__row">
+          <span class="debug-tooltip__label">connectionStatus:</span>
+          <span class="debug-tooltip__value debug-tooltip__value--mono">${debugInfo.connectionStatus}</span>
+        </div>
+        <div class="debug-tooltip__row">
+          <span class="debug-tooltip__label">deviceStatus (final):</span>
+          <span class="debug-tooltip__value debug-tooltip__badge">${debugInfo.finalDeviceStatus}</span>
+        </div>
+        <div class="debug-tooltip__row debug-tooltip__row--full">
+          <span class="debug-tooltip__label">Fonte da decis\xE3o:</span>
+          <span class="debug-tooltip__value debug-tooltip__value--highlight">${debugInfo.statusDecisionSource}</span>
+        </div>
+      </div>
+
+      <div class="debug-tooltip__section">
+        <div class="debug-tooltip__section-title">\u{1F3A8} Output Visual</div>
+        <div class="debug-tooltip__row">
+          <span class="debug-tooltip__label">stateClass:</span>
+          <span class="debug-tooltip__value debug-tooltip__value--mono">${debugInfo.stateClass}</span>
+        </div>
+        <div class="debug-tooltip__row">
+          <span class="debug-tooltip__label">chipClass:</span>
+          <span class="debug-tooltip__value debug-tooltip__value--mono">${debugInfo.chipClass}</span>
+        </div>
+        <div class="debug-tooltip__row">
+          <span class="debug-tooltip__label">chipLabel:</span>
+          <span class="debug-tooltip__value">${debugInfo.chipLabel}</span>
+        </div>
+      </div>
+
+      <div class="debug-tooltip__section">
+        <div class="debug-tooltip__section-title">\u{1F550} Timestamps de Conex\xE3o</div>
+        <div class="debug-tooltip__row">
+          <span class="debug-tooltip__label">lastConnectTime:</span>
+          <span class="debug-tooltip__value debug-tooltip__value--mono">${debugInfo.lastConnectTime}</span>
+        </div>
+        <div class="debug-tooltip__row">
+          <span class="debug-tooltip__label">lastDisconnectTime:</span>
+          <span class="debug-tooltip__value debug-tooltip__value--mono">${debugInfo.lastDisconnectTime}</span>
+        </div>
+        <div class="debug-tooltip__row">
+          <span class="debug-tooltip__label">delayTime:</span>
+          <span class="debug-tooltip__value">${debugInfo.delayTimeConnectionInMins} mins</span>
+        </div>
+      </div>
+
+      <div class="debug-tooltip__section">
+        <div class="debug-tooltip__section-title">\u{1F4CA} Valores</div>
+        <div class="debug-tooltip__row">
+          <span class="debug-tooltip__label">val (consumo):</span>
+          <span class="debug-tooltip__value">${debugInfo.val ?? "N/A"}</span>
+        </div>
+        <div class="debug-tooltip__row">
+          <span class="debug-tooltip__label">target (meta):</span>
+          <span class="debug-tooltip__value">${debugInfo.consumptionTargetValue ?? "N/A"}</span>
+        </div>
+        <div class="debug-tooltip__row">
+          <span class="debug-tooltip__label">deviceType:</span>
+          <span class="debug-tooltip__value debug-tooltip__value--mono">${debugInfo.deviceType}</span>
+        </div>
+      </div>
+    </div>
+  `;
+    tooltipContainer.appendChild(tooltip);
+    element.style.position = "relative";
+    element.style.cursor = "help";
+    element.appendChild(tooltipContainer);
+    element.classList.add("has-debug-tooltip");
+  }
+  function verifyOfflineStatus(entityObject, delayTimeInMins = 15, LogHelper2) {
     const lastConnectionTime = new Date(entityObject.lastConnectTime || 0);
     const lastDisconnectTime = new Date(entityObject.lastDisconnectTime || 0);
     const now = /* @__PURE__ */ new Date();
     const delayTimeInMs = delayTimeInMins * 60 * 1e3;
     const timeSinceConnection = now.getTime() - lastConnectionTime.getTime();
+    let isOffline = false;
     if (lastDisconnectTime.getTime() > lastConnectionTime.getTime()) {
-      return false;
-    }
-    if (timeSinceConnection < delayTimeInMs) {
-      return false;
+      isOffline = true;
+      LogHelper2.log(
+        "[CardHeadOffice][ConnectionStatus Verify] Device is OFFLINE because lastDisconnectTime is more recent than lastConnectTime",
+        entityObject.nameEl
+      );
+    } else if (timeSinceConnection > delayTimeInMs) {
+      isOffline = true;
+      LogHelper2.log(
+        "[CardHeadOffice][ConnectionStatus Verify] Device is OFFLINE because lastConnectTime is older than configured delayTimeConnectionInMins:",
+        delayTimeInMins,
+        "for device",
+        entityObject.nameEl
+      );
+    } else {
+      isOffline = false;
+      LogHelper2.log(
+        "[CardHeadOffice][ConnectionStatus Verify] Device is ONLINE because lastConnectTime is within configured delayTimeConnectionInMins:",
+        delayTimeInMins,
+        "for device",
+        entityObject.nameEl
+      );
     }
-    return true;
+    return isOffline;
   }
   function paint(root, state) {
-    const { entityObject, i18n, delayTimeConnectionInMins, isSelected } = state;
+    const { entityObject, i18n, delayTimeConnectionInMins, isSelected, LogHelper: LogHelper2, activeTooltipDebug } = state;
+    let statusDecisionSource = "unknown";
     if (entityObject.connectionStatus) {
       if (entityObject.connectionStatus === "offline") {
-        entityObject.deviceStatus = DeviceStatusType.NO_INFO;
+        LogHelper2.log(
+          "[CardHeadOffice][ConnectionStatus Verify 01] Setting deviceStatus to OFFLINE based on connectionStatus"
+        );
+        entityObject.deviceStatus = DeviceStatusType.OFFLINE;
+        statusDecisionSource = 'connectionStatus === "offline"';
+      } else {
+        LogHelper2.log(
+          "[CardHeadOffice] Device is ONLINE or WAITING based on connectionStatus for device",
+          entityObject.nameEl
+        );
+        statusDecisionSource = `connectionStatus === "${entityObject.connectionStatus}" (kept original deviceStatus)`;
       }
     } else {
-      if (verifyOfflineStatus(entityObject, delayTimeConnectionInMins) === false) {
-        entityObject.deviceStatus = DeviceStatusType.NO_INFO;
+      if (verifyOfflineStatus(entityObject, delayTimeConnectionInMins, LogHelper2) === false) {
+        LogHelper2.log(
+          "[CardHeadOffice][ConnectionStatus Verify 02] Setting deviceStatus to OFFLINE based on timestamp verification by verifyOfflineStatus METHOD with delayTimeConnectionInMins:",
+          delayTimeConnectionInMins
+        );
+        entityObject.deviceStatus = DeviceStatusType.OFFLINE;
+        statusDecisionSource = `verifyOfflineStatus() returned false (delay: ${delayTimeConnectionInMins} mins)`;
+      } else {
+        LogHelper2.log(
+          `[CardHeadOffice][ConnectionStatus Verify 03] Device is ONLINE with deviceStatus = ${entityObject.deviceStatus} based on timestamp verification for device ${entityObject.nameEl}`
+        );
+        statusDecisionSource = `verifyOfflineStatus() returned true (delay: ${delayTimeConnectionInMins} mins)`;
       }
     }
     const stateClass = getCardStateClass(entityObject.deviceStatus);
@@ -5164,6 +5938,10 @@
     const chip = root.querySelector(".chip");
     chip.className = `chip ${statusInfo.chipClass}`;
     chip.innerHTML = statusInfo.label;
+    if (activeTooltipDebug) {
+      const debugInfo = buildDebugTooltipInfo(entityObject, statusInfo, stateClass, statusDecisionSource, delayTimeConnectionInMins);
+      attachDebugTooltip(chip, debugInfo);
+    }
     const primaryValue = formatValueByDomain(entityObject.val, entityObject.domain);
     const numSpan = root.querySelector(".myio-ho-card__value .num");
     root.querySelector(".myio-ho-card__value .unit");
@@ -5376,6 +6154,7 @@
   }
 
   // src/thingsboard/main-dashboard-shopping/v-5.2.0/card/template-card-v5.js
+  var LABEL_CHAR_LIMIT2 = 18;
   function renderCardComponentV5({
     entityObject,
     handleActionDashboard,
@@ -5892,7 +6671,7 @@ ${rangeText}`;
 
               <div class="device-title-row" style="flex-direction: column; min-height: 38px; text-align: center; width: 100%;">
                 <span class="device-title" title="${cardEntity.name}">
-                  ${cardEntity.name.length > 18 ? cardEntity.name.slice(0, 18) + "\u2026" : cardEntity.name}
+                  ${cardEntity.name.length > LABEL_CHAR_LIMIT2 ? cardEntity.name.slice(0, LABEL_CHAR_LIMIT2) + "\u2026" : cardEntity.name}
                 </span>
                 ${deviceIdentifier ? `
                   <span class="device-subtitle" title="${deviceIdentifier}">
@@ -15658,23 +16437,1019 @@ ${rangeText}`;
       if (isNaN(level) || level < 0 || level > 100) {
         errors.push("currentLevel must be a number between 0 and 100");
       }
-    }
-    if (options.limit !== void 0) {
-      const limit = Number(options.limit);
-      if (isNaN(limit) || limit < 1 || limit > 1e4) {
-        errors.push("limit must be a number between 1 and 10000");
+    }
+    if (options.limit !== void 0) {
+      const limit = Number(options.limit);
+      if (isNaN(limit) || limit < 1 || limit > 1e4) {
+        errors.push("limit must be a number between 1 and 10000");
+      }
+    }
+    if (options.aggregation !== void 0) {
+      const validAggregations = ["NONE", "MIN", "MAX", "AVG", "SUM", "COUNT"];
+      if (!validAggregations.includes(options.aggregation)) {
+        errors.push(`aggregation must be one of: ${validAggregations.join(", ")}`);
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(`Validation failed:
+- ${errors.join("\n- ")}`);
+    }
+  }
+
+  // src/components/premium-modals/power-limits/types.ts
+  var DEVICE_TYPES = [
+    { value: "ELEVADOR", label: "Elevator" },
+    { value: "ESCADA_ROLANTE", label: "Escalator" },
+    { value: "MOTOR", label: "Motor" },
+    { value: "BOMBA", label: "Pump" },
+    { value: "CHILLER", label: "Chiller" },
+    { value: "AR_CONDICIONADO", label: "Air Conditioner" },
+    { value: "HVAC", label: "HVAC" },
+    { value: "FANCOIL", label: "Fancoil" },
+    { value: "3F_MEDIDOR", label: "Three-phase Meter" }
+  ];
+  var TELEMETRY_TYPES2 = [
+    { value: "consumption", label: "Consumption (kW)", unit: "kW" },
+    { value: "voltage_a", label: "Voltage A (V)", unit: "V" },
+    { value: "voltage_b", label: "Voltage B (V)", unit: "V" },
+    { value: "voltage_c", label: "Voltage C (V)", unit: "V" },
+    { value: "current_a", label: "Current A (A)", unit: "A" },
+    { value: "current_b", label: "Current B (A)", unit: "A" },
+    { value: "current_c", label: "Current C (A)", unit: "A" },
+    { value: "total_current", label: "Total Current (A)", unit: "A" },
+    { value: "fp_a", label: "Power Factor A", unit: "" },
+    { value: "fp_b", label: "Power Factor B", unit: "" },
+    { value: "fp_c", label: "Power Factor C", unit: "" }
+  ];
+  var STATUS_CONFIG = {
+    standBy: { label: "StandBy", color: "#22c55e", bgColor: "rgba(34, 197, 94, 0.1)" },
+    normal: { label: "Normal", color: "#3b82f6", bgColor: "rgba(59, 130, 246, 0.1)" },
+    alert: { label: "Alert", color: "#f59e0b", bgColor: "rgba(245, 158, 11, 0.1)" },
+    failure: { label: "Failure", color: "#ef4444", bgColor: "rgba(239, 68, 68, 0.1)" }
+  };
+
+  // src/components/premium-modals/power-limits/PowerLimitsModalView.ts
+  var PowerLimitsModalView = class {
+    container = null;
+    overlayEl = null;
+    config;
+    formData;
+    isLoading = false;
+    isSaving = false;
+    constructor(config) {
+      this.config = config;
+      this.formData = {
+        deviceType: config.deviceType,
+        telemetryType: config.telemetryType,
+        standby: { baseValue: null, topValue: null },
+        normal: { baseValue: null, topValue: null },
+        alert: { baseValue: null, topValue: null },
+        failure: { baseValue: null, topValue: null }
+      };
+    }
+    render(targetContainer) {
+      this.overlayEl = document.createElement("div");
+      this.overlayEl.className = "myio-power-limits-overlay";
+      this.overlayEl.innerHTML = `
+      <style>${this.getStyles()}</style>
+      <div class="myio-power-limits-card">
+        ${this.renderHeader()}
+        ${this.renderSelectors()}
+        ${this.renderStatusCards()}
+        ${this.renderLoadingState()}
+        ${this.renderErrorState()}
+        ${this.renderSuccessState()}
+      </div>
+    `;
+      const target = targetContainer || document.body;
+      target.appendChild(this.overlayEl);
+      this.container = this.overlayEl.querySelector(".myio-power-limits-card");
+      this.setupEventListeners();
+      requestAnimationFrame(() => {
+        this.overlayEl?.classList.add("active");
+      });
+      return this.overlayEl;
+    }
+    renderHeader() {
+      return `
+      <div class="myio-power-limits-header">
+        <div class="myio-power-limits-title-section">
+          <span class="myio-power-limits-icon">&#x2699;</span>
+          <h2 class="myio-power-limits-title">Power Limits Setup</h2>
+        </div>
+        <div class="myio-power-limits-actions">
+          <button class="myio-btn myio-btn-primary" id="plm-save-btn" type="button">
+            <span class="myio-btn-text">Save</span>
+            <span class="myio-btn-spinner" style="display: none;"></span>
+          </button>
+          <button class="myio-btn myio-btn-secondary" id="plm-reset-btn" type="button">Reset</button>
+          <button class="myio-btn myio-btn-close" id="plm-close-btn" type="button" aria-label="Close">&times;</button>
+        </div>
+      </div>
+    `;
+    }
+    renderSelectors() {
+      const deviceOptions = DEVICE_TYPES.map(
+        (dt) => `<option value="${dt.value}" ${dt.value === this.config.deviceType ? "selected" : ""}>${dt.label}</option>`
+      ).join("");
+      const telemetryOptions = TELEMETRY_TYPES2.map(
+        (tt) => `<option value="${tt.value}" ${tt.value === this.config.telemetryType ? "selected" : ""}>${tt.label}</option>`
+      ).join("");
+      return `
+      <div class="myio-power-limits-selectors">
+        <div class="myio-form-group">
+          <label for="plm-device-type">Device Type</label>
+          <select id="plm-device-type" class="myio-select">
+            ${deviceOptions}
+          </select>
+        </div>
+        <div class="myio-form-group">
+          <label for="plm-telemetry-type">Telemetry Type</label>
+          <select id="plm-telemetry-type" class="myio-select">
+            ${telemetryOptions}
+          </select>
+        </div>
+      </div>
+    `;
+    }
+    renderStatusCards() {
+      const statuses = ["standby", "normal", "alert", "failure"];
+      const cards = statuses.map((status) => {
+        const config = STATUS_CONFIG[status === "standby" ? "standBy" : status];
+        const formValues = this.formData[status];
+        return `
+        <div class="myio-power-limits-card-item myio-status-${status}" style="--status-color: ${config.color}; --status-bg: ${config.bgColor};">
+          <div class="myio-card-header">
+            <span class="myio-status-indicator"></span>
+            <span class="myio-status-label">${config.label}</span>
+          </div>
+          <div class="myio-card-inputs">
+            <div class="myio-input-group">
+              <label for="plm-${status}-base">Base Value</label>
+              <input
+                type="number"
+                id="plm-${status}-base"
+                class="myio-input"
+                min="0"
+                step="0.01"
+                value="${formValues.baseValue ?? ""}"
+                placeholder="0"
+              >
+            </div>
+            <div class="myio-input-group">
+              <label for="plm-${status}-top">Top Value</label>
+              <input
+                type="number"
+                id="plm-${status}-top"
+                class="myio-input"
+                min="0"
+                step="0.01"
+                value="${formValues.topValue ?? ""}"
+                placeholder="0"
+              >
+            </div>
+          </div>
+        </div>
+      `;
+      }).join("");
+      return `
+      <div class="myio-power-limits-grid" id="plm-grid">
+        ${cards}
+      </div>
+    `;
+    }
+    renderLoadingState() {
+      return `
+      <div class="myio-power-limits-loading" id="plm-loading" style="display: none;">
+        <div class="myio-spinner"></div>
+        <span>Loading configuration...</span>
+      </div>
+    `;
+    }
+    renderErrorState() {
+      return `
+      <div class="myio-power-limits-error" id="plm-error" style="display: none;">
+        <span class="myio-error-icon">&#x26A0;</span>
+        <span class="myio-error-message" id="plm-error-msg"></span>
+      </div>
+    `;
+    }
+    renderSuccessState() {
+      return `
+      <div class="myio-power-limits-success" id="plm-success" style="display: none;">
+        <span class="myio-success-icon">&#x2713;</span>
+        <span class="myio-success-message">Configuration saved successfully!</span>
+      </div>
+    `;
+    }
+    setupEventListeners() {
+      if (!this.overlayEl) return;
+      const closeBtn = this.overlayEl.querySelector("#plm-close-btn");
+      closeBtn?.addEventListener("click", () => this.close());
+      this.overlayEl.addEventListener("click", (e) => {
+        if (e.target === this.overlayEl) {
+          this.close();
+        }
+      });
+      document.addEventListener("keydown", this.handleKeyDown);
+      const saveBtn = this.overlayEl.querySelector("#plm-save-btn");
+      saveBtn?.addEventListener("click", () => this.handleSave());
+      const resetBtn = this.overlayEl.querySelector("#plm-reset-btn");
+      resetBtn?.addEventListener("click", () => this.handleReset());
+      const deviceSelect = this.overlayEl.querySelector("#plm-device-type");
+      deviceSelect?.addEventListener("change", (e) => {
+        const value = e.target.value;
+        this.formData.deviceType = value;
+        this.config.onDeviceTypeChange(value);
+      });
+      const telemetrySelect = this.overlayEl.querySelector("#plm-telemetry-type");
+      telemetrySelect?.addEventListener("change", (e) => {
+        const value = e.target.value;
+        this.formData.telemetryType = value;
+        this.config.onTelemetryTypeChange(value);
+      });
+      const statuses = ["standby", "normal", "alert", "failure"];
+      statuses.forEach((status) => {
+        const baseInput = this.overlayEl?.querySelector(`#plm-${status}-base`);
+        const topInput = this.overlayEl?.querySelector(`#plm-${status}-top`);
+        baseInput?.addEventListener("input", (e) => {
+          const value = e.target.value;
+          this.formData[status].baseValue = value ? parseFloat(value) : null;
+        });
+        topInput?.addEventListener("input", (e) => {
+          const value = e.target.value;
+          this.formData[status].topValue = value ? parseFloat(value) : null;
+        });
+      });
+    }
+    handleKeyDown = (e) => {
+      if (e.key === "Escape") {
+        this.close();
+      }
+    };
+    async handleSave() {
+      if (this.isSaving) return;
+      const validationError = this.validateForm();
+      if (validationError) {
+        this.showError(validationError);
+        return;
+      }
+      this.isSaving = true;
+      this.showSaveLoading(true);
+      this.hideError();
+      this.hideSuccess();
+      try {
+        await this.config.onSave();
+        this.showSuccess();
+        setTimeout(() => this.hideSuccess(), 3e3);
+      } catch (error) {
+        this.showError(error.message || "Failed to save configuration");
+      } finally {
+        this.isSaving = false;
+        this.showSaveLoading(false);
+      }
+    }
+    handleReset() {
+      const statuses = ["standby", "normal", "alert", "failure"];
+      statuses.forEach((status) => {
+        const baseInput = this.overlayEl?.querySelector(`#plm-${status}-base`);
+        const topInput = this.overlayEl?.querySelector(`#plm-${status}-top`);
+        if (baseInput) baseInput.value = "";
+        if (topInput) topInput.value = "";
+        this.formData[status] = { baseValue: null, topValue: null };
+      });
+      this.hideError();
+      this.hideSuccess();
+    }
+    validateForm() {
+      const statuses = ["standby", "normal", "alert", "failure"];
+      for (const status of statuses) {
+        const base = this.formData[status].baseValue;
+        const top = this.formData[status].topValue;
+        if (base !== null && base < 0) {
+          return `${STATUS_CONFIG[status === "standby" ? "standBy" : status].label}: Base value cannot be negative`;
+        }
+        if (top !== null && top < 0) {
+          return `${STATUS_CONFIG[status === "standby" ? "standBy" : status].label}: Top value cannot be negative`;
+        }
+        if (base !== null && top !== null && base > top) {
+          return `${STATUS_CONFIG[status === "standby" ? "standBy" : status].label}: Base value should not exceed top value`;
+        }
+      }
+      return null;
+    }
+    close() {
+      document.removeEventListener("keydown", this.handleKeyDown);
+      if (this.overlayEl) {
+        this.overlayEl.classList.remove("active");
+        setTimeout(() => {
+          this.overlayEl?.remove();
+          this.overlayEl = null;
+          this.container = null;
+          this.config.onClose();
+        }, 300);
+      }
+    }
+    destroy() {
+      document.removeEventListener("keydown", this.handleKeyDown);
+      this.overlayEl?.remove();
+      this.overlayEl = null;
+      this.container = null;
+    }
+    showLoading() {
+      this.isLoading = true;
+      const loadingEl = this.overlayEl?.querySelector("#plm-loading");
+      const gridEl = this.overlayEl?.querySelector("#plm-grid");
+      if (loadingEl) loadingEl.style.display = "flex";
+      if (gridEl) gridEl.style.opacity = "0.5";
+    }
+    hideLoading() {
+      this.isLoading = false;
+      const loadingEl = this.overlayEl?.querySelector("#plm-loading");
+      const gridEl = this.overlayEl?.querySelector("#plm-grid");
+      if (loadingEl) loadingEl.style.display = "none";
+      if (gridEl) gridEl.style.opacity = "1";
+    }
+    showSaveLoading(show) {
+      const saveBtn = this.overlayEl?.querySelector("#plm-save-btn");
+      const btnText = saveBtn?.querySelector(".myio-btn-text");
+      const btnSpinner = saveBtn?.querySelector(".myio-btn-spinner");
+      if (saveBtn) saveBtn.disabled = show;
+      if (btnText) btnText.style.display = show ? "none" : "inline";
+      if (btnSpinner) btnSpinner.style.display = show ? "inline-block" : "none";
+    }
+    showError(message) {
+      const errorEl = this.overlayEl?.querySelector("#plm-error");
+      const errorMsg = this.overlayEl?.querySelector("#plm-error-msg");
+      if (errorEl) errorEl.style.display = "flex";
+      if (errorMsg) errorMsg.textContent = message;
+    }
+    hideError() {
+      const errorEl = this.overlayEl?.querySelector("#plm-error");
+      if (errorEl) errorEl.style.display = "none";
+    }
+    showSuccess() {
+      const successEl = this.overlayEl?.querySelector("#plm-success");
+      if (successEl) successEl.style.display = "flex";
+    }
+    hideSuccess() {
+      const successEl = this.overlayEl?.querySelector("#plm-success");
+      if (successEl) successEl.style.display = "none";
+    }
+    getFormData() {
+      return { ...this.formData };
+    }
+    setFormData(data) {
+      if (data.deviceType) this.formData.deviceType = data.deviceType;
+      if (data.telemetryType) this.formData.telemetryType = data.telemetryType;
+      if (data.standby) this.formData.standby = { ...data.standby };
+      if (data.normal) this.formData.normal = { ...data.normal };
+      if (data.alert) this.formData.alert = { ...data.alert };
+      if (data.failure) this.formData.failure = { ...data.failure };
+      this.updateInputValues();
+    }
+    updateInputValues() {
+      const statuses = ["standby", "normal", "alert", "failure"];
+      statuses.forEach((status) => {
+        const baseInput = this.overlayEl?.querySelector(`#plm-${status}-base`);
+        const topInput = this.overlayEl?.querySelector(`#plm-${status}-top`);
+        if (baseInput) {
+          baseInput.value = this.formData[status].baseValue?.toString() ?? "";
+        }
+        if (topInput) {
+          topInput.value = this.formData[status].topValue?.toString() ?? "";
+        }
+      });
+      const deviceSelect = this.overlayEl?.querySelector("#plm-device-type");
+      const telemetrySelect = this.overlayEl?.querySelector("#plm-telemetry-type");
+      if (deviceSelect) deviceSelect.value = this.formData.deviceType;
+      if (telemetrySelect) telemetrySelect.value = this.formData.telemetryType;
+    }
+    getStyles() {
+      const styles = this.config.styles || {};
+      const primaryColor = styles.primaryColor || "#4A148C";
+      const successColor = styles.successColor || "#22c55e";
+      styles.warningColor || "#f59e0b";
+      const dangerColor = styles.dangerColor || "#ef4444";
+      styles.infoColor || "#3b82f6";
+      return `
+      .myio-power-limits-overlay {
+        position: fixed;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+        background: rgba(0, 0, 0, 0.6);
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        z-index: ${styles.zIndex || 1e4};
+        opacity: 0;
+        visibility: hidden;
+        transition: all 0.3s ease;
+        font-family: ${styles.fontFamily || '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif'};
+      }
+
+      .myio-power-limits-overlay.active {
+        opacity: 1;
+        visibility: visible;
+      }
+
+      .myio-power-limits-card {
+        background: ${styles.backgroundColor || "#ffffff"};
+        border-radius: ${styles.borderRadius || "12px"};
+        width: 90%;
+        max-width: 700px;
+        max-height: 90vh;
+        overflow-y: auto;
+        transform: scale(0.9);
+        transition: transform 0.3s ease;
+        box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
+      }
+
+      .myio-power-limits-overlay.active .myio-power-limits-card {
+        transform: scale(1);
+      }
+
+      .myio-power-limits-header {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        padding: 20px 24px;
+        background: linear-gradient(135deg, ${primaryColor}, ${this.lightenColor(primaryColor, 20)});
+        color: white;
+        border-radius: 12px 12px 0 0;
+      }
+
+      .myio-power-limits-title-section {
+        display: flex;
+        align-items: center;
+        gap: 12px;
+      }
+
+      .myio-power-limits-icon {
+        font-size: 24px;
+      }
+
+      .myio-power-limits-title {
+        font-size: 1.25rem;
+        font-weight: 600;
+        margin: 0;
+      }
+
+      .myio-power-limits-actions {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+      }
+
+      .myio-btn {
+        padding: 8px 16px;
+        border-radius: ${styles.buttonRadius || "6px"};
+        font-size: 14px;
+        font-weight: 500;
+        cursor: pointer;
+        border: none;
+        transition: all 0.2s;
+        display: inline-flex;
+        align-items: center;
+        gap: 6px;
+      }
+
+      .myio-btn:disabled {
+        opacity: 0.6;
+        cursor: not-allowed;
+      }
+
+      .myio-btn-primary {
+        background: white;
+        color: ${primaryColor};
+      }
+
+      .myio-btn-primary:hover:not(:disabled) {
+        background: #f3f4f6;
+      }
+
+      .myio-btn-secondary {
+        background: rgba(255, 255, 255, 0.2);
+        color: white;
+      }
+
+      .myio-btn-secondary:hover:not(:disabled) {
+        background: rgba(255, 255, 255, 0.3);
+      }
+
+      .myio-btn-close {
+        background: transparent;
+        color: white;
+        font-size: 24px;
+        padding: 4px 8px;
+        line-height: 1;
+      }
+
+      .myio-btn-close:hover {
+        background: rgba(255, 255, 255, 0.1);
+      }
+
+      .myio-btn-spinner {
+        width: 16px;
+        height: 16px;
+        border: 2px solid ${primaryColor};
+        border-top-color: transparent;
+        border-radius: 50%;
+        animation: spin 0.8s linear infinite;
+      }
+
+      @keyframes spin {
+        to { transform: rotate(360deg); }
+      }
+
+      .myio-power-limits-selectors {
+        display: grid;
+        grid-template-columns: 1fr 1fr;
+        gap: 16px;
+        padding: 20px 24px;
+        background: #f9fafb;
+        border-bottom: 1px solid #e5e7eb;
+      }
+
+      .myio-form-group {
+        display: flex;
+        flex-direction: column;
+        gap: 6px;
+      }
+
+      .myio-form-group label {
+        font-size: 13px;
+        font-weight: 500;
+        color: #374151;
+      }
+
+      .myio-select, .myio-input {
+        padding: 10px 12px;
+        border: 1px solid #d1d5db;
+        border-radius: 6px;
+        font-size: 14px;
+        background: white;
+        color: #1f2937;
+        transition: border-color 0.2s, box-shadow 0.2s;
+      }
+
+      .myio-select:focus, .myio-input:focus {
+        outline: none;
+        border-color: ${primaryColor};
+        box-shadow: 0 0 0 3px ${this.hexToRgba(primaryColor, 0.1)};
+      }
+
+      .myio-power-limits-grid {
+        display: grid;
+        grid-template-columns: repeat(2, 1fr);
+        gap: 16px;
+        padding: 24px;
+        transition: opacity 0.3s;
+      }
+
+      .myio-power-limits-card-item {
+        background: var(--status-bg);
+        border: 1px solid var(--status-color);
+        border-radius: 8px;
+        padding: 16px;
+        transition: transform 0.2s, box-shadow 0.2s;
+      }
+
+      .myio-power-limits-card-item:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+      }
+
+      .myio-card-header {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        margin-bottom: 12px;
+      }
+
+      .myio-status-indicator {
+        width: 12px;
+        height: 12px;
+        border-radius: 50%;
+        background: var(--status-color);
+      }
+
+      .myio-status-label {
+        font-weight: 600;
+        font-size: 14px;
+        color: #1f2937;
+      }
+
+      .myio-card-inputs {
+        display: grid;
+        grid-template-columns: 1fr 1fr;
+        gap: 12px;
+      }
+
+      .myio-input-group {
+        display: flex;
+        flex-direction: column;
+        gap: 4px;
+      }
+
+      .myio-input-group label {
+        font-size: 11px;
+        font-weight: 500;
+        color: #6b7280;
+        text-transform: uppercase;
+      }
+
+      .myio-power-limits-loading,
+      .myio-power-limits-error,
+      .myio-power-limits-success {
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        gap: 12px;
+        padding: 16px 24px;
+        margin: 0 24px 24px;
+        border-radius: 8px;
+      }
+
+      .myio-power-limits-loading {
+        background: #f3f4f6;
+        color: #6b7280;
+      }
+
+      .myio-power-limits-error {
+        background: #fef2f2;
+        color: ${dangerColor};
+        border: 1px solid ${dangerColor};
+      }
+
+      .myio-power-limits-success {
+        background: #f0fdf4;
+        color: ${successColor};
+        border: 1px solid ${successColor};
+      }
+
+      .myio-spinner {
+        width: 24px;
+        height: 24px;
+        border: 3px solid #e5e7eb;
+        border-top-color: ${primaryColor};
+        border-radius: 50%;
+        animation: spin 0.8s linear infinite;
+      }
+
+      .myio-error-icon, .myio-success-icon {
+        font-size: 20px;
+      }
+
+      @media (max-width: 600px) {
+        .myio-power-limits-selectors,
+        .myio-power-limits-grid {
+          grid-template-columns: 1fr;
+        }
+
+        .myio-power-limits-header {
+          flex-direction: column;
+          gap: 12px;
+          text-align: center;
+        }
+
+        .myio-power-limits-actions {
+          width: 100%;
+          justify-content: center;
+        }
+      }
+    `;
+    }
+    lightenColor(hex, percent) {
+      const num = parseInt(hex.replace("#", ""), 16);
+      const amt = Math.round(2.55 * percent);
+      const R = (num >> 16) + amt;
+      const G = (num >> 8 & 255) + amt;
+      const B = (num & 255) + amt;
+      return "#" + (16777216 + (R < 255 ? R < 1 ? 0 : R : 255) * 65536 + (G < 255 ? G < 1 ? 0 : G : 255) * 256 + (B < 255 ? B < 1 ? 0 : B : 255)).toString(16).slice(1);
+    }
+    hexToRgba(hex, alpha) {
+      const num = parseInt(hex.replace("#", ""), 16);
+      const R = num >> 16;
+      const G = num >> 8 & 255;
+      const B = num & 255;
+      return `rgba(${R}, ${G}, ${B}, ${alpha})`;
+    }
+  };
+
+  // src/components/premium-modals/power-limits/PowerLimitsPersister.ts
+  var PowerLimitsPersister = class {
+    jwtToken;
+    tbBaseUrl;
+    constructor(jwtToken, tbBaseUrl) {
+      this.jwtToken = jwtToken;
+      this.tbBaseUrl = tbBaseUrl || window.location.origin;
+    }
+    /**
+     * Load existing mapInstantaneousPower from customer server_scope attributes
+     */
+    async loadCustomerPowerLimits(customerId) {
+      try {
+        const url = `${this.tbBaseUrl}/api/plugins/telemetry/CUSTOMER/${customerId}/values/attributes/SERVER_SCOPE?keys=mapInstantaneousPower`;
+        const response = await fetch(url, {
+          method: "GET",
+          headers: {
+            "X-Authorization": `Bearer ${this.jwtToken}`,
+            "Content-Type": "application/json"
+          }
+        });
+        if (!response.ok) {
+          if (response.status === 404) {
+            console.log("[PowerLimitsPersister] No existing mapInstantaneousPower found");
+            return null;
+          }
+          throw this.createHttpError(response.status, await response.text().catch(() => ""));
+        }
+        const data = await response.json();
+        if (!data || data.length === 0) {
+          console.log("[PowerLimitsPersister] No mapInstantaneousPower attribute found");
+          return null;
+        }
+        const attr = data.find((item) => item.key === "mapInstantaneousPower");
+        if (!attr || !attr.value) {
+          return null;
+        }
+        const parsedValue = typeof attr.value === "string" ? JSON.parse(attr.value) : attr.value;
+        console.log("[PowerLimitsPersister] Loaded mapInstantaneousPower:", parsedValue);
+        return parsedValue;
+      } catch (error) {
+        console.error("[PowerLimitsPersister] Error loading power limits:", error);
+        throw this.mapError(error);
+      }
+    }
+    /**
+     * Save mapInstantaneousPower to customer server_scope attributes
+     */
+    async saveCustomerPowerLimits(customerId, limits) {
+      try {
+        const url = `${this.tbBaseUrl}/api/plugins/telemetry/CUSTOMER/${customerId}/attributes/SERVER_SCOPE`;
+        const payload = {
+          mapInstantaneousPower: limits
+        };
+        console.log("[PowerLimitsPersister] Saving power limits:", payload);
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "X-Authorization": `Bearer ${this.jwtToken}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(payload)
+        });
+        if (!response.ok) {
+          throw this.createHttpError(response.status, await response.text().catch(() => ""));
+        }
+        console.log("[PowerLimitsPersister] Successfully saved power limits");
+        return { ok: true };
+      } catch (error) {
+        console.error("[PowerLimitsPersister] Error saving power limits:", error);
+        return { ok: false, error: this.mapError(error) };
+      }
+    }
+    /**
+     * Extract form data for a specific device type and telemetry type
+     */
+    extractFormData(limits, deviceType, telemetryType) {
+      const defaultFormData = {
+        deviceType,
+        telemetryType,
+        standby: { baseValue: null, topValue: null },
+        normal: { baseValue: null, topValue: null },
+        alert: { baseValue: null, topValue: null },
+        failure: { baseValue: null, topValue: null }
+      };
+      if (!limits || !limits.limitsByInstantaneoustPowerType) {
+        return defaultFormData;
+      }
+      const telemetryEntry = limits.limitsByInstantaneoustPowerType.find(
+        (t) => t.telemetryType === telemetryType
+      );
+      if (!telemetryEntry || !telemetryEntry.itemsByDeviceType) {
+        return defaultFormData;
+      }
+      const deviceEntry = telemetryEntry.itemsByDeviceType.find(
+        (d) => d.deviceType === deviceType
+      );
+      if (!deviceEntry || !deviceEntry.limitsByDeviceStatus) {
+        return defaultFormData;
+      }
+      const statusMap = {
+        "standBy": "standby",
+        "normal": "normal",
+        "alert": "alert",
+        "failure": "failure"
+      };
+      deviceEntry.limitsByDeviceStatus.forEach((status) => {
+        const formKey = statusMap[status.deviceStatusName];
+        if (formKey && defaultFormData[formKey]) {
+          defaultFormData[formKey] = {
+            baseValue: status.limitsValues.baseValue,
+            topValue: status.limitsValues.topValue
+          };
+        }
+      });
+      return defaultFormData;
+    }
+    /**
+     * Merge form data into existing limits JSON
+     * Creates new entries if they don't exist
+     */
+    mergeFormDataIntoLimits(existingLimits, formData) {
+      const result = existingLimits ? JSON.parse(JSON.stringify(existingLimits)) : { version: "1.0.0", limitsByInstantaneoustPowerType: [] };
+      const statusLimits = [
+        {
+          deviceStatusName: "standBy",
+          limitsValues: {
+            baseValue: formData.standby.baseValue ?? 0,
+            topValue: formData.standby.topValue ?? 0
+          }
+        },
+        {
+          deviceStatusName: "normal",
+          limitsValues: {
+            baseValue: formData.normal.baseValue ?? 0,
+            topValue: formData.normal.topValue ?? 0
+          }
+        },
+        {
+          deviceStatusName: "alert",
+          limitsValues: {
+            baseValue: formData.alert.baseValue ?? 0,
+            topValue: formData.alert.topValue ?? 0
+          }
+        },
+        {
+          deviceStatusName: "failure",
+          limitsValues: {
+            baseValue: formData.failure.baseValue ?? 0,
+            topValue: formData.failure.topValue ?? 0
+          }
+        }
+      ];
+      let telemetryEntry = result.limitsByInstantaneoustPowerType.find(
+        (t) => t.telemetryType === formData.telemetryType
+      );
+      if (!telemetryEntry) {
+        telemetryEntry = {
+          telemetryType: formData.telemetryType,
+          itemsByDeviceType: []
+        };
+        result.limitsByInstantaneoustPowerType.push(telemetryEntry);
+      }
+      let deviceEntry = telemetryEntry.itemsByDeviceType.find(
+        (d) => d.deviceType === formData.deviceType
+      );
+      if (!deviceEntry) {
+        deviceEntry = {
+          deviceType: formData.deviceType,
+          name: `mapInstantaneousPower${this.formatDeviceTypeName(formData.deviceType)}`,
+          description: `Power limits for ${formData.deviceType}`,
+          limitsByDeviceStatus: []
+        };
+        telemetryEntry.itemsByDeviceType.push(deviceEntry);
+      }
+      deviceEntry.limitsByDeviceStatus = statusLimits;
+      deviceEntry.name = `mapInstantaneousPower${this.formatDeviceTypeName(formData.deviceType)}`;
+      deviceEntry.description = `Power limits for ${formData.deviceType} - ${formData.telemetryType}`;
+      return result;
+    }
+    /**
+     * Format device type name for the JSON name field
+     */
+    formatDeviceTypeName(deviceType) {
+      if (!deviceType) return "";
+      return deviceType.toLowerCase().split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+    }
+    createHttpError(status, body) {
+      const error = new Error(`HTTP ${status}: ${body}`);
+      error.status = status;
+      error.body = body;
+      return error;
+    }
+    mapError(error) {
+      const status = error.status;
+      if (status === 400) {
+        return {
+          code: "VALIDATION_ERROR",
+          message: "Invalid input data",
+          cause: error
+        };
+      }
+      if (status === 401) {
+        return {
+          code: "TOKEN_EXPIRED",
+          message: "Authentication token has expired",
+          cause: error
+        };
+      }
+      if (status === 403) {
+        return {
+          code: "AUTH_ERROR",
+          message: "Insufficient permissions",
+          cause: error
+        };
+      }
+      if (status === 404) {
+        return {
+          code: "NETWORK_ERROR",
+          message: "Customer not found",
+          cause: error
+        };
+      }
+      if (status >= 500) {
+        return {
+          code: "NETWORK_ERROR",
+          message: "Server error occurred",
+          cause: error
+        };
       }
+      return {
+        code: "UNKNOWN_ERROR",
+        message: error.message || "Unknown error occurred",
+        cause: error
+      };
     }
-    if (options.aggregation !== void 0) {
-      const validAggregations = ["NONE", "MIN", "MAX", "AVG", "SUM", "COUNT"];
-      if (!validAggregations.includes(options.aggregation)) {
-        errors.push(`aggregation must be one of: ${validAggregations.join(", ")}`);
+  };
+
+  // src/components/premium-modals/power-limits/openPowerLimitsSetupModal.ts
+  async function openPowerLimitsSetupModal(params) {
+    if (!params.token) {
+      throw new Error("[PowerLimitsSetupModal] token is required");
+    }
+    if (!params.customerId) {
+      throw new Error("[PowerLimitsSetupModal] customerId is required");
+    }
+    const persister = new PowerLimitsPersister(params.token, params.tbBaseUrl);
+    let currentDeviceType = params.deviceType || "ELEVADOR";
+    let currentTelemetryType = params.telemetryType || "consumption";
+    let existingLimits = params.existingMapPower || null;
+    const view = new PowerLimitsModalView({
+      deviceType: currentDeviceType,
+      telemetryType: currentTelemetryType,
+      styles: params.styles,
+      locale: params.locale,
+      onDeviceTypeChange: async (deviceType) => {
+        currentDeviceType = deviceType;
+        await loadFormData();
+      },
+      onTelemetryTypeChange: async (telemetryType) => {
+        currentTelemetryType = telemetryType;
+        await loadFormData();
+      },
+      onSave: async () => {
+        const formData = view.getFormData();
+        const updatedLimits = persister.mergeFormDataIntoLimits(existingLimits, formData);
+        const result = await persister.saveCustomerPowerLimits(params.customerId, updatedLimits);
+        if (!result.ok) {
+          throw new Error(result.error?.message || "Failed to save configuration");
+        }
+        existingLimits = updatedLimits;
+        if (params.onSave) {
+          params.onSave(updatedLimits);
+        }
+      },
+      onClose: () => {
+        if (params.onClose) {
+          params.onClose();
+        }
+      }
+    });
+    async function loadFormData() {
+      view.showLoading();
+      try {
+        if (!existingLimits) {
+          existingLimits = await persister.loadCustomerPowerLimits(params.customerId);
+        }
+        const formData = persister.extractFormData(existingLimits, currentDeviceType, currentTelemetryType);
+        view.setFormData(formData);
+      } catch (error) {
+        console.error("[PowerLimitsSetupModal] Error loading form data:", error);
+        view.showError(error.message || "Failed to load configuration");
+      } finally {
+        view.hideLoading();
       }
     }
-    if (errors.length > 0) {
-      throw new Error(`Validation failed:
-- ${errors.join("\n- ")}`);
+    let container;
+    if (params.container) {
+      if (typeof params.container === "string") {
+        container = document.querySelector(params.container);
+      } else {
+        container = params.container;
+      }
     }
+    view.render(container);
+    await loadFormData();
+    return {
+      destroy: () => view.destroy(),
+      getFormData: () => view.getFormData(),
+      setFormData: (data) => view.setFormData(data)
+    };
   }
 
   // src/components/premium-modals/settings/SettingsModalView.ts
@@ -20045,220 +21820,6 @@ ${rangeText}`;
     }
   }
 
-  // src/components/temperature/utils.ts
-  var DAY_PERIODS = [
-    { id: "madrugada", label: "Madrugada (00h-06h)", startHour: 0, endHour: 6 },
-    { id: "manha", label: "Manh\xE3 (06h-12h)", startHour: 6, endHour: 12 },
-    { id: "tarde", label: "Tarde (12h-18h)", startHour: 12, endHour: 18 },
-    { id: "noite", label: "Noite (18h-24h)", startHour: 18, endHour: 24 }
-  ];
-  var DEFAULT_CLAMP_RANGE = { min: 15, max: 40 };
-  function getTodaySoFar() {
-    const now = /* @__PURE__ */ new Date();
-    const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0);
-    return {
-      startTs: startOfDay.getTime(),
-      endTs: now.getTime()
-    };
-  }
-  var CHART_COLORS = [
-    "#1976d2",
-    // Blue
-    "#FF6B6B",
-    // Red
-    "#4CAF50",
-    // Green
-    "#FF9800",
-    // Orange
-    "#9C27B0",
-    // Purple
-    "#00BCD4",
-    // Cyan
-    "#E91E63",
-    // Pink
-    "#795548"
-    // Brown
-  ];
-  async function fetchTemperatureData(token, deviceId, startTs, endTs) {
-    const url = `/api/plugins/telemetry/DEVICE/${deviceId}/values/timeseries?keys=temperature&startTs=${encodeURIComponent(startTs)}&endTs=${encodeURIComponent(endTs)}&limit=50000&agg=NONE`;
-    const response = await fetch(url, {
-      headers: {
-        "X-Authorization": `Bearer ${token}`,
-        "Content-Type": "application/json"
-      }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to fetch temperature data: ${response.status}`);
-    }
-    const data = await response.json();
-    return data?.temperature || [];
-  }
-  function clampTemperature(value, range = DEFAULT_CLAMP_RANGE) {
-    const num = Number(value || 0);
-    if (num < range.min) return range.min;
-    if (num > range.max) return range.max;
-    return num;
-  }
-  function calculateStats(data, clampRange = DEFAULT_CLAMP_RANGE) {
-    if (data.length === 0) {
-      return { avg: 0, min: 0, max: 0, count: 0 };
-    }
-    const values = data.map((item) => clampTemperature(item.value, clampRange));
-    const sum = values.reduce((acc, v) => acc + v, 0);
-    return {
-      avg: sum / values.length,
-      min: Math.min(...values),
-      max: Math.max(...values),
-      count: values.length
-    };
-  }
-  function interpolateTemperature(data, options) {
-    const { intervalMinutes, startTs, endTs, clampRange = DEFAULT_CLAMP_RANGE } = options;
-    const intervalMs = intervalMinutes * 60 * 1e3;
-    if (data.length === 0) {
-      return [];
-    }
-    const sortedData = [...data].sort((a, b) => a.ts - b.ts);
-    const result = [];
-    let lastKnownValue = clampTemperature(sortedData[0].value, clampRange);
-    let dataIndex = 0;
-    for (let ts = startTs; ts <= endTs; ts += intervalMs) {
-      while (dataIndex < sortedData.length - 1 && sortedData[dataIndex + 1].ts <= ts) {
-        dataIndex++;
-      }
-      const currentData = sortedData[dataIndex];
-      if (currentData && Math.abs(currentData.ts - ts) < intervalMs) {
-        lastKnownValue = clampTemperature(currentData.value, clampRange);
-      }
-      result.push({
-        ts,
-        value: lastKnownValue
-      });
-    }
-    return result;
-  }
-  function aggregateByDay(data, clampRange = DEFAULT_CLAMP_RANGE) {
-    if (data.length === 0) {
-      return [];
-    }
-    const dayMap = /* @__PURE__ */ new Map();
-    data.forEach((item) => {
-      const date = new Date(item.ts);
-      const dateKey = date.toISOString().split("T")[0];
-      if (!dayMap.has(dateKey)) {
-        dayMap.set(dateKey, []);
-      }
-      dayMap.get(dateKey).push(item);
-    });
-    const result = [];
-    dayMap.forEach((dayData, dateKey) => {
-      const values = dayData.map((item) => clampTemperature(item.value, clampRange));
-      const sum = values.reduce((acc, v) => acc + v, 0);
-      result.push({
-        date: dateKey,
-        dateTs: new Date(dateKey).getTime(),
-        avg: sum / values.length,
-        min: Math.min(...values),
-        max: Math.max(...values),
-        count: values.length
-      });
-    });
-    return result.sort((a, b) => a.dateTs - b.dateTs);
-  }
-  function filterByDayPeriods(data, selectedPeriods) {
-    if (selectedPeriods.length === 0 || selectedPeriods.length === DAY_PERIODS.length) {
-      return data;
-    }
-    return data.filter((item) => {
-      const date = new Date(item.ts);
-      const hour = date.getHours();
-      return selectedPeriods.some((periodId) => {
-        const period = DAY_PERIODS.find((p) => p.id === periodId);
-        if (!period) return false;
-        return hour >= period.startHour && hour < period.endHour;
-      });
-    });
-  }
-  function getSelectedPeriodsLabel(selectedPeriods) {
-    if (selectedPeriods.length === 0 || selectedPeriods.length === DAY_PERIODS.length) {
-      return "Todos os per\xEDodos";
-    }
-    if (selectedPeriods.length === 1) {
-      const period = DAY_PERIODS.find((p) => p.id === selectedPeriods[0]);
-      return period?.label || "";
-    }
-    return `${selectedPeriods.length} per\xEDodos selecionados`;
-  }
-  function formatTemperature2(value, decimals = 1) {
-    return `${value.toFixed(decimals)}\xB0C`;
-  }
-  function exportTemperatureCSV(data, deviceLabel, stats, startDate, endDate) {
-    if (data.length === 0) {
-      console.warn("No data to export");
-      return;
-    }
-    const BOM = "\uFEFF";
-    let csvContent = BOM;
-    csvContent += `Relat\xF3rio de Temperatura - ${deviceLabel}
-`;
-    csvContent += `Per\xEDodo: ${startDate} at\xE9 ${endDate}
-`;
-    csvContent += `M\xE9dia: ${formatTemperature2(stats.avg)}
-`;
-    csvContent += `M\xEDnima: ${formatTemperature2(stats.min)}
-`;
-    csvContent += `M\xE1xima: ${formatTemperature2(stats.max)}
-`;
-    csvContent += `Total de leituras: ${stats.count}
-`;
-    csvContent += "\n";
-    csvContent += "Data/Hora,Temperatura (\xB0C)\n";
-    data.forEach((item) => {
-      const date = new Date(item.ts).toLocaleString("pt-BR");
-      const temp = Number(item.value).toFixed(2);
-      csvContent += `"${date}",${temp}
-`;
-    });
-    const blob = new Blob([csvContent], { type: "text/csv;charset=utf-8;" });
-    const url = URL.createObjectURL(blob);
-    const link = document.createElement("a");
-    link.href = url;
-    link.download = `temperatura_${deviceLabel.replace(/\s+/g, "_")}_${startDate}_${endDate}.csv`;
-    document.body.appendChild(link);
-    link.click();
-    document.body.removeChild(link);
-    URL.revokeObjectURL(url);
-  }
-  var DARK_THEME = {
-    background: "rgba(0, 0, 0, 0.85)",
-    surface: "#1a1f28",
-    text: "#ffffff",
-    textMuted: "rgba(255, 255, 255, 0.7)",
-    border: "rgba(255, 255, 255, 0.1)",
-    primary: "#1976d2",
-    success: "#4CAF50",
-    warning: "#FF9800",
-    danger: "#f44336",
-    chartLine: "#1976d2",
-    chartGrid: "rgba(255, 255, 255, 0.1)"
-  };
-  var LIGHT_THEME = {
-    background: "rgba(0, 0, 0, 0.6)",
-    surface: "#ffffff",
-    text: "#333333",
-    textMuted: "#666666",
-    border: "#e0e0e0",
-    primary: "#1976d2",
-    success: "#4CAF50",
-    warning: "#FF9800",
-    danger: "#f44336",
-    chartLine: "#1976d2",
-    chartGrid: "#e0e0e0"
-  };
-  function getThemeColors(theme) {
-    return theme === "dark" ? DARK_THEME : LIGHT_THEME;
-  }
-
   // src/components/temperature/TemperatureModal.ts
   async function openTemperatureModal(params) {
     const modalId = `myio-temp-modal-${Date.now()}`;
@@ -20498,7 +22059,7 @@ ${rangeText}`;
           ">
             <span style="color: ${colors.textMuted}; font-size: 12px; font-weight: 500;">Temperatura Atual</span>
             <div style="font-weight: 700; font-size: 24px; color: ${statusColor}; margin-top: 4px;">
-              ${state.currentTemperature !== null ? formatTemperature2(state.currentTemperature) : "N/A"}
+              ${state.currentTemperature !== null ? formatTemperature(state.currentTemperature) : "N/A"}
             </div>
             <div style="font-size: 11px; color: ${statusColor}; margin-top: 2px;">${statusText}</div>
           </div>
@@ -20509,7 +22070,7 @@ ${rangeText}`;
           ">
             <span style="color: ${colors.textMuted}; font-size: 12px; font-weight: 500;">M\xE9dia do Per\xEDodo</span>
             <div id="${modalId}-avg" style="font-weight: 600; font-size: 20px; color: ${colors.text}; margin-top: 4px;">
-              ${state.stats.count > 0 ? formatTemperature2(state.stats.avg) : "N/A"}
+              ${state.stats.count > 0 ? formatTemperature(state.stats.avg) : "N/A"}
             </div>
             <div style="font-size: 11px; color: ${colors.textMuted}; margin-top: 2px;">${startDateStr} - ${endDateStr}</div>
           </div>
@@ -20520,7 +22081,7 @@ ${rangeText}`;
           ">
             <span style="color: ${colors.textMuted}; font-size: 12px; font-weight: 500;">Min / Max</span>
             <div id="${modalId}-minmax" style="font-weight: 600; font-size: 20px; color: ${colors.text}; margin-top: 4px;">
-              ${state.stats.count > 0 ? `${formatTemperature2(state.stats.min)} / ${formatTemperature2(state.stats.max)}` : "N/A"}
+              ${state.stats.count > 0 ? `${formatTemperature(state.stats.min)} / ${formatTemperature(state.stats.max)}` : "N/A"}
             </div>
             <div style="font-size: 11px; color: ${colors.textMuted}; margin-top: 2px;">${state.stats.count} leituras</div>
           </div>
@@ -20836,7 +22397,7 @@ ${rangeText}`;
         }
         tooltip.innerHTML = `
         <div style="font-weight: 600; margin-bottom: 6px; color: ${colors.primary};">
-          ${formatTemperature2(point.y)}
+          ${formatTemperature(point.y)}
         </div>
         <div style="font-size: 11px; color: ${colors.textMuted};">
           \u{1F4C5} ${dateStr}
@@ -21099,7 +22660,7 @@ ${rangeText}`;
       <span style="width: 12px; height: 12px; border-radius: 50%; background: ${dd.color};"></span>
       <span style="color: ${colors.text}; font-size: 13px;">${dd.device.label}</span>
       <span style="color: ${colors.textMuted}; font-size: 11px; margin-left: auto;">
-        ${dd.stats.count > 0 ? formatTemperature2(dd.stats.avg) : "N/A"}
+        ${dd.stats.count > 0 ? formatTemperature(dd.stats.avg) : "N/A"}
       </span>
     </div>
   `).join("");
@@ -21115,15 +22676,15 @@ ${rangeText}`;
       <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 4px; font-size: 11px;">
         <span style="color: ${colors.textMuted};">M\xE9dia:</span>
         <span style="color: ${colors.text}; font-weight: 500;">
-          ${dd.stats.count > 0 ? formatTemperature2(dd.stats.avg) : "N/A"}
+          ${dd.stats.count > 0 ? formatTemperature(dd.stats.avg) : "N/A"}
         </span>
         <span style="color: ${colors.textMuted};">Min:</span>
         <span style="color: ${colors.text};">
-          ${dd.stats.count > 0 ? formatTemperature2(dd.stats.min) : "N/A"}
+          ${dd.stats.count > 0 ? formatTemperature(dd.stats.min) : "N/A"}
         </span>
         <span style="color: ${colors.textMuted};">Max:</span>
         <span style="color: ${colors.text};">
-          ${dd.stats.count > 0 ? formatTemperature2(dd.stats.max) : "N/A"}
+          ${dd.stats.count > 0 ? formatTemperature(dd.stats.max) : "N/A"}
         </span>
         <span style="color: ${colors.textMuted};">Leituras:</span>
         <span style="color: ${colors.text};">${dd.stats.count}</span>
@@ -21659,7 +23220,7 @@ ${rangeText}`;
           <span style="font-weight: 600;">${point.deviceLabel}</span>
         </div>
         <div style="font-weight: 600; font-size: 16px; color: ${point.deviceColor}; margin-bottom: 4px;">
-          ${formatTemperature2(point.y)}
+          ${formatTemperature(point.y)}
         </div>
         <div style="font-size: 11px; color: ${colors.textMuted};">
           \u{1F4C5} ${dateStr}
@@ -26151,6 +27712,9 @@ ${rangeText}`;
   exports.MyIODraggableCard = MyIODraggableCard;
   exports.MyIOSelectionStoreClass = MyIOSelectionStoreClass;
   exports.MyIOToast = MyIOToast;
+  exports.POWER_LIMITS_DEVICE_TYPES = DEVICE_TYPES;
+  exports.POWER_LIMITS_STATUS_CONFIG = STATUS_CONFIG;
+  exports.POWER_LIMITS_TELEMETRY_TYPES = TELEMETRY_TYPES2;
   exports.addDetectionContext = addDetectionContext;
   exports.addNamespace = addNamespace;
   exports.aggregateByDay = aggregateByDay;
@@ -26205,7 +27769,7 @@ ${rangeText}`;
   exports.formatNumberReadable = formatNumberReadable;
   exports.formatRelativeTime = formatRelativeTime;
   exports.formatTankHeadFromCm = formatTankHeadFromCm;
-  exports.formatTemperature = formatTemperature2;
+  exports.formatTemperature = formatTemperature;
   exports.formatWater = formatWater;
   exports.formatWaterByGroup = formatWaterByGroup;
   exports.formatWaterVolumeM3 = formatWaterVolumeM3;
@@ -26248,6 +27812,7 @@ ${rangeText}`;
   exports.openDashboardPopupWaterTank = openDashboardPopupWaterTank;
   exports.openDemandModal = openDemandModal;
   exports.openGoalsPanel = openGoalsPanel;
+  exports.openPowerLimitsSetupModal = openPowerLimitsSetupModal;
   exports.openRealTimeTelemetryModal = openRealTimeTelemetryModal;
   exports.openTemperatureComparisonModal = openTemperatureComparisonModal;
   exports.openTemperatureModal = openTemperatureModal;