myio-js-library 0.1.161 → 0.1.162

package/dist/index.js

@@ -644,6 +644,10 @@ function formatNumberReadable(value, locale = "pt-BR", minimumFractionDigits = 2
 }
 
 // src/format/water.ts
+function formatWater(value) {
+  const num = Number(value) || 0;
+  return `${num.toFixed(2)} m\xB3`;
+}
 function formatWaterVolumeM3(value, locale = "pt-BR") {
   if (value === null || value === void 0 || isNaN(value)) {
     return "-";
@@ -721,6 +725,76 @@ function formatAllInSameWaterUnit(values) {
   };
 }
 
+// src/format/time.ts
+function formatRelativeTime(timestamp) {
+  if (!timestamp || timestamp <= 0) {
+    return "\u2014";
+  }
+  const now = Date.now();
+  const diffSeconds = Math.round((now - timestamp) / 1e3);
+  if (diffSeconds < 10) {
+    return "agora";
+  }
+  if (diffSeconds < 60) {
+    return `h\xE1 ${diffSeconds}s`;
+  }
+  const diffMinutes = Math.round(diffSeconds / 60);
+  if (diffMinutes === 1) {
+    return "h\xE1 1 min";
+  }
+  if (diffMinutes < 60) {
+    return `h\xE1 ${diffMinutes} mins`;
+  }
+  const diffHours = Math.round(diffMinutes / 60);
+  if (diffHours === 1) {
+    return "h\xE1 1 hora";
+  }
+  if (diffHours < 24) {
+    return `h\xE1 ${diffHours} horas`;
+  }
+  const diffDays = Math.round(diffHours / 24);
+  if (diffDays === 1) {
+    return "ontem";
+  }
+  if (diffDays <= 30) {
+    return `h\xE1 ${diffDays} dias`;
+  }
+  return new Date(timestamp).toLocaleDateString("pt-BR");
+}
+function formatarDuracao(ms) {
+  if (typeof ms !== "number" || ms < 0 || !isFinite(ms)) {
+    return "0s";
+  }
+  if (ms === 0) {
+    return "0s";
+  }
+  const segundos = Math.floor(ms / 1e3 % 60);
+  const minutos = Math.floor(ms / (1e3 * 60) % 60);
+  const horas = Math.floor(ms / (1e3 * 60 * 60) % 24);
+  const dias = Math.floor(ms / (1e3 * 60 * 60 * 24));
+  const parts = [];
+  if (dias > 0) {
+    parts.push(`${dias}d`);
+    if (horas > 0) {
+      parts.push(`${horas}h`);
+    }
+  } else if (horas > 0) {
+    parts.push(`${horas}h`);
+    if (minutos > 0) {
+      parts.push(`${minutos}m`);
+    }
+  } else if (minutos > 0) {
+    parts.push(`${minutos}m`);
+    if (segundos > 0) {
+      parts.push(`${segundos}s`);
+    }
+  } else {
+    parts.push(`${segundos}s`);
+  }
+  return parts.length > 0 ? parts.join(" ") : "0s";
+}
+var formatDuration = formatarDuracao;
+
 // src/date/ymd.ts
 function formatDateToYMD(date) {
   if (!date) {
@@ -1229,6 +1303,11 @@ function findValue(data, keyOrPath, legacyDataKey) {
   }
   return getValueByDatakey(data, keyOrPath);
 }
+function findValueWithDefault(values, key, defaultValue = null) {
+  if (!Array.isArray(values)) return defaultValue;
+  const found = values.find((v) => v.key === key || v.dataType === key);
+  return found ? found.value : defaultValue;
+}
 
 // src/utils/deviceStatus.js
 var DeviceStatusType = {
@@ -1285,6 +1364,16 @@ function mapDeviceToConnectionStatus(deviceStatus) {
   }
   return ConnectionStatusType.CONNECTED;
 }
+function mapConnectionStatus(rawStatus) {
+  const statusLower = String(rawStatus || "").toLowerCase().trim();
+  if (statusLower === "online" || statusLower === "ok" || statusLower === "running") {
+    return "online";
+  }
+  if (statusLower === "waiting" || statusLower === "connecting" || statusLower === "pending") {
+    return "waiting";
+  }
+  return "offline";
+}
 function mapDeviceStatusToCardStatus(deviceStatus) {
   const statusMap = {
     [DeviceStatusType.POWER_ON]: "ok",
@@ -7698,14 +7787,14 @@ async function openRealTimeTelemetryModal(params) {
     return `${value.toFixed(config.decimals)} ${config.unit}`;
   }
   function initializeChart() {
-    const Chart = window.Chart;
-    if (!Chart) {
+    const Chart2 = window.Chart;
+    if (!Chart2) {
       console.warn("[RealTimeTelemetry] Chart.js not loaded");
       return;
     }
     chartContainer.style.display = "block";
     const config = TELEMETRY_CONFIG[selectedChartKey] || { label: selectedChartKey, unit: "" };
-    chart = new Chart(chartCanvas, {
+    chart = new Chart2(chartCanvas, {
       type: "line",
       data: {
         datasets: [{
@@ -10474,7 +10563,7 @@ async function openDemandModal(params) {
       params.timezoneOffset
     );
     if (!newChartData.isEmpty && chart && chartData) {
-      const Chart = window.Chart;
+      const Chart2 = window.Chart;
       newChartData.series.forEach((newSeries, seriesIndex) => {
         if (newSeries.points.length > 0 && chart.data.datasets[seriesIndex]) {
           newSeries.points.forEach((point) => {
@@ -10703,8 +10792,8 @@ async function openDemandModal(params) {
         peakEl.textContent = `${strings.maximum}: ${peak.formattedValue} kW ${peak.key ? `(${peak.key}) ` : ""}${strings.at} ${dateStr}`;
         peakEl.style.display = "block";
       }
-      const Chart = window.Chart;
-      Chart.register(window.ChartZoom);
+      const Chart2 = window.Chart;
+      Chart2.register(window.ChartZoom);
       if (chart) {
         chart.data.datasets = chartData.series.map((series) => ({
           label: series.label,
@@ -10756,7 +10845,7 @@ async function openDemandModal(params) {
         };
         chart.update();
       } else {
-        chart = new Chart(chartCanvas, {
+        chart = new Chart2(chartCanvas, {
           type: "line",
           data: {
             datasets: chartData.series.map((series) => ({
@@ -18929,8 +19018,8 @@ function openGoalsPanel(params) {
             <div class="myio-goals-progress-fill" style="width: ${Math.min(progress, 100)}%"></div>
           </div>
           <div class="myio-goals-progress-text">
-            <span>${formatNumber2(monthlySum, locale)} ${annual.unit}</span>
-            <span>${formatNumber2(annual.total, locale)} ${annual.unit}</span>
+            <span>${formatNumber3(monthlySum, locale)} ${annual.unit}</span>
+            <span>${formatNumber3(annual.total, locale)} ${annual.unit}</span>
           </div>
 
           <!-- Monthly Grid -->
@@ -19004,7 +19093,7 @@ function openGoalsPanel(params) {
             <span>${assetData.label || assetId}</span>
           </div>
           <div class="myio-goals-asset-total">
-            ${formatNumber2(assetData.annual?.total || 0, locale)} ${assetData.annual?.unit || "kWh"}
+            ${formatNumber3(assetData.annual?.total || 0, locale)} ${assetData.annual?.unit || "kWh"}
           </div>
           <button class="myio-goals-btn-icon" data-action="delete-asset" data-asset-id="${assetId}" aria-label="${i18n.deleteAsset}">
             <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
@@ -19319,7 +19408,7 @@ function openGoalsPanel(params) {
         monthlySum += value;
       }
       if (monthlySum > annualTotal && annualTotal > 0) {
-        errors.push(`${i18n.errorMonthlyExceedsAnnual} (${formatNumber2(monthlySum, locale)} > ${formatNumber2(annualTotal, locale)})`);
+        errors.push(`${i18n.errorMonthlyExceedsAnnual} (${formatNumber3(monthlySum, locale)} > ${formatNumber3(annualTotal, locale)})`);
       }
     }
     return errors;
@@ -19410,8 +19499,8 @@ function openGoalsPanel(params) {
     }
     if (progressTexts.length === 2) {
       const unit = document.getElementById("unit-select")?.value || "kWh";
-      progressTexts[0].textContent = `${formatNumber2(monthlySum, locale)} ${unit}`;
-      progressTexts[1].textContent = `${formatNumber2(annualTotal, locale)} ${unit}`;
+      progressTexts[0].textContent = `${formatNumber3(monthlySum, locale)} ${unit}`;
+      progressTexts[1].textContent = `${formatNumber3(annualTotal, locale)} ${unit}`;
     }
   }
   function updateMonthlyUnits(unit) {
@@ -19509,7 +19598,7 @@ function openGoalsPanel(params) {
     modal.addEventListener("keydown", handleTab);
     firstElement.focus();
   }
-  function formatNumber2(value, locale2) {
+  function formatNumber3(value, locale2) {
     return new Intl.NumberFormat(locale2, {
       minimumFractionDigits: 0,
       maximumFractionDigits: 2
@@ -22459,11 +22548,1742 @@ function openTemperatureSettingsModal(params) {
   });
   return { destroy };
 }
+
+// src/components/ModalHeader/index.ts
+var DEFAULT_BG_COLOR = "#3e1a7d";
+var DEFAULT_TEXT_COLOR = "white";
+var DEFAULT_BORDER_RADIUS = "10px 10px 0 0";
+var EXPORT_FORMAT_LABELS = {
+  csv: "CSV",
+  xls: "Excel (XLS)",
+  pdf: "PDF"
+};
+var EXPORT_FORMAT_ICONS = {
+  csv: "\u{1F4C4}",
+  xls: "\u{1F4CA}",
+  pdf: "\u{1F4D1}"
+};
+function createModalHeader(config) {
+  let currentTheme = config.theme || "light";
+  let currentIsMaximized = config.isMaximized || false;
+  let currentTitle = config.title;
+  let themeBtn = null;
+  let maximizeBtn = null;
+  let closeBtn = null;
+  let exportBtn = null;
+  let exportDropdown = null;
+  const cleanupHandlers = [];
+  const handleThemeClick = () => {
+    currentTheme = currentTheme === "light" ? "dark" : "light";
+    config.onThemeToggle?.(currentTheme);
+    updateButtonIcons();
+  };
+  const handleMaximizeClick = () => {
+    currentIsMaximized = !currentIsMaximized;
+    config.onMaximize?.(currentIsMaximized);
+    updateButtonIcons();
+  };
+  const handleCloseClick = () => {
+    config.onClose?.();
+  };
+  const handleExportClick = (format) => {
+    config.onExport?.(format);
+    if (exportDropdown) {
+      exportDropdown.style.display = "none";
+    }
+  };
+  function updateButtonIcons() {
+    if (themeBtn) {
+      themeBtn.textContent = currentTheme === "dark" ? "\u2600\uFE0F" : "\u{1F319}";
+      themeBtn.title = currentTheme === "dark" ? "Modo claro" : "Modo escuro";
+    }
+    if (maximizeBtn) {
+      maximizeBtn.textContent = currentIsMaximized ? "\u{1F5D7}" : "\u{1F5D6}";
+      maximizeBtn.title = currentIsMaximized ? "Restaurar" : "Maximizar";
+    }
+  }
+  function getButtonStyle() {
+    return `
+      background: none;
+      border: none;
+      font-size: 16px;
+      cursor: pointer;
+      padding: 4px 8px;
+      border-radius: 6px;
+      color: rgba(255, 255, 255, 0.8);
+      transition: background-color 0.2s, color 0.2s;
+    `.replace(/\s+/g, " ").trim();
+  }
+  function renderExportDropdown() {
+    const formats = config.exportFormats || [];
+    if (formats.length === 0) return "";
+    if (formats.length === 1) {
+      return `
+        <button id="${config.id}-export" title="Exportar ${EXPORT_FORMAT_LABELS[formats[0]]}" style="${getButtonStyle()}">
+          \u{1F4E5}
+        </button>
+      `;
+    }
+    return `
+      <div style="position: relative; display: inline-block;">
+        <button id="${config.id}-export-btn" title="Exportar" style="${getButtonStyle()}">
+          \u{1F4E5}
+        </button>
+        <div id="${config.id}-export-dropdown" style="
+          display: none;
+          position: absolute;
+          top: 100%;
+          right: 0;
+          background: white;
+          border-radius: 6px;
+          box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+          min-width: 140px;
+          z-index: 10001;
+          margin-top: 4px;
+          overflow: hidden;
+        ">
+          ${formats.map((format) => `
+            <button
+              id="${config.id}-export-${format}"
+              class="myio-export-option"
+              data-format="${format}"
+              style="
+                display: flex;
+                align-items: center;
+                gap: 8px;
+                width: 100%;
+                padding: 10px 14px;
+                border: none;
+                background: white;
+                cursor: pointer;
+                font-size: 13px;
+                color: #333;
+                text-align: left;
+                transition: background-color 0.2s;
+              "
+            >
+              ${EXPORT_FORMAT_ICONS[format]} ${EXPORT_FORMAT_LABELS[format]}
+            </button>
+          `).join("")}
+        </div>
+      </div>
+    `;
+  }
+  const instance = {
+    render() {
+      const bgColor = config.backgroundColor || DEFAULT_BG_COLOR;
+      const textColor = config.textColor || DEFAULT_TEXT_COLOR;
+      const borderRadius = currentIsMaximized ? "0" : config.borderRadius || DEFAULT_BORDER_RADIUS;
+      const showTheme = config.showThemeToggle !== false;
+      const showMax = config.showMaximize !== false;
+      const showClose = config.showClose !== false;
+      const showExport = config.exportFormats && config.exportFormats.length > 0;
+      const iconHtml = config.icon ? `<span style="margin-right: 8px;">${config.icon}</span>` : "";
+      const buttonStyle = getButtonStyle();
+      return `
+        <div class="myio-modal-header" style="
+          padding: 4px 8px;
+          display: flex;
+          align-items: center;
+          justify-content: space-between;
+          background: ${bgColor};
+          color: ${textColor};
+          border-radius: ${borderRadius};
+          min-height: 20px;
+          font-family: 'Roboto', Arial, sans-serif;
+        ">
+          <h2 id="${config.id}-header-title" style="
+            margin: 6px;
+            font-size: 18px;
+            font-weight: 600;
+            color: ${textColor};
+            line-height: 2;
+            display: flex;
+            align-items: center;
+          ">
+            ${iconHtml}${currentTitle}
+          </h2>
+          <div style="display: flex; gap: 4px; align-items: center;">
+            ${showExport ? renderExportDropdown() : ""}
+            ${showTheme ? `
+              <button id="${config.id}-theme-toggle" title="${currentTheme === "dark" ? "Modo claro" : "Modo escuro"}" style="${buttonStyle}">
+                ${currentTheme === "dark" ? "\u2600\uFE0F" : "\u{1F319}"}
+              </button>
+            ` : ""}
+            ${showMax ? `
+              <button id="${config.id}-maximize" title="${currentIsMaximized ? "Restaurar" : "Maximizar"}" style="${buttonStyle}">
+                ${currentIsMaximized ? "\u{1F5D7}" : "\u{1F5D6}"}
+              </button>
+            ` : ""}
+            ${showClose ? `
+              <button id="${config.id}-close" title="Fechar" style="${buttonStyle}; font-size: 20px;">
+                \xD7
+              </button>
+            ` : ""}
+          </div>
+        </div>
+      `;
+    },
+    attachListeners() {
+      themeBtn = document.getElementById(`${config.id}-theme-toggle`);
+      maximizeBtn = document.getElementById(`${config.id}-maximize`);
+      closeBtn = document.getElementById(`${config.id}-close`);
+      const singleExportBtn = document.getElementById(`${config.id}-export`);
+      if (singleExportBtn && config.exportFormats?.length === 1) {
+        exportBtn = singleExportBtn;
+        const format = config.exportFormats[0];
+        const clickHandler = () => handleExportClick(format);
+        exportBtn.addEventListener("click", clickHandler);
+        cleanupHandlers.push(() => exportBtn?.removeEventListener("click", clickHandler));
+        const enterHandler = () => {
+          exportBtn.style.backgroundColor = "rgba(255, 255, 255, 0.2)";
+        };
+        const leaveHandler = () => {
+          exportBtn.style.backgroundColor = "transparent";
+        };
+        exportBtn.addEventListener("mouseenter", enterHandler);
+        exportBtn.addEventListener("mouseleave", leaveHandler);
+        cleanupHandlers.push(() => {
+          exportBtn?.removeEventListener("mouseenter", enterHandler);
+          exportBtn?.removeEventListener("mouseleave", leaveHandler);
+        });
+      }
+      const exportDropdownBtn = document.getElementById(`${config.id}-export-btn`);
+      exportDropdown = document.getElementById(`${config.id}-export-dropdown`);
+      if (exportDropdownBtn && exportDropdown) {
+        exportBtn = exportDropdownBtn;
+        const toggleHandler = (e) => {
+          e.stopPropagation();
+          if (exportDropdown) {
+            exportDropdown.style.display = exportDropdown.style.display === "none" ? "block" : "none";
+          }
+        };
+        exportDropdownBtn.addEventListener("click", toggleHandler);
+        cleanupHandlers.push(() => exportDropdownBtn.removeEventListener("click", toggleHandler));
+        const outsideClickHandler = (e) => {
+          if (exportDropdown && !exportDropdown.contains(e.target) && e.target !== exportDropdownBtn) {
+            exportDropdown.style.display = "none";
+          }
+        };
+        document.addEventListener("click", outsideClickHandler);
+        cleanupHandlers.push(() => document.removeEventListener("click", outsideClickHandler));
+        config.exportFormats?.forEach((format) => {
+          const btn = document.getElementById(`${config.id}-export-${format}`);
+          if (btn) {
+            const clickHandler = () => handleExportClick(format);
+            btn.addEventListener("click", clickHandler);
+            cleanupHandlers.push(() => btn.removeEventListener("click", clickHandler));
+            const enterHandler2 = () => {
+              btn.style.backgroundColor = "#f0f0f0";
+            };
+            const leaveHandler2 = () => {
+              btn.style.backgroundColor = "white";
+            };
+            btn.addEventListener("mouseenter", enterHandler2);
+            btn.addEventListener("mouseleave", leaveHandler2);
+            cleanupHandlers.push(() => {
+              btn.removeEventListener("mouseenter", enterHandler2);
+              btn.removeEventListener("mouseleave", leaveHandler2);
+            });
+          }
+        });
+        const enterHandler = () => {
+          exportDropdownBtn.style.backgroundColor = "rgba(255, 255, 255, 0.2)";
+        };
+        const leaveHandler = () => {
+          exportDropdownBtn.style.backgroundColor = "transparent";
+        };
+        exportDropdownBtn.addEventListener("mouseenter", enterHandler);
+        exportDropdownBtn.addEventListener("mouseleave", leaveHandler);
+        cleanupHandlers.push(() => {
+          exportDropdownBtn.removeEventListener("mouseenter", enterHandler);
+          exportDropdownBtn.removeEventListener("mouseleave", leaveHandler);
+        });
+      }
+      if (themeBtn && config.showThemeToggle !== false) {
+        themeBtn.addEventListener("click", handleThemeClick);
+        cleanupHandlers.push(() => themeBtn?.removeEventListener("click", handleThemeClick));
+        const enterHandler = () => {
+          themeBtn.style.backgroundColor = "rgba(255, 255, 255, 0.2)";
+        };
+        const leaveHandler = () => {
+          themeBtn.style.backgroundColor = "transparent";
+        };
+        themeBtn.addEventListener("mouseenter", enterHandler);
+        themeBtn.addEventListener("mouseleave", leaveHandler);
+        cleanupHandlers.push(() => {
+          themeBtn?.removeEventListener("mouseenter", enterHandler);
+          themeBtn?.removeEventListener("mouseleave", leaveHandler);
+        });
+      }
+      if (maximizeBtn && config.showMaximize !== false) {
+        maximizeBtn.addEventListener("click", handleMaximizeClick);
+        cleanupHandlers.push(() => maximizeBtn?.removeEventListener("click", handleMaximizeClick));
+        const enterHandler = () => {
+          maximizeBtn.style.backgroundColor = "rgba(255, 255, 255, 0.2)";
+        };
+        const leaveHandler = () => {
+          maximizeBtn.style.backgroundColor = "transparent";
+        };
+        maximizeBtn.addEventListener("mouseenter", enterHandler);
+        maximizeBtn.addEventListener("mouseleave", leaveHandler);
+        cleanupHandlers.push(() => {
+          maximizeBtn?.removeEventListener("mouseenter", enterHandler);
+          maximizeBtn?.removeEventListener("mouseleave", leaveHandler);
+        });
+      }
+      if (closeBtn && config.showClose !== false) {
+        closeBtn.addEventListener("click", handleCloseClick);
+        cleanupHandlers.push(() => closeBtn?.removeEventListener("click", handleCloseClick));
+        const enterHandler = () => {
+          closeBtn.style.backgroundColor = "rgba(255, 255, 255, 0.2)";
+        };
+        const leaveHandler = () => {
+          closeBtn.style.backgroundColor = "transparent";
+        };
+        closeBtn.addEventListener("mouseenter", enterHandler);
+        closeBtn.addEventListener("mouseleave", leaveHandler);
+        cleanupHandlers.push(() => {
+          closeBtn?.removeEventListener("mouseenter", enterHandler);
+          closeBtn?.removeEventListener("mouseleave", leaveHandler);
+        });
+      }
+    },
+    update(updates) {
+      if (updates.theme !== void 0) {
+        currentTheme = updates.theme;
+        updateButtonIcons();
+      }
+      if (updates.isMaximized !== void 0) {
+        currentIsMaximized = updates.isMaximized;
+        updateButtonIcons();
+      }
+      if (updates.title !== void 0) {
+        currentTitle = updates.title;
+        const titleEl = document.getElementById(`${config.id}-header-title`);
+        if (titleEl) {
+          const iconHtml = config.icon ? `<span style="margin-right: 8px;">${config.icon}</span>` : "";
+          titleEl.innerHTML = `${iconHtml}${currentTitle}`;
+        }
+      }
+    },
+    getState() {
+      return {
+        theme: currentTheme,
+        isMaximized: currentIsMaximized
+      };
+    },
+    destroy() {
+      cleanupHandlers.forEach((handler) => handler());
+      cleanupHandlers.length = 0;
+      themeBtn = null;
+      maximizeBtn = null;
+      closeBtn = null;
+      exportBtn = null;
+      exportDropdown = null;
+    }
+  };
+  return instance;
+}
+function getModalHeaderStyles() {
+  return `
+    .myio-modal-header button:hover {
+      background-color: rgba(255, 255, 255, 0.2) !important;
+    }
+    .myio-modal-header button:active {
+      background-color: rgba(255, 255, 255, 0.3) !important;
+    }
+    .myio-export-option:hover {
+      background-color: #f0f0f0 !important;
+    }
+  `;
+}
+
+// src/components/Consumption7DaysChart/types.ts
+var DEFAULT_COLORS = {
+  energy: {
+    primary: "#2563eb",
+    background: "rgba(37, 99, 235, 0.1)",
+    gradient: ["#f0fdf4", "#dcfce7"],
+    pointBackground: "#2563eb",
+    pointBorder: "#ffffff"
+  },
+  water: {
+    primary: "#0288d1",
+    background: "rgba(2, 136, 209, 0.1)",
+    gradient: ["#f0f9ff", "#bae6fd"],
+    pointBackground: "#0288d1",
+    pointBorder: "#ffffff"
+  },
+  gas: {
+    primary: "#ea580c",
+    background: "rgba(234, 88, 12, 0.1)",
+    gradient: ["#fff7ed", "#fed7aa"],
+    pointBackground: "#ea580c",
+    pointBorder: "#ffffff"
+  },
+  temperature: {
+    primary: "#dc2626",
+    background: "rgba(220, 38, 38, 0.1)",
+    gradient: ["#fef2f2", "#fecaca"],
+    pointBackground: "#dc2626",
+    pointBorder: "#ffffff"
+  }
+};
+var THEME_COLORS = {
+  light: {
+    chartBackground: "#ffffff",
+    text: "#1f2937",
+    textMuted: "#6b7280",
+    grid: "rgba(0, 0, 0, 0.1)",
+    border: "#e5e7eb",
+    tooltipBackground: "#ffffff",
+    tooltipText: "#1f2937"
+  },
+  dark: {
+    chartBackground: "#1f2937",
+    text: "#f9fafb",
+    textMuted: "#9ca3af",
+    grid: "rgba(255, 255, 255, 0.1)",
+    border: "#374151",
+    tooltipBackground: "#374151",
+    tooltipText: "#f9fafb"
+  }
+};
+var DEFAULT_CONFIG = {
+  defaultPeriod: 7,
+  defaultChartType: "line",
+  defaultVizMode: "total",
+  defaultTheme: "light",
+  cacheTTL: 3e5,
+  // 5 minutes
+  decimalPlaces: 1,
+  lineTension: 0.4,
+  pointRadius: 4,
+  borderWidth: 2,
+  fill: true,
+  showLegend: false,
+  enableExport: true
+};
+
+// src/components/Consumption7DaysChart/createConsumption7DaysChart.ts
+function createConsumption7DaysChart(config) {
+  let chartInstance = null;
+  let cachedData = null;
+  let currentPeriod = config.defaultPeriod ?? DEFAULT_CONFIG.defaultPeriod;
+  let currentChartType = config.defaultChartType ?? DEFAULT_CONFIG.defaultChartType;
+  let currentVizMode = config.defaultVizMode ?? DEFAULT_CONFIG.defaultVizMode;
+  let currentTheme = config.theme ?? DEFAULT_CONFIG.defaultTheme;
+  let currentIdealRange = config.idealRange ?? null;
+  let isRendered = false;
+  let autoRefreshTimer = null;
+  const colors = {
+    ...DEFAULT_COLORS[config.domain] ?? DEFAULT_COLORS.energy,
+    ...config.colors
+  };
+  function $id(id) {
+    if (config.$container && config.$container[0]) {
+      return config.$container[0].querySelector(`#${id}`);
+    }
+    return document.getElementById(id);
+  }
+  function log(level, ...args) {
+    const prefix = `[${config.domain.toUpperCase()}]`;
+    console[level](prefix, ...args);
+  }
+  function calculateYAxisMax(values) {
+    const maxValue = Math.max(...values, 0);
+    if (config.domain === "temperature") {
+      const tempConfig = config.temperatureConfig;
+      if (tempConfig?.clampRange) {
+        return tempConfig.clampRange.max;
+      }
+      const maxWithThreshold = Math.max(
+        maxValue,
+        tempConfig?.maxThreshold?.value ?? 0,
+        tempConfig?.idealRange?.max ?? 0
+      );
+      return Math.ceil(maxWithThreshold + 5);
+    }
+    if (maxValue === 0) {
+      return config.thresholdForLargeUnit ? config.thresholdForLargeUnit / 2 : 500;
+    }
+    let roundTo;
+    if (config.thresholdForLargeUnit && maxValue >= config.thresholdForLargeUnit) {
+      roundTo = config.thresholdForLargeUnit / 10;
+    } else if (maxValue >= 1e3) {
+      roundTo = 100;
+    } else if (maxValue >= 100) {
+      roundTo = 50;
+    } else if (maxValue >= 10) {
+      roundTo = 10;
+    } else {
+      roundTo = 5;
+    }
+    return Math.ceil(maxValue * 1.1 / roundTo) * roundTo;
+  }
+  function calculateYAxisMin(values) {
+    if (config.domain !== "temperature") {
+      return 0;
+    }
+    const tempConfig = config.temperatureConfig;
+    if (tempConfig?.clampRange) {
+      return tempConfig.clampRange.min;
+    }
+    const minValue = Math.min(...values);
+    const minWithThreshold = Math.min(
+      minValue,
+      tempConfig?.minThreshold?.value ?? minValue,
+      tempConfig?.idealRange?.min ?? minValue
+    );
+    return Math.floor(minWithThreshold - 5);
+  }
+  function buildTemperatureAnnotations() {
+    const tempConfig = config.temperatureConfig;
+    if (!tempConfig || config.domain !== "temperature") {
+      return {};
+    }
+    const annotations = {};
+    const createLineAnnotation = (line, id) => {
+      const borderDash = line.lineStyle === "dashed" ? [6, 6] : line.lineStyle === "dotted" ? [2, 2] : [];
+      return {
+        type: "line",
+        yMin: line.value,
+        yMax: line.value,
+        borderColor: line.color,
+        borderWidth: line.lineWidth ?? 2,
+        borderDash,
+        label: {
+          display: true,
+          content: line.label,
+          position: "end",
+          backgroundColor: line.color,
+          color: "#fff",
+          font: { size: 10, weight: "bold" },
+          padding: { x: 4, y: 2 }
+        }
+      };
+    };
+    if (tempConfig.minThreshold) {
+      annotations["minThreshold"] = createLineAnnotation(tempConfig.minThreshold, "minThreshold");
+    }
+    if (tempConfig.maxThreshold) {
+      annotations["maxThreshold"] = createLineAnnotation(tempConfig.maxThreshold, "maxThreshold");
+    }
+    if (tempConfig.idealRange) {
+      annotations["idealRange"] = {
+        type: "box",
+        yMin: tempConfig.idealRange.min,
+        yMax: tempConfig.idealRange.max,
+        backgroundColor: tempConfig.idealRange.color,
+        borderWidth: 0,
+        label: tempConfig.idealRange.label ? {
+          display: true,
+          content: tempConfig.idealRange.label,
+          position: { x: "start", y: "center" },
+          color: "#666",
+          font: { size: 10 }
+        } : void 0
+      };
+    }
+    return annotations;
+  }
+  function buildIdealRangeAnnotation() {
+    if (!currentIdealRange) {
+      return {};
+    }
+    const { min, max, enabled = true } = currentIdealRange;
+    if (!enabled || min === 0 && max === 0 || min >= max) {
+      return {};
+    }
+    const defaultColors = {
+      temperature: { bg: "rgba(34, 197, 94, 0.15)", border: "rgba(34, 197, 94, 0.4)" },
+      energy: { bg: "rgba(37, 99, 235, 0.1)", border: "rgba(37, 99, 235, 0.3)" },
+      water: { bg: "rgba(2, 136, 209, 0.1)", border: "rgba(2, 136, 209, 0.3)" },
+      gas: { bg: "rgba(234, 88, 12, 0.1)", border: "rgba(234, 88, 12, 0.3)" }
+    };
+    const domainDefaults = defaultColors[config.domain] || defaultColors.energy;
+    return {
+      idealRangeBox: {
+        type: "box",
+        yMin: min,
+        yMax: max,
+        backgroundColor: currentIdealRange.color || domainDefaults.bg,
+        borderColor: currentIdealRange.borderColor || domainDefaults.border,
+        borderWidth: 1,
+        label: currentIdealRange.label ? {
+          display: true,
+          content: currentIdealRange.label,
+          position: { x: "start", y: "center" },
+          color: "#666",
+          font: { size: 10, style: "italic" },
+          backgroundColor: "rgba(255, 255, 255, 0.8)",
+          padding: { x: 4, y: 2 }
+        } : void 0
+      }
+    };
+  }
+  function formatValue(value, includeUnit = true) {
+    const decimals = config.decimalPlaces ?? DEFAULT_CONFIG.decimalPlaces;
+    if (config.unitLarge && config.thresholdForLargeUnit && value >= config.thresholdForLargeUnit) {
+      const converted = value / config.thresholdForLargeUnit;
+      return includeUnit ? `${converted.toFixed(decimals)} ${config.unitLarge}` : converted.toFixed(decimals);
+    }
+    return includeUnit ? `${value.toFixed(decimals)} ${config.unit}` : value.toFixed(decimals);
+  }
+  function formatTickValue(value) {
+    if (config.unitLarge && config.thresholdForLargeUnit && value >= config.thresholdForLargeUnit) {
+      return `${(value / config.thresholdForLargeUnit).toFixed(1)}`;
+    }
+    return value.toFixed(0);
+  }
+  function buildChartConfig(data) {
+    const yAxisMax = calculateYAxisMax(data.dailyTotals);
+    const yAxisMin = calculateYAxisMin(data.dailyTotals);
+    const tension = config.lineTension ?? DEFAULT_CONFIG.lineTension;
+    const pointRadius = config.pointRadius ?? DEFAULT_CONFIG.pointRadius;
+    const borderWidth = config.borderWidth ?? DEFAULT_CONFIG.borderWidth;
+    const fill = config.fill ?? DEFAULT_CONFIG.fill;
+    const showLegend = config.showLegend ?? DEFAULT_CONFIG.showLegend;
+    const themeColors = THEME_COLORS[currentTheme];
+    const isTemperature = config.domain === "temperature";
+    let datasets;
+    if (currentVizMode === "separate" && data.shoppingData && data.shoppingNames) {
+      const shoppingColors = [
+        "#2563eb",
+        "#16a34a",
+        "#ea580c",
+        "#dc2626",
+        "#8b5cf6",
+        "#0891b2",
+        "#65a30d",
+        "#d97706",
+        "#be185d",
+        "#0d9488"
+      ];
+      datasets = Object.entries(data.shoppingData).map(([shoppingId, values], index) => ({
+        label: data.shoppingNames?.[shoppingId] || shoppingId,
+        data: values,
+        borderColor: shoppingColors[index % shoppingColors.length],
+        backgroundColor: currentChartType === "line" ? `${shoppingColors[index % shoppingColors.length]}20` : shoppingColors[index % shoppingColors.length],
+        fill: currentChartType === "line" && fill,
+        tension,
+        borderWidth,
+        pointRadius: currentChartType === "line" ? pointRadius : 0,
+        pointBackgroundColor: shoppingColors[index % shoppingColors.length],
+        pointBorderColor: "#fff",
+        pointBorderWidth: 2
+      }));
+    } else {
+      const datasetLabel = isTemperature ? `Temperatura (${config.unit})` : `Consumo (${config.unit})`;
+      datasets = [
+        {
+          label: datasetLabel,
+          data: data.dailyTotals,
+          borderColor: colors.primary,
+          backgroundColor: currentChartType === "line" ? colors.background : colors.primary,
+          fill: currentChartType === "line" && fill,
+          tension,
+          borderWidth,
+          pointRadius: currentChartType === "line" ? pointRadius : 0,
+          pointBackgroundColor: colors.pointBackground || colors.primary,
+          pointBorderColor: colors.pointBorder || "#fff",
+          pointBorderWidth: 2,
+          borderRadius: currentChartType === "bar" ? 4 : 0
+        }
+      ];
+    }
+    const temperatureAnnotations = buildTemperatureAnnotations();
+    const idealRangeAnnotations = buildIdealRangeAnnotation();
+    const allAnnotations = { ...temperatureAnnotations, ...idealRangeAnnotations };
+    const yAxisLabel = config.unitLarge && config.thresholdForLargeUnit && yAxisMax >= config.thresholdForLargeUnit ? config.unitLarge : config.unit;
+    return {
+      type: currentChartType,
+      data: {
+        labels: data.labels,
+        datasets
+      },
+      options: {
+        responsive: true,
+        maintainAspectRatio: false,
+        animation: false,
+        // CRITICAL: Prevents infinite growth bug
+        plugins: {
+          legend: {
+            display: showLegend || currentVizMode === "separate",
+            position: "bottom",
+            labels: {
+              color: themeColors.text
+            }
+          },
+          tooltip: {
+            backgroundColor: themeColors.tooltipBackground,
+            titleColor: themeColors.tooltipText,
+            bodyColor: themeColors.tooltipText,
+            borderColor: themeColors.border,
+            borderWidth: 1,
+            callbacks: {
+              label: function(context) {
+                const value = context.parsed.y || 0;
+                const label = context.dataset.label || "";
+                return `${label}: ${formatValue(value)}`;
+              }
+            }
+          },
+          // Reference lines and ideal range (requires chartjs-plugin-annotation)
+          annotation: Object.keys(allAnnotations).length > 0 ? {
+            annotations: allAnnotations
+          } : void 0
+        },
+        scales: {
+          y: {
+            beginAtZero: !isTemperature,
+            // Temperature can have negative values
+            min: yAxisMin,
+            max: yAxisMax,
+            // CRITICAL: Fixed max prevents animation loop
+            grid: {
+              color: themeColors.grid
+            },
+            title: {
+              display: true,
+              text: yAxisLabel,
+              font: { size: 12 },
+              color: themeColors.text
+            },
+            ticks: {
+              font: { size: 11 },
+              color: themeColors.textMuted,
+              callback: function(value) {
+                return formatTickValue(value);
+              }
+            }
+          },
+          x: {
+            grid: {
+              color: themeColors.grid
+            },
+            ticks: {
+              font: { size: 11 },
+              color: themeColors.textMuted
+            }
+          }
+        }
+      }
+    };
+  }
+  function validateChartJs() {
+    if (typeof Chart === "undefined") {
+      log("error", "Chart.js not loaded. Cannot initialize chart.");
+      config.onError?.(new Error("Chart.js not loaded"));
+      return false;
+    }
+    return true;
+  }
+  function validateCanvas() {
+    const canvas = $id(config.containerId);
+    if (!canvas) {
+      log("error", `Canvas #${config.containerId} not found`);
+      config.onError?.(new Error(`Canvas #${config.containerId} not found`));
+      return null;
+    }
+    return canvas;
+  }
+  function setupAutoRefresh() {
+    if (config.autoRefreshInterval && config.autoRefreshInterval > 0) {
+      if (autoRefreshTimer) {
+        clearInterval(autoRefreshTimer);
+      }
+      autoRefreshTimer = setInterval(async () => {
+        log("log", "Auto-refreshing data...");
+        await instance.refresh(true);
+      }, config.autoRefreshInterval);
+    }
+  }
+  function cleanupAutoRefresh() {
+    if (autoRefreshTimer) {
+      clearInterval(autoRefreshTimer);
+      autoRefreshTimer = null;
+    }
+  }
+  function setupButtonHandlers() {
+    if (config.settingsButtonId && config.onSettingsClick) {
+      const settingsBtn = $id(config.settingsButtonId);
+      if (settingsBtn) {
+        settingsBtn.addEventListener("click", () => {
+          log("log", "Settings button clicked");
+          config.onSettingsClick?.();
+        });
+        log("log", "Settings button handler attached");
+      }
+    }
+    if (config.maximizeButtonId && config.onMaximizeClick) {
+      const maximizeBtn = $id(config.maximizeButtonId);
+      if (maximizeBtn) {
+        maximizeBtn.addEventListener("click", () => {
+          log("log", "Maximize button clicked");
+          config.onMaximizeClick?.();
+        });
+        log("log", "Maximize button handler attached");
+      }
+    }
+    const enableExport = config.enableExport ?? DEFAULT_CONFIG.enableExport;
+    if (enableExport && config.exportButtonId) {
+      const exportBtn = $id(config.exportButtonId);
+      if (exportBtn) {
+        exportBtn.addEventListener("click", () => {
+          log("log", "Export button clicked");
+          if (config.onExportCSV && cachedData) {
+            config.onExportCSV(cachedData);
+          } else {
+            instance.exportCSV();
+          }
+        });
+        log("log", "Export button handler attached");
+      }
+    }
+  }
+  function generateCSVContent(data) {
+    const rows = [];
+    const decimals = config.decimalPlaces ?? DEFAULT_CONFIG.decimalPlaces;
+    if (currentVizMode === "separate" && data.shoppingData && data.shoppingNames) {
+      const shoppingHeaders = Object.keys(data.shoppingData).map(
+        (id) => data.shoppingNames?.[id] || id
+      );
+      rows.push(["Data", ...shoppingHeaders, "Total"].join(";"));
+      data.labels.forEach((label, index) => {
+        const shoppingValues = Object.keys(data.shoppingData).map(
+          (id) => data.shoppingData[id][index].toFixed(decimals)
+        );
+        rows.push([label, ...shoppingValues, data.dailyTotals[index].toFixed(decimals)].join(";"));
+      });
+    } else {
+      rows.push(["Data", `Consumo (${config.unit})`].join(";"));
+      data.labels.forEach((label, index) => {
+        rows.push([label, data.dailyTotals[index].toFixed(decimals)].join(";"));
+      });
+    }
+    const total = data.dailyTotals.reduce((sum, v) => sum + v, 0);
+    const avg = total / data.dailyTotals.length;
+    rows.push("");
+    rows.push(["Total", total.toFixed(decimals)].join(";"));
+    rows.push(["M\xE9dia", avg.toFixed(decimals)].join(";"));
+    return rows.join("\n");
+  }
+  function downloadCSV(content, filename) {
+    const BOM = "\uFEFF";
+    const blob = new Blob([BOM + content], { type: "text/csv;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = `${filename}.csv`;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+    log("log", `CSV exported: ${filename}.csv`);
+  }
+  function updateTitle() {
+    if (config.titleElementId) {
+      const titleEl = $id(config.titleElementId);
+      if (titleEl) {
+        if (currentPeriod === 0) {
+          titleEl.textContent = `Consumo - Per\xEDodo Personalizado`;
+        } else {
+          titleEl.textContent = `Consumo dos \xFAltimos ${currentPeriod} dias`;
+        }
+      }
+    }
+  }
+  const instance = {
+    async render() {
+      log("log", "Rendering chart...");
+      if (!validateChartJs()) return;
+      const canvas = validateCanvas();
+      if (!canvas) return;
+      try {
+        log("log", `Fetching ${currentPeriod} days of data...`);
+        cachedData = await config.fetchData(currentPeriod);
+        cachedData.fetchTimestamp = Date.now();
+        if (config.onBeforeRender) {
+          cachedData = config.onBeforeRender(cachedData);
+        }
+        if (chartInstance) {
+          chartInstance.destroy();
+          chartInstance = null;
+        }
+        const ctx = canvas.getContext("2d");
+        const chartConfig = buildChartConfig(cachedData);
+        chartInstance = new Chart(ctx, chartConfig);
+        isRendered = true;
+        const yAxisMax = calculateYAxisMax(cachedData.dailyTotals);
+        log("log", `Chart initialized with yAxisMax: ${yAxisMax}`);
+        config.onDataLoaded?.(cachedData);
+        config.onAfterRender?.(chartInstance);
+        setupButtonHandlers();
+        updateTitle();
+        setupAutoRefresh();
+      } catch (error) {
+        log("error", "Failed to render chart:", error);
+        config.onError?.(error instanceof Error ? error : new Error(String(error)));
+      }
+    },
+    async update(data) {
+      if (data) {
+        cachedData = data;
+        cachedData.fetchTimestamp = Date.now();
+      }
+      if (!chartInstance || !cachedData) {
+        log("warn", "Cannot update: chart not initialized or no data");
+        return;
+      }
+      let renderData = cachedData;
+      if (config.onBeforeRender) {
+        renderData = config.onBeforeRender(cachedData);
+      }
+      const chartConfig = buildChartConfig(renderData);
+      chartInstance.data = chartConfig.data;
+      chartInstance.options = chartConfig.options;
+      chartInstance.update("none");
+      log("log", "Chart updated");
+    },
+    setChartType(type) {
+      if (currentChartType === type) return;
+      log("log", `Changing chart type to: ${type}`);
+      currentChartType = type;
+      if (cachedData && chartInstance) {
+        const canvas = validateCanvas();
+        if (canvas) {
+          chartInstance.destroy();
+          const ctx = canvas.getContext("2d");
+          chartInstance = new Chart(ctx, buildChartConfig(cachedData));
+        }
+      }
+    },
+    setVizMode(mode) {
+      if (currentVizMode === mode) return;
+      log("log", `Changing viz mode to: ${mode}`);
+      currentVizMode = mode;
+      if (cachedData) {
+        this.update();
+      }
+    },
+    async setPeriod(days) {
+      if (currentPeriod === days) return;
+      log("log", `Changing period to: ${days} days`);
+      currentPeriod = days;
+      updateTitle();
+      await this.refresh(true);
+    },
+    async refresh(forceRefresh = false) {
+      if (!forceRefresh && cachedData?.fetchTimestamp) {
+        const age = Date.now() - cachedData.fetchTimestamp;
+        const ttl = config.cacheTTL ?? DEFAULT_CONFIG.cacheTTL;
+        if (age < ttl) {
+          log("log", `Using cached data (age: ${Math.round(age / 1e3)}s)`);
+          return;
+        }
+      }
+      log("log", "Refreshing data...");
+      await this.render();
+    },
+    destroy() {
+      log("log", "Destroying chart...");
+      cleanupAutoRefresh();
+      if (chartInstance) {
+        chartInstance.destroy();
+        chartInstance = null;
+      }
+      cachedData = null;
+      isRendered = false;
+    },
+    getChartInstance() {
+      return chartInstance;
+    },
+    getCachedData() {
+      return cachedData;
+    },
+    getState() {
+      return {
+        period: currentPeriod,
+        chartType: currentChartType,
+        vizMode: currentVizMode,
+        theme: currentTheme,
+        isRendered
+      };
+    },
+    exportCSV(filename) {
+      if (!cachedData) {
+        log("warn", "Cannot export: no data available");
+        return;
+      }
+      const defaultFilename = config.exportFilename || `${config.domain}-consumo-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`;
+      const csvContent = generateCSVContent(cachedData);
+      downloadCSV(csvContent, filename || defaultFilename);
+    },
+    setTheme(theme) {
+      if (currentTheme === theme) return;
+      log("log", `Changing theme to: ${theme}`);
+      currentTheme = theme;
+      if (cachedData && chartInstance) {
+        const canvas = validateCanvas();
+        if (canvas) {
+          chartInstance.destroy();
+          const ctx = canvas.getContext("2d");
+          chartInstance = new Chart(ctx, buildChartConfig(cachedData));
+        }
+      }
+    },
+    setIdealRange(range) {
+      const rangeChanged = JSON.stringify(currentIdealRange) !== JSON.stringify(range);
+      if (!rangeChanged) return;
+      if (range) {
+        log("log", `Setting ideal range: ${range.min} - ${range.max}`);
+      } else {
+        log("log", "Clearing ideal range");
+      }
+      currentIdealRange = range;
+      if (cachedData && chartInstance) {
+        const canvas = validateCanvas();
+        if (canvas) {
+          chartInstance.destroy();
+          const ctx = canvas.getContext("2d");
+          chartInstance = new Chart(ctx, buildChartConfig(cachedData));
+        }
+      }
+    },
+    getIdealRange() {
+      return currentIdealRange;
+    }
+  };
+  return instance;
+}
+
+// src/components/Consumption7DaysChart/createConsumptionModal.ts
+var DOMAIN_CONFIG3 = {
+  energy: { name: "Energia", icon: "\u26A1" },
+  water: { name: "\xC1gua", icon: "\u{1F4A7}" },
+  gas: { name: "G\xE1s", icon: "\u{1F525}" },
+  temperature: { name: "Temperatura", icon: "\u{1F321}\uFE0F" }
+};
+function createConsumptionModal(config) {
+  const modalId = `myio-consumption-modal-${Date.now()}`;
+  let modalElement = null;
+  let chartInstance = null;
+  let headerInstance = null;
+  let currentTheme = config.theme ?? "light";
+  let currentChartType = config.defaultChartType ?? "line";
+  let currentVizMode = config.defaultVizMode ?? "total";
+  let isMaximized = false;
+  const domainCfg = DOMAIN_CONFIG3[config.domain] || { name: config.domain, icon: "\u{1F4CA}" };
+  const title = config.title || `${domainCfg.name} - Hist\xF3rico de Consumo`;
+  function getThemeColors2() {
+    return THEME_COLORS[currentTheme];
+  }
+  function renderModal4() {
+    const colors = getThemeColors2();
+    const exportFormats = config.exportFormats || ["csv"];
+    headerInstance = createModalHeader({
+      id: modalId,
+      title,
+      icon: domainCfg.icon,
+      theme: currentTheme,
+      isMaximized,
+      exportFormats,
+      onExport: (format) => {
+        if (config.onExport) {
+          config.onExport(format);
+        } else {
+          if (format === "csv") {
+            chartInstance?.exportCSV();
+          } else {
+            console.warn(`[ConsumptionModal] Export format "${format}" requires custom onExport handler`);
+          }
+        }
+      },
+      onThemeToggle: (theme) => {
+        currentTheme = theme;
+        chartInstance?.setTheme(currentTheme);
+        updateModal();
+      },
+      onMaximize: (maximized) => {
+        isMaximized = maximized;
+        updateModal();
+      },
+      onClose: () => {
+        instance.close();
+      }
+    });
+    return `
+      <div class="myio-consumption-modal-overlay" style="
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        background: rgba(0, 0, 0, 0.5);
+        backdrop-filter: blur(2px);
+        z-index: 99998;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+      ">
+        <div class="myio-consumption-modal-content" style="
+          background: ${colors.chartBackground};
+          border-radius: ${isMaximized ? "0" : "10px"};
+          width: ${isMaximized ? "100%" : "95%"};
+          max-width: ${isMaximized ? "100%" : "1200px"};
+          height: ${isMaximized ? "100%" : "85vh"};
+          display: flex;
+          flex-direction: column;
+          box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+          overflow: hidden;
+        ">
+          <!-- MyIO Premium Header (using ModalHeader component) -->
+          ${headerInstance.render()}
+
+          <!-- Controls Bar -->
+          <div class="myio-consumption-modal-controls" style="
+            display: flex;
+            gap: 16px;
+            padding: 12px 16px;
+            background: ${currentTheme === "dark" ? "#374151" : "#f7f7f7"};
+            border-bottom: 1px solid ${colors.border};
+            align-items: center;
+            flex-wrap: wrap;
+          ">
+            <!-- Viz Mode Tabs -->
+            <div style="display: flex; gap: 2px; background: ${currentTheme === "dark" ? "#4b5563" : "#e5e7eb"}; border-radius: 8px; padding: 2px;">
+              <button id="${modalId}-viz-total" style="
+                padding: 6px 12px;
+                border: none;
+                border-radius: 6px;
+                font-size: 13px;
+                cursor: pointer;
+                transition: all 0.2s;
+                background: ${currentVizMode === "total" ? "#3e1a7d" : "transparent"};
+                color: ${currentVizMode === "total" ? "white" : colors.text};
+              ">Consolidado</button>
+              <button id="${modalId}-viz-separate" style="
+                padding: 6px 12px;
+                border: none;
+                border-radius: 6px;
+                font-size: 13px;
+                cursor: pointer;
+                transition: all 0.2s;
+                background: ${currentVizMode === "separate" ? "#3e1a7d" : "transparent"};
+                color: ${currentVizMode === "separate" ? "white" : colors.text};
+              ">Por Shopping</button>
+            </div>
+
+            <!-- Chart Type Tabs -->
+            <div style="display: flex; gap: 2px; background: ${currentTheme === "dark" ? "#4b5563" : "#e5e7eb"}; border-radius: 8px; padding: 2px;">
+              <button id="${modalId}-type-line" style="
+                padding: 6px 12px;
+                border: none;
+                border-radius: 6px;
+                font-size: 13px;
+                cursor: pointer;
+                transition: all 0.2s;
+                background: ${currentChartType === "line" ? "#3e1a7d" : "transparent"};
+                color: ${currentChartType === "line" ? "white" : colors.text};
+              ">Linhas</button>
+              <button id="${modalId}-type-bar" style="
+                padding: 6px 12px;
+                border: none;
+                border-radius: 6px;
+                font-size: 13px;
+                cursor: pointer;
+                transition: all 0.2s;
+                background: ${currentChartType === "bar" ? "#3e1a7d" : "transparent"};
+                color: ${currentChartType === "bar" ? "white" : colors.text};
+              ">Barras</button>
+            </div>
+          </div>
+
+          <!-- Chart Container -->
+          <div style="
+            flex: 1;
+            padding: 16px;
+            min-height: 0;
+            position: relative;
+            background: ${colors.chartBackground};
+          ">
+            <canvas id="${modalId}-chart" style="width: 100%; height: 100%;"></canvas>
+          </div>
+        </div>
+      </div>
+    `;
+  }
+  function setupListeners() {
+    if (!modalElement) return;
+    headerInstance?.attachListeners();
+    document.getElementById(`${modalId}-viz-total`)?.addEventListener("click", () => {
+      currentVizMode = "total";
+      chartInstance?.setVizMode("total");
+      updateControlStyles();
+    });
+    document.getElementById(`${modalId}-viz-separate`)?.addEventListener("click", () => {
+      currentVizMode = "separate";
+      chartInstance?.setVizMode("separate");
+      updateControlStyles();
+    });
+    document.getElementById(`${modalId}-type-line`)?.addEventListener("click", () => {
+      currentChartType = "line";
+      chartInstance?.setChartType("line");
+      updateControlStyles();
+    });
+    document.getElementById(`${modalId}-type-bar`)?.addEventListener("click", () => {
+      currentChartType = "bar";
+      chartInstance?.setChartType("bar");
+      updateControlStyles();
+    });
+    modalElement.querySelector(".myio-consumption-modal-overlay")?.addEventListener("click", (e) => {
+      if (e.target.classList.contains("myio-consumption-modal-overlay")) {
+        instance.close();
+      }
+    });
+    const handleKeydown = (e) => {
+      if (e.key === "Escape") {
+        instance.close();
+      }
+    };
+    document.addEventListener("keydown", handleKeydown);
+    modalElement.__handleKeydown = handleKeydown;
+  }
+  function updateControlStyles() {
+    const colors = getThemeColors2();
+    const vizTotalBtn = document.getElementById(`${modalId}-viz-total`);
+    const vizSeparateBtn = document.getElementById(`${modalId}-viz-separate`);
+    if (vizTotalBtn) {
+      vizTotalBtn.style.background = currentVizMode === "total" ? "#3e1a7d" : "transparent";
+      vizTotalBtn.style.color = currentVizMode === "total" ? "white" : colors.text;
+    }
+    if (vizSeparateBtn) {
+      vizSeparateBtn.style.background = currentVizMode === "separate" ? "#3e1a7d" : "transparent";
+      vizSeparateBtn.style.color = currentVizMode === "separate" ? "white" : colors.text;
+    }
+    const typeLineBtn = document.getElementById(`${modalId}-type-line`);
+    const typeBarBtn = document.getElementById(`${modalId}-type-bar`);
+    if (typeLineBtn) {
+      typeLineBtn.style.background = currentChartType === "line" ? "#3e1a7d" : "transparent";
+      typeLineBtn.style.color = currentChartType === "line" ? "white" : colors.text;
+    }
+    if (typeBarBtn) {
+      typeBarBtn.style.background = currentChartType === "bar" ? "#3e1a7d" : "transparent";
+      typeBarBtn.style.color = currentChartType === "bar" ? "white" : colors.text;
+    }
+  }
+  function updateModal() {
+    if (!modalElement) return;
+    const cachedData = chartInstance?.getCachedData();
+    headerInstance?.destroy();
+    chartInstance?.destroy();
+    modalElement.innerHTML = renderModal4();
+    setupListeners();
+    if (cachedData) {
+      chartInstance = createConsumption7DaysChart({
+        ...config,
+        containerId: `${modalId}-chart`,
+        theme: currentTheme,
+        defaultChartType: currentChartType,
+        defaultVizMode: currentVizMode
+      });
+      chartInstance.update(cachedData);
+    }
+  }
+  const instance = {
+    async open() {
+      modalElement = document.createElement("div");
+      modalElement.id = modalId;
+      modalElement.innerHTML = renderModal4();
+      const container = config.container || document.body;
+      container.appendChild(modalElement);
+      setupListeners();
+      chartInstance = createConsumption7DaysChart({
+        ...config,
+        containerId: `${modalId}-chart`,
+        theme: currentTheme,
+        defaultChartType: currentChartType,
+        defaultVizMode: currentVizMode
+      });
+      await chartInstance.render();
+    },
+    close() {
+      if (modalElement) {
+        const handleKeydown = modalElement.__handleKeydown;
+        if (handleKeydown) {
+          document.removeEventListener("keydown", handleKeydown);
+        }
+        headerInstance?.destroy();
+        headerInstance = null;
+        chartInstance?.destroy();
+        chartInstance = null;
+        modalElement.remove();
+        modalElement = null;
+        config.onClose?.();
+      }
+    },
+    getChart() {
+      return chartInstance;
+    },
+    destroy() {
+      instance.close();
+    }
+  };
+  return instance;
+}
+
+// src/components/ExportData/index.ts
+var DEFAULT_COLORS3 = {
+  primary: "#3e1a7d",
+  // MyIO purple
+  secondary: "#6b4c9a",
+  // Light purple
+  accent: "#00bcd4",
+  // Cyan accent
+  background: "#ffffff",
+  // White
+  text: "#333333",
+  // Dark gray
+  chartColors: ["#3e1a7d", "#00bcd4", "#4caf50", "#ff9800", "#e91e63", "#9c27b0"]
+};
+var DOMAIN_ICONS = {
+  energy: "\u26A1",
+  // Lightning bolt
+  water: "\u{1F4A7}",
+  // Water drop
+  temperature: "\u{1F321}\uFE0F"
+  // Thermometer
+};
+var DOMAIN_LABELS = {
+  energy: "Energia",
+  water: "\xC1gua",
+  temperature: "Temperatura"
+};
+var DOMAIN_LABELS_EN = {
+  energy: "Energy",
+  water: "Water",
+  temperature: "Temperature"
+};
+var DOMAIN_UNITS = {
+  energy: "kWh",
+  water: "m\xB3",
+  temperature: "\xB0C"
+};
+var CSV_SEPARATORS = {
+  "pt-BR": ";",
+  "en-US": ",",
+  "default": ";"
+};
+function formatDateForFilename(date) {
+  const pad = (n) => n.toString().padStart(2, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}-${pad(date.getHours())}-${pad(date.getMinutes())}-${pad(date.getSeconds())}`;
+}
+function sanitizeFilename(str) {
+  return str.replace(/[<>:"/\\|?*]/g, "").replace(/\s+/g, "_").substring(0, 50);
+}
+function generateFilename(data, config) {
+  const timestamp = formatDateForFilename(/* @__PURE__ */ new Date());
+  const domainLabel = DOMAIN_LABELS_EN[config.domain].toUpperCase();
+  const ext = config.formatExport;
+  let baseName = "export";
+  if ("device" in data && data.device) {
+    const device = data.device;
+    const label = device.label || device.name || "device";
+    const identifier = device.identifier ? `-${device.identifier}` : "";
+    baseName = `${sanitizeFilename(label)}${identifier}`;
+  } else if ("customer" in data && data.customer?.customerName) {
+    baseName = sanitizeFilename(data.customer.customerName);
+  } else if ("groupName" in data) {
+    baseName = sanitizeFilename(data.groupName);
+  }
+  return `${baseName}-${domainLabel}-${timestamp}.${ext}`;
+}
+function normalizeTimestamp(ts) {
+  if (ts instanceof Date) return ts;
+  if (typeof ts === "number") return new Date(ts);
+  return new Date(ts);
+}
+function calculateStats2(dataPoints) {
+  if (dataPoints.length === 0) {
+    return { min: 0, max: 0, average: 0, sum: 0, count: 0 };
+  }
+  const values = dataPoints.map((d) => d.value);
+  const sum = values.reduce((a, b) => a + b, 0);
+  return {
+    min: Math.min(...values),
+    max: Math.max(...values),
+    average: sum / values.length,
+    sum,
+    count: values.length
+  };
+}
+function formatNumber2(value, locale, decimals = 2) {
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  }).format(value);
+}
+function formatDate3(date, locale) {
+  return new Intl.DateTimeFormat(locale, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit"
+  }).format(date);
+}
+function generateCSV(data, config) {
+  const sep = CSV_SEPARATORS[config.locale] || CSV_SEPARATORS["default"];
+  const rows = [];
+  const escapeCSV = (val) => {
+    const str = String(val ?? "");
+    if (str.includes(sep) || str.includes('"') || str.includes("\n")) {
+      return `"${str.replace(/"/g, '""')}"`;
+    }
+    return str;
+  };
+  const formatNumCSV = (val) => {
+    return formatNumber2(val, config.locale);
+  };
+  if ("device" in data && "data" in data && Array.isArray(data.data)) {
+    const deviceData = data;
+    rows.push(["Timestamp", config.domainLabel, `Unit (${config.domainUnit})`]);
+    for (const point of deviceData.data) {
+      const ts = normalizeTimestamp(point.timestamp);
+      rows.push([
+        formatDate3(ts, config.locale),
+        formatNumCSV(point.value),
+        point.unit || config.domainUnit
+      ]);
+    }
+    if (config.includeStats) {
+      const stats = calculateStats2(deviceData.data);
+      rows.push([]);
+      rows.push(["Statistics", "", ""]);
+      rows.push(["Minimum", formatNumCSV(stats.min), config.domainUnit]);
+      rows.push(["Maximum", formatNumCSV(stats.max), config.domainUnit]);
+      rows.push(["Average", formatNumCSV(stats.average), config.domainUnit]);
+      rows.push(["Total", formatNumCSV(stats.sum), config.domainUnit]);
+      rows.push(["Count", String(stats.count), "points"]);
+    }
+  } else if ("devices" in data && Array.isArray(data.devices)) {
+    const compData = data;
+    const deviceHeaders = compData.devices.map(
+      (d) => d.device.label || d.device.name || "Device"
+    );
+    rows.push(["Timestamp", ...deviceHeaders]);
+    const allTimestamps = /* @__PURE__ */ new Set();
+    compData.devices.forEach((d) => {
+      d.data.forEach((point) => {
+        allTimestamps.add(normalizeTimestamp(point.timestamp).getTime());
+      });
+    });
+    const sortedTimestamps = Array.from(allTimestamps).sort((a, b) => a - b);
+    for (const ts of sortedTimestamps) {
+      const row = [formatDate3(new Date(ts), config.locale)];
+      for (const device of compData.devices) {
+        const point = device.data.find(
+          (p) => normalizeTimestamp(p.timestamp).getTime() === ts
+        );
+        row.push(point ? formatNumCSV(point.value) : "");
+      }
+      rows.push(row);
+    }
+  }
+  return rows.map((row) => row.map(escapeCSV).join(sep)).join("\r\n");
+}
+function generateXLSX(data, config) {
+  return generateCSV(data, config);
+}
+function generatePDFContent(data, config) {
+  const { colors, domainIcon, domainLabel, domainUnit, locale, includeStats, includeChart } = config;
+  let deviceLabel = "Export";
+  let customerName = "";
+  let identifier = "";
+  let dataPoints = [];
+  if ("device" in data && "data" in data) {
+    const deviceData = data;
+    deviceLabel = deviceData.device.label || deviceData.device.name || "Device";
+    identifier = deviceData.device.identifier || "";
+    customerName = deviceData.customer?.customerName || "";
+    dataPoints = deviceData.data;
+  }
+  const stats = calculateStats2(dataPoints);
+  const tableRows = dataPoints.slice(0, 100).map((point) => {
+    const ts = normalizeTimestamp(point.timestamp);
+    return `
+      <tr>
+        <td style="padding: 8px; border-bottom: 1px solid #eee;">${formatDate3(ts, locale)}</td>
+        <td style="padding: 8px; border-bottom: 1px solid #eee; text-align: right;">${formatNumber2(point.value, locale)}</td>
+        <td style="padding: 8px; border-bottom: 1px solid #eee;">${point.unit || domainUnit}</td>
+      </tr>
+    `;
+  }).join("");
+  const statsSection = includeStats ? `
+    <div style="margin-top: 24px; padding: 16px; background: #f5f5f5; border-radius: 8px;">
+      <h3 style="margin: 0 0 12px 0; color: ${colors.primary};">Statistics</h3>
+      <table style="width: 100%;">
+        <tr>
+          <td><strong>Minimum:</strong></td>
+          <td>${formatNumber2(stats.min, locale)} ${domainUnit}</td>
+          <td><strong>Maximum:</strong></td>
+          <td>${formatNumber2(stats.max, locale)} ${domainUnit}</td>
+        </tr>
+        <tr>
+          <td><strong>Average:</strong></td>
+          <td>${formatNumber2(stats.average, locale)} ${domainUnit}</td>
+          <td><strong>Total:</strong></td>
+          <td>${formatNumber2(stats.sum, locale)} ${domainUnit}</td>
+        </tr>
+      </table>
+    </div>
+  ` : "";
+  return `
+    <!DOCTYPE html>
+    <html>
+    <head>
+      <meta charset="UTF-8">
+      <title>${deviceLabel} - ${domainLabel} Report</title>
+      <style>
+        body {
+          font-family: 'Roboto', Arial, sans-serif;
+          margin: 0;
+          padding: 24px;
+          color: ${colors.text};
+          background: ${colors.background};
+        }
+        .header {
+          background: ${colors.primary};
+          color: white;
+          padding: 20px;
+          border-radius: 8px;
+          margin-bottom: 24px;
+        }
+        .header h1 {
+          margin: 0;
+          font-size: 24px;
+        }
+        .header .subtitle {
+          opacity: 0.9;
+          margin-top: 8px;
+        }
+        .device-info {
+          display: flex;
+          gap: 16px;
+          margin-bottom: 16px;
+          padding: 12px;
+          background: #f5f5f5;
+          border-radius: 8px;
+        }
+        .device-info span {
+          padding: 4px 12px;
+          background: ${colors.secondary};
+          color: white;
+          border-radius: 4px;
+          font-size: 14px;
+        }
+        table {
+          width: 100%;
+          border-collapse: collapse;
+        }
+        th {
+          background: ${colors.primary};
+          color: white;
+          padding: 12px 8px;
+          text-align: left;
+        }
+        th:nth-child(2) {
+          text-align: right;
+        }
+        .footer {
+          margin-top: 24px;
+          padding-top: 16px;
+          border-top: 1px solid #eee;
+          text-align: center;
+          font-size: 12px;
+          color: #999;
+        }
+        @media print {
+          body { padding: 0; }
+          .header { border-radius: 0; }
+        }
+      </style>
+    </head>
+    <body>
+      <div class="header">
+        <h1>${domainIcon} ${deviceLabel}</h1>
+        <div class="subtitle">${domainLabel} Report - Generated ${formatDate3(/* @__PURE__ */ new Date(), locale)}</div>
+      </div>
+
+      ${customerName ? `<div class="customer-name" style="margin-bottom: 16px; font-size: 18px;"><strong>Customer:</strong> ${customerName}</div>` : ""}
+
+      ${identifier ? `
+        <div class="device-info">
+          <span>ID: ${identifier}</span>
+          <span>Domain: ${domainLabel}</span>
+          <span>Unit: ${domainUnit}</span>
+        </div>
+      ` : ""}
+
+      <table>
+        <thead>
+          <tr>
+            <th>Timestamp</th>
+            <th>${domainLabel} (${domainUnit})</th>
+            <th>Unit</th>
+          </tr>
+        </thead>
+        <tbody>
+          ${tableRows}
+          ${dataPoints.length > 100 ? `<tr><td colspan="3" style="text-align: center; padding: 16px; color: #999;">... and ${dataPoints.length - 100} more rows</td></tr>` : ""}
+        </tbody>
+      </table>
+
+      ${statsSection}
+
+      <div class="footer">
+        <p>${config.footerText || "Generated by MyIO Platform"}</p>
+      </div>
+    </body>
+    </html>
+  `;
+}
+function buildTemplateExport(params) {
+  const {
+    domain,
+    formatExport,
+    typeExport,
+    colorsPallet,
+    locale = "pt-BR",
+    includeChart = formatExport === "pdf",
+    includeStats = true,
+    headerText,
+    footerText
+  } = params;
+  const colors = {
+    ...DEFAULT_COLORS3,
+    ...colorsPallet,
+    chartColors: colorsPallet?.chartColors || DEFAULT_COLORS3.chartColors
+  };
+  return {
+    domain,
+    formatExport,
+    typeExport,
+    colors,
+    locale,
+    includeChart,
+    includeStats,
+    headerText: headerText || `${DOMAIN_LABELS[domain]} Report`,
+    footerText: footerText || "Generated by MyIO Platform",
+    domainIcon: DOMAIN_ICONS[domain],
+    domainLabel: DOMAIN_LABELS[domain],
+    domainUnit: DOMAIN_UNITS[domain]
+  };
+}
+function myioExportData(data, config, options) {
+  const filename = generateFilename(data, config);
+  let allDataPoints = [];
+  if ("data" in data && Array.isArray(data.data)) {
+    allDataPoints = data.data;
+  } else if ("devices" in data && Array.isArray(data.devices)) {
+    allDataPoints = data.devices.flatMap((d) => d.data);
+  }
+  const stats = calculateStats2(allDataPoints);
+  const instance = {
+    async export() {
+      try {
+        options?.onProgress?.(10, "Generating content...");
+        let content;
+        let mimeType;
+        let finalFilename = filename;
+        switch (config.formatExport) {
+          case "csv":
+            content = generateCSV(data, config);
+            mimeType = "text/csv;charset=utf-8;";
+            break;
+          case "xlsx":
+            content = generateXLSX(data, config);
+            mimeType = "text/csv;charset=utf-8;";
+            finalFilename = filename.replace(".xlsx", ".csv");
+            break;
+          case "pdf":
+            content = generatePDFContent(data, config);
+            mimeType = "text/html;charset=utf-8;";
+            finalFilename = filename.replace(".pdf", ".html");
+            break;
+          default:
+            throw new Error(`Unsupported format: ${config.formatExport}`);
+        }
+        options?.onProgress?.(80, "Creating file...");
+        const bom = config.formatExport === "csv" ? "\uFEFF" : "";
+        const blob = new Blob([bom + content], { type: mimeType });
+        options?.onProgress?.(100, "Export complete");
+        return {
+          success: true,
+          filename: finalFilename,
+          blob,
+          dataUrl: URL.createObjectURL(blob)
+        };
+      } catch (error) {
+        return {
+          success: false,
+          filename,
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    },
+    async download() {
+      const result = await this.export();
+      if (!result.success || !result.blob) {
+        console.error("Export failed:", result.error);
+        return;
+      }
+      const link = document.createElement("a");
+      link.href = URL.createObjectURL(result.blob);
+      link.download = result.filename;
+      link.style.display = "none";
+      document.body.appendChild(link);
+      link.click();
+      document.body.removeChild(link);
+      URL.revokeObjectURL(link.href);
+    },
+    async preview() {
+      if (config.formatExport !== "pdf") {
+        return null;
+      }
+      const result = await this.export();
+      return result.dataUrl || null;
+    },
+    getStats() {
+      return stats;
+    },
+    getFilename() {
+      return filename;
+    }
+  };
+  if (options?.autoDownload) {
+    instance.download();
+  }
+  return instance;
+}
+var EXPORT_DEFAULT_COLORS = DEFAULT_COLORS3;
+var EXPORT_DOMAIN_ICONS = DOMAIN_ICONS;
+var EXPORT_DOMAIN_LABELS = DOMAIN_LABELS;
+var EXPORT_DOMAIN_UNITS = DOMAIN_UNITS;
 export {
   CHART_COLORS,
+  DEFAULT_COLORS as CONSUMPTION_CHART_COLORS,
+  DEFAULT_CONFIG as CONSUMPTION_CHART_DEFAULTS,
+  THEME_COLORS as CONSUMPTION_THEME_COLORS,
   ConnectionStatusType,
   DEFAULT_CLAMP_RANGE,
   DeviceStatusType,
+  EXPORT_DEFAULT_COLORS,
+  EXPORT_DOMAIN_ICONS,
+  EXPORT_DOMAIN_LABELS,
+  EXPORT_DOMAIN_UNITS,
   MyIOChartModal,
   MyIODraggableCard,
   MyIOSelectionStore,
@@ -22475,11 +24295,13 @@ export {
   averageByDay,
   buildListItemsThingsboardByUniqueDatasource,
   buildMyioIngestionAuth,
+  buildTemplateExport,
   buildWaterReportCSV,
   buildWaterStoresCSV,
   calcDeltaPercent,
   calculateDeviceStatus,
   calculateDeviceStatusWithRanges,
+  calculateStats2 as calculateExportStats,
   calculateStats,
   clampTemperature,
   classify,
@@ -22487,8 +24309,11 @@ export {
   classifyWaterLabels,
   clearAllAuthCaches,
   connectionStatusIcons,
+  createConsumption7DaysChart,
+  createConsumptionModal,
   createDateRangePicker2 as createDateRangePicker,
   createInputDateRangePickerInsideDIV,
+  createModalHeader,
   decodePayload,
   decodePayloadBase64Xor,
   detectDeviceType,
@@ -22502,6 +24327,7 @@ export {
   fetchThingsboardCustomerAttrsFromStorage,
   fetchThingsboardCustomerServerScopeAttrs,
   findValue,
+  findValueWithDefault,
   fmtPerc,
   fmtPerc2 as fmtPercLegacy,
   formatAllInSameUnit,
@@ -22509,18 +24335,24 @@ export {
   formatDateForInput,
   formatDateToYMD,
   formatDateWithTimezoneOffset,
+  formatDuration,
   formatEnergy,
   formatNumberReadable,
+  formatRelativeTime,
   formatTankHeadFromCm,
   formatTemperature2 as formatTemperature,
+  formatWater,
   formatWaterByGroup,
   formatWaterVolumeM3,
+  formatarDuracao,
+  generateFilename as generateExportFilename,
   getAuthCacheStats,
   getAvailableContexts,
   getConnectionStatusIcon,
   getDateRangeArray,
   getDeviceStatusIcon,
   getDeviceStatusInfo,
+  getModalHeaderStyles,
   getSaoPauloISOString,
   getSaoPauloISOStringFixed,
   getValueByDatakey,
@@ -22532,8 +24364,10 @@ export {
   isValidConnectionStatus,
   isValidDeviceStatus,
   isWaterCategory,
+  mapConnectionStatus,
   mapDeviceStatusToCardStatus,
   mapDeviceToConnectionStatus,
+  myioExportData,
   normalizeRecipients,
   numbers_exports as numbers,
   openDashboardPopup,