myio-js-library 0.1.169 → 0.1.173

package/dist/index.js

@@ -1318,7 +1318,8 @@ var DeviceStatusType = {
   FAILURE: "failure",
   MAINTENANCE: "maintenance",
   NO_INFO: "no_info",
-  NOT_INSTALLED: "not_installed"
+  NOT_INSTALLED: "not_installed",
+  OFFLINE: "offline"
 };
 var ConnectionStatusType = {
   CONNECTED: "connected",
@@ -1327,39 +1328,42 @@ var ConnectionStatusType = {
 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;
@@ -1383,15 +1387,16 @@ function mapDeviceStatusToCardStatus(deviceStatus) {
     [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() || "";
@@ -3947,15 +3952,30 @@ var CSS_STRING = `
   --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;
@@ -4011,26 +4031,55 @@ var CSS_STRING = `
 }
 
 /* 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;
@@ -4048,7 +4097,9 @@ var CSS_STRING = `
   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);
 }
 
@@ -4056,14 +4107,28 @@ var CSS_STRING = `
   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);
@@ -4458,6 +4523,37 @@ var CSS_STRING = `
   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;
@@ -4491,6 +4587,31 @@ var CSS_STRING = `
   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;
@@ -4673,6 +4794,215 @@ var CSS_STRING = `
     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
@@ -4827,46 +5157,296 @@ var DEFAULT_I18N = {
   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);
+    }
+  };
+}
+var LogHelper = createLogHelper(false);
+
+// 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;
@@ -4891,16 +5471,10 @@ function formatValueByDomain(value, domain) {
     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);
@@ -4915,32 +5489,32 @@ function getStatusInfo(deviceStatus, i18n, domain) {
     // --- 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 };
   }
@@ -4948,23 +5522,32 @@ function getStatusInfo(deviceStatus, i18n, domain) {
 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 "";
   }
@@ -4978,17 +5561,25 @@ function getStatusDotClass(deviceStatus) {
       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";
   }
@@ -5012,7 +5603,13 @@ function buildDOM(state) {
   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");
@@ -5141,29 +5738,207 @@ function buildDOM(state) {
   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);
@@ -5172,6 +5947,10 @@ function paint(root, state) {
   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");
   const unitSpan = root.querySelector(".myio-ho-card__value .unit");
@@ -5384,6 +6163,7 @@ function renderCardComponentHeadOffice(containerEl, params) {
 }
 
 // src/thingsboard/main-dashboard-shopping/v-5.2.0/card/template-card-v5.js
+var LABEL_CHAR_LIMIT2 = 18;
 function renderCardComponentV5({
   entityObject,
   handleActionDashboard,
@@ -5900,7 +6680,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}">
@@ -15840,23 +16620,1019 @@ function validateOptions2(options) {
     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";
+    const warningColor = styles.warningColor || "#f59e0b";
+    const dangerColor = styles.dangerColor || "#ef4444";
+    const infoColor = 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
@@ -20227,220 +22003,6 @@ function openGoalsPanel(params) {
   }
 }
 
-// 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()}`;
@@ -20680,7 +22242,7 @@ function renderModal(container, state, modalId, error) {
           ">
             <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>
@@ -20691,7 +22253,7 @@ function renderModal(container, state, modalId, error) {
           ">
             <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>
@@ -20702,7 +22264,7 @@ function renderModal(container, state, modalId, error) {
           ">
             <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>
@@ -21018,7 +22580,7 @@ function setupChartTooltip(canvas, container, chartData, state, colors) {
       }
       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}
@@ -21281,7 +22843,7 @@ function renderModal2(container, state, modalId) {
       <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("");
@@ -21297,15 +22859,15 @@ function renderModal2(container, state, modalId) {
       <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>
@@ -21841,7 +23403,7 @@ function setupComparisonChartTooltip(canvas, container, chartData, state, colors
           <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}
@@ -26339,6 +27901,9 @@ export {
   MyIOSelectionStore,
   MyIOSelectionStoreClass,
   MyIOToast,
+  DEVICE_TYPES as POWER_LIMITS_DEVICE_TYPES,
+  STATUS_CONFIG as POWER_LIMITS_STATUS_CONFIG,
+  TELEMETRY_TYPES2 as POWER_LIMITS_TELEMETRY_TYPES,
   addDetectionContext,
   addNamespace,
   aggregateByDay,
@@ -26393,7 +27958,7 @@ export {
   formatNumberReadable,
   formatRelativeTime,
   formatTankHeadFromCm,
-  formatTemperature2 as formatTemperature,
+  formatTemperature,
   formatWater,
   formatWaterByGroup,
   formatWaterVolumeM3,
@@ -26436,6 +28001,7 @@ export {
   openDashboardPopupWaterTank,
   openDemandModal,
   openGoalsPanel,
+  openPowerLimitsSetupModal,
   openRealTimeTelemetryModal,
   openTemperatureComparisonModal,
   openTemperatureModal,