@c8y/ngx-components 1021.11.1 → 1021.21.0

package/fesm2022/c8y-ngx-components-datapoints-export-selector.mjs

@@ -0,0 +1,1928 @@
+import * as i0 from '@angular/core';
+import { Injectable, Component, Input, EventEmitter, Output, InjectionToken, Inject, ViewChild, HostListener } from '@angular/core';
+import * as i3 from '@angular/platform-browser';
+import * as i2 from '@c8y/client';
+import * as i1 from '@c8y/ngx-components';
+import { gettext, AGGREGATION_VALUES, CoreModule, AGGREGATION_LABELS, AGGREGATION_VALUES_ARR, CommonModule, ModalModule } from '@c8y/ngx-components';
+import * as i4 from '@ngx-translate/core';
+import JSZip from 'jszip';
+import * as i2$1 from '@angular/common';
+import { KeyValuePipe } from '@angular/common';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i3$2 from '@angular/forms';
+import { FormsModule, FormControl, ReactiveFormsModule } from '@angular/forms';
+import saveAs from 'file-saver';
+import { Subject, debounceTime, merge, takeUntil } from 'rxjs';
+import { TimeSpanInMs } from '@c8y/ngx-components/interval-picker';
+import { A11yModule } from '@angular/cdk/a11y';
+import * as i3$1 from 'ngx-bootstrap/popover';
+import { PopoverModule } from 'ngx-bootstrap/popover';
+import { isNil, isEmpty, isNumber } from 'lodash-es';
+import * as i1$1 from 'ngx-bootstrap/modal';
+import * as i3$3 from 'ngx-bootstrap/tooltip';
+import { TooltipModule } from 'ngx-bootstrap/tooltip';
+
+const HAS_ERROR = 'has-error';
+const MEASUREMENTS_PREVIEW_ITEMS_LIMIT = 5;
+const SERIES_DATA_MERGED_FILE_NAME = 'seriesDataMergedFileName';
+const EXPORT_MODE_LABELS = {
+    FULL: gettext('Full`export type`'),
+    COMPACT: gettext('Compact`export type`')
+};
+/**
+ * Each export type is based on a different API:
+ * - COMPACT - series
+ * - FULL - measurements
+ * All differences between export modes:
+ *  Compact:
+ *    Processes up to 5,000 records per data point, or up to the data retention limit (API limit)
+ *    Creates a single merged file containing all the data
+ *    Provides minimum and maximum values (API feature)
+ *    Preview is not available
+ *    Supports optional data aggregation (API feature)
+ *  Full:
+ *    Processes up to 1,000,000 records per data point, or up to the data retention limit (API limit)
+ *    For exports exceeding 50,000 records, data will be sent via email
+ *    Creates a compressed ZIP file containing separate data files for each selected data point
+ *    Preview is available
+ *    Does not support data aggregation
+ */
+const EXPORT_MODE_VALUES = {
+    full: 'FULL',
+    compact: 'COMPACT'
+};
+const FILE_COMPRESSION_TYPES_VALUES = {
+    store: 'STORE',
+    deflate: 'DEFLATE'
+};
+const TIME_RANGE_INTERVAL_UNITS_VALUES = {
+    minutes: 'minutes',
+    hours: 'hours',
+    days: 'days',
+    weeks: 'weeks',
+    months: 'months',
+    custom: 'custom'
+};
+
+class UtilsService {
+    transformDataStructure(data) {
+        const result = {};
+        data.forEach(sourceItem => {
+            const { source: sourceId, data: sourceData } = sourceItem;
+            result[sourceId] = {};
+            sourceData.series.forEach((seriesInfo, index) => {
+                const { type, name, unit } = seriesInfo;
+                /**
+                 * Unique key to distinguish between different series from same source,
+                 * e.g.: c8y_Acceleration.accelerationX, c8y_Acceleration.accelerationY, c8y_Acceleration.accelerationZ
+                 */
+                const seriesKey = `${type}.${name}`;
+                result[sourceId][seriesKey] = {
+                    values: {},
+                    seriesDetails: { name, unit, type }
+                };
+                let hasValues = false;
+                Object.entries(sourceData.values).forEach(([timestamp, measurements]) => {
+                    if (!measurements) {
+                        return;
+                    }
+                    const measurement = measurements[index];
+                    if (measurement !== null && measurement !== undefined) {
+                        result[sourceId][seriesKey].values[timestamp] = measurement;
+                        hasValues = true;
+                    }
+                });
+                if (!hasValues) {
+                    result[sourceId][seriesKey].values = null;
+                }
+            });
+        });
+        return result;
+    }
+    /**
+     * Formats a date range into a specific string format, handling UTC dates correctly.
+     *
+     * @param fromDate - The start date in ISO format (e.g., "2023-12-04T12:40:00.000Z")
+     * @param toDate - The end date in ISO format (e.g., "2023-12-06T23:50:00.000Z")
+     * @returns A string representing the date range in the format "ddmmmyyhhmm-ddmmmyyhhmm"
+     *          where d=day, m=month, y=year, h=hour, m=minute
+     *
+     * Example
+     * ```typescript
+     * const fromDate = "2023-12-04T12:40:00.000Z";
+     * const toDate = "2023-12-06T23:50:00.000Z";
+     * const formattedRange = getFormattedDateRange(fromDate, toDate);
+     * console.log(formattedRange); // Output: "04dec231240-06dec232350"
+     * ```
+     */
+    getFormattedDateRange(fromDate, toDate) {
+        const formatDate = (dateString) => {
+            const date = new Date(dateString);
+            if (isNaN(date.getTime())) {
+                throw new Error(`Invalid date string: ${dateString}`);
+            }
+            const day = date.getUTCDate().toString().padStart(2, '0');
+            const month = date.toLocaleString('en', { month: 'short', timeZone: 'UTC' }).toLowerCase();
+            const hours = date.getUTCHours().toString().padStart(2, '0');
+            const minutes = date.getUTCMinutes().toString().padStart(2, '0');
+            const seconds = date.getUTCSeconds().toString().padStart(2, '0');
+            return `${day}${month}${hours}${minutes}${seconds}`;
+        };
+        return `${formatDate(fromDate)}-${formatDate(toDate)}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: UtilsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: UtilsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: UtilsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class DataFetchingService {
+    constructor(alertService, measurementService, sanitizer, translateService, utilsService) {
+        this.alertService = alertService;
+        this.measurementService = measurementService;
+        this.sanitizer = sanitizer;
+        this.translateService = translateService;
+        this.utilsService = utilsService;
+    }
+    /**
+     * Checks if any of measurements requests may exceeded the limit,
+     * after which the export data is processed by the backend and the generated CSV/Excel file is sent by email.
+     *
+     * The threshold is set to 50_000 records in application's core properties (export.data.synchronous.limit).
+     *
+     * @param exportConfig - The export configuration.
+     * @returns A promise that returns an array of objects representing datapoints files that will be sent by email.
+     */
+    async getDatapointsExceedingLimit(exportConfig) {
+        const backendProcessingLimit = 50_000;
+        const promises = exportConfig.datapointDetails.map(async (details) => {
+            try {
+                const filter = {
+                    dateFrom: exportConfig.dateFrom,
+                    dateTo: exportConfig.dateTo,
+                    pageSize: 1,
+                    source: details.source,
+                    valueFragmentSeries: details.valueFragmentSeries,
+                    valueFragmentType: details.valueFragmentType,
+                    withTotalElements: true
+                };
+                const response = await this.measurementService.list(filter);
+                if (response?.paging?.totalElements > backendProcessingLimit) {
+                    return {
+                        datapointDetail: {
+                            source: details.source,
+                            valueFragmentSeries: details.valueFragmentSeries,
+                            valueFragmentType: details.valueFragmentType
+                        },
+                        totalElements: response.paging.totalElements
+                    };
+                }
+                else {
+                    return null;
+                }
+            }
+            catch (error) {
+                this.alertService.addServerFailure(error);
+            }
+        });
+        const results = await Promise.all(promises);
+        const datapointsExceedingLimit = results.filter(result => result !== null);
+        return datapointsExceedingLimit;
+    }
+    /**
+     * Retrieves the message to be displayed when the limit of datapoints is exceeded during file export.
+     *
+     * @param hasNoExportableData - Indicates if there is no exportable data because the date range of all selected datapoints exceeds 1,000,000 records.
+     * @param emailDeliverableCount - The number of datapoint exports that exceed the limit, will be proceeded by the backend and sent by email.
+     * @param browserDownloadableCount - The number of datapoint exports that can be downloaded directly.
+     * @param skippedDatapointCount - The number of datapoint exports skipped due to exceeding the measurements API limit of 1,000,000 records.
+     * @param totalDatapointsSelectedForExportCount - Total number of datapoint selected for exports.
+     * @returns The message that can be injected.
+     */
+    getLimitExceededMessage(hasNoExportableData, emailDeliverableCount, browserDownloadableCount, nonRetrievableCount, totalDatapointsSelectedForExportCount) {
+        if (hasNoExportableData) {
+            const message = this.translateService.instant(gettext(`The data for selected datapoint(s) exceed 1,000,000 records, which is the limit for backend processing. To export this data, please reduce the date range.`));
+            return message;
+        }
+        const message = this.translateService.instant(gettext(`After clicking "Download":<br>
+        <ul>
+          <li><strong>{{$browserDownloadableCount}}</strong> datapoint(s) exports will be downloaded directly within one file: <em>exported_[csv/excel].zip</em></li>
+          <li><strong>{{$emailDeliverableCount}}</strong> datapoint(s) exports require further processing. The files will be sent to you via separate emails once completed, which may take some time.</li>
+          <li><strong>{{$nonRetrievableCount}}</strong> datapoint(s) exports exceeded 1,000,000 records, which is the limit for backend processing. To export these data, please reduce the date range. Otherwise, the data will neither be downloaded nor sent via email.</li>
+        </ul>
+        <p>The total number of data points that can be exported is: <strong>{{$totalExportableDatapointsCount}} out of {{$totalDatapointsSelectedForExportCount}}</strong>.
+        <p><strong>Note:</strong> The file name convention of files within zip file is: <code>[source]_[fragment_series].[csv/xls]</code></p>`), {
+            $browserDownloadableCount: browserDownloadableCount,
+            $emailDeliverableCount: emailDeliverableCount,
+            $nonRetrievableCount: nonRetrievableCount,
+            $totalDatapointsSelectedForExportCount: totalDatapointsSelectedForExportCount,
+            $totalExportableDatapointsCount: browserDownloadableCount + emailDeliverableCount
+        });
+        const trimmedMessage = this.removeZeroCountListItems(message, [
+            browserDownloadableCount,
+            emailDeliverableCount,
+            nonRetrievableCount
+        ]);
+        return trimmedMessage;
+    }
+    /**
+     * Displays an information alert about sending data via email.
+     *
+     * Only measurements API can send files via email.
+     *
+     * @param fileType - The type of file to be sent.
+     * @param datapointsExceedingLimit - The array of datapoints exceeding the limit.
+     */
+    showSendViaEmailInfoAlert(fileType, datapointsExceedingLimit) {
+        const messageTemplate = this.translateService.instant(gettext(`You will get {{$fileTypeText}} file(s) for {{$count}} series via email.`), { $count: datapointsExceedingLimit.length, $fileTypeText: fileType });
+        const formattedList = datapointsExceedingLimit
+            .map(datapoint => `• ${datapoint.datapointDetail.source}_${datapoint.datapointDetail.valueFragmentType}_${datapoint.datapointDetail.valueFragmentSeries}`)
+            .join('\n');
+        this.alertService.info(messageTemplate, formattedList);
+    }
+    async fetchMeasurementDataFilesAndPairWithSourceDetails(acceptFileType, exportConfig) {
+        const measurementFileConfig = {
+            exportConfig,
+            acceptFileType
+        };
+        const filePromises = exportConfig.datapointDetails.map(details => this.fetchAndProcessMeasurementFile(details, measurementFileConfig));
+        return Promise.all(filePromises);
+    }
+    async fetchAndProcessMeasurementFile(details, measurementFileConfig) {
+        const filter = this.prepareMeasurementsFilter(details, measurementFileConfig.exportConfig);
+        const header = { accept: measurementFileConfig.acceptFileType };
+        try {
+            const measurementFileResponse = await this.measurementService.getMeasurementsFile(filter, header);
+            // If the status is 200, then the file is in the response.
+            // If the status is 202, then the file is being processed by the backend and will be sent by email.
+            if (measurementFileResponse.status === 200) {
+                return this.mergeMeasurementsWithItsSourceDetails(details, measurementFileResponse);
+            }
+        }
+        catch (error) {
+            this.alertService.addServerFailure(error);
+        }
+    }
+    async mergeMeasurementsWithItsSourceDetails(details, measurementFile) {
+        return {
+            source: details.source,
+            valueFragmentSeries: details.valueFragmentSeries,
+            valueFragmentType: details.valueFragmentType,
+            fetchedMeasurementsBlobFile: await measurementFile.blob()
+        };
+    }
+    async fetchAndPrepareDataToExport(exportConfig, isMeasurement) {
+        return isMeasurement
+            ? await this.fetchAndPrepareMeasurementDataToExportForPreview(exportConfig)
+            : await this.fetchAndPrepareSeriesDataToExport(exportConfig);
+    }
+    async getSourcesWithPermissionsToRead(datapointDetails) {
+        const dateFrom = new Date();
+        const dateTo = new Date(dateFrom);
+        const fetchedDataPromises = datapointDetails.map(async (datapoint) => {
+            const rawFilter = {
+                dateFrom,
+                dateTo,
+                source: datapoint.source
+            };
+            try {
+                const { res } = await this.fetchSeriesData(rawFilter);
+                if (res?.status === 200) {
+                    return datapoint.source;
+                }
+                return null;
+            }
+            catch (error) {
+                // If an error occurs during fetch, return null to prevent promise rejection
+                return null;
+            }
+        });
+        const fetchedSources = await Promise.all(fetchedDataPromises);
+        return fetchedSources.filter((source) => source !== null);
+    }
+    /**
+     * Fetches and prepares measurement data for preview.
+     *
+     * Empty DataToExport object can be returned, because unlike series data,
+     * measurement data is not further processed besides showing only in the preview.
+     * CSV/Excel files are generated by the backend for measurements.
+     *
+     * @param exportConfig - The export configuration.
+     * @returns A promise that resolves to an array of DataToExport objects or null when no data is fetched.
+     */
+    async fetchAndPrepareMeasurementDataToExportForPreview(exportConfig) {
+        const dataToExportPromises = exportConfig.datapointDetails.map(async (details) => {
+            const fetchedMeasurementData = await this.fetchMeasurementDataForPreview(details, exportConfig);
+            if (fetchedMeasurementData?.data?.length) {
+                return this.processMeasurementDataForPreview(details, fetchedMeasurementData.data);
+            }
+            return null;
+        });
+        return await Promise.all(dataToExportPromises);
+    }
+    async fetchMeasurementDataForPreview(details, exportConfig) {
+        let measurements;
+        const filter = this.prepareMeasurementsFilter(details, exportConfig, MEASUREMENTS_PREVIEW_ITEMS_LIMIT);
+        try {
+            // TODO: consider adding a cache mechanism -> MTM-60289
+            // When user switches between report types, and rest of the settings are the same, then the data should not be fetched again?
+            measurements = await this.measurementService.list(filter);
+        }
+        catch (error) {
+            this.alertService.addServerFailure(error);
+        }
+        return measurements;
+    }
+    prepareMeasurementsFilter(details, exportConfig, pageSize) {
+        const filter = {
+            // Round the 'from' time to the previous full minute.
+            dateFrom: this.adjustDate(exportConfig.dateFrom, -1),
+            // Round the 'to' time to the nearest full minute.
+            dateTo: this.adjustDate(exportConfig.dateTo, 1),
+            source: details.source,
+            valueFragmentSeries: details.valueFragmentSeries,
+            valueFragmentType: details.valueFragmentType
+        };
+        if (pageSize) {
+            filter.pageSize = pageSize;
+        }
+        return filter;
+    }
+    processMeasurementDataForPreview(details, data) {
+        const unit = data[0][details.valueFragmentType][details.valueFragmentSeries]?.unit || '';
+        const values = {};
+        data.forEach(measurement => {
+            values[measurement.time] =
+                measurement[details.valueFragmentType][details.valueFragmentSeries].value;
+        });
+        return { ...details, unit, timeValueMap: values };
+    }
+    async fetchAndPrepareSeriesDataToExport(exportConfig) {
+        const datapointsValuesDataMap = this.groupSeriesByDeviceId(exportConfig.datapointDetails);
+        const fetchedDataPromises = Array.from(datapointsValuesDataMap).map(async ([source, series]) => {
+            const { dateFrom, dateTo, aggregation } = exportConfig;
+            const rawFilter = {
+                dateFrom,
+                dateTo,
+                source,
+                series,
+                aggregationType: aggregation
+            };
+            const { data } = await this.fetchSeriesData(rawFilter);
+            return { source, data };
+        });
+        const fetchedDataGroupedBySource = await Promise.all(fetchedDataPromises);
+        return this.processSeriesData(exportConfig.datapointDetails, fetchedDataGroupedBySource);
+    }
+    /**
+     * Returns a map of active data points device IDs with their corresponding series.
+     *
+     * Example output:
+     * ```typescript
+     * new Map([
+     *   ['844657202', ['c8y_Temperature.T']],
+     *   ['32666427', ['c8y_Battery.Battery']]
+     * ]);
+     * ```
+     * @param datapointDetails - An array of data points details.
+     * @returns A map where the key is the data point ID and the value is an array of data point series.
+     */
+    groupSeriesByDeviceId(datapointDetails) {
+        return datapointDetails.reduce((map, { valueFragmentType, valueFragmentSeries, source }) => {
+            const value = `${valueFragmentType}.${valueFragmentSeries}`;
+            const existingValue = map.get(source) ?? [];
+            map.set(source, [...existingValue, value]);
+            return map;
+        }, new Map());
+    }
+    async fetchSeriesData(rawFilter) {
+        let seriesData;
+        const filter = this.prepareSeriesFilter({
+            dateFrom: rawFilter.dateFrom,
+            dateTo: rawFilter.dateTo,
+            source: rawFilter.source,
+            series: rawFilter.series,
+            aggregationType: rawFilter.aggregationType
+        });
+        try {
+            // TODO: consider adding a cache mechanism -> MTM-60289
+            // When user switches between report types, and rest of the settings are the same, then the data should not be fetched again?
+            seriesData = await this.measurementService.listSeries(filter);
+        }
+        catch (error) {
+            this.alertService.addServerFailure(error);
+        }
+        return seriesData;
+    }
+    prepareSeriesFilter(filters) {
+        const { dateFrom, dateTo, source, series, aggregationType } = filters;
+        // Round the 'from' time to the previous full minute.
+        const from = this.adjustDate(dateFrom, -1);
+        // Round the 'to' time to the nearest full minute.
+        const to = this.adjustDate(dateTo, 1);
+        const filter = {
+            dateFrom: from,
+            dateTo: to,
+            source: source,
+            revert: true
+        };
+        // The 'NONE' aggregation type is not handled by a backend, so even when is selected, it is not passed as a filter parameter.
+        if (aggregationType && aggregationType !== AGGREGATION_VALUES.none) {
+            filter.aggregationType = aggregationType;
+        }
+        // TODO: it is a temporal workaround for a bug in the backend,
+        // where the series with more than one dot are impossible to retrieve:
+        // https://cumulocity.atlassian.net/browse/MTM-59277
+        if (series) {
+            const hasMoreThanOneDot = series.some(s => s.split('.').length > 2);
+            if (!hasMoreThanOneDot) {
+                filter.series = series;
+            }
+        }
+        return filter;
+    }
+    /**
+     * Processes the fetched series data and prepares it for export.
+     *
+     * @param datapointDetails - An array of data point details.
+     * @param fetchedDataMap - A map of fetched series data grouped by source.
+     * @returns An array of DataToExport objects.
+     */
+    processSeriesData(datapointDetails, fetchedDataMap) {
+        const valuesGroupedBySource = this.utilsService.transformDataStructure(fetchedDataMap);
+        return datapointDetails.map((details) => {
+            let unit;
+            let data;
+            /**
+             * Unique key to distinguish between different series from same source,
+             * e.g.: c8y_Acceleration.accelerationX, c8y_Acceleration.accelerationY, c8y_Acceleration.accelerationZ
+             */
+            const seriesKey = `${details.valueFragmentType}.${details.valueFragmentSeries}`;
+            if (valuesGroupedBySource[details.source][seriesKey]) {
+                unit = valuesGroupedBySource[details.source][seriesKey].seriesDetails.unit;
+                data = valuesGroupedBySource[details.source][seriesKey].values;
+            }
+            return {
+                ...details,
+                unit,
+                timeValueMap: data
+            };
+        });
+    }
+    /**
+     * Adjusts the given date by adding the specified number of minutes and setting seconds to 0.
+     *
+     * @param date - The date to be adjusted in string format.
+     * @param minutes - The number of minutes to add to the date.
+     * @returns The adjusted date in the format 'YYYY-MM-DDTHH:mm:ss+HH:MM'.
+     */
+    adjustDate(date, minutes) {
+        const dateTime = new Date(date);
+        dateTime.setMinutes(dateTime.getMinutes() + minutes);
+        dateTime.setSeconds(0);
+        const offset = -dateTime.getTimezoneOffset();
+        const offsetSign = offset >= 0 ? '+' : '-';
+        const pad = (num) => (num < 10 ? '0' + num : num.toString());
+        const offsetHours = pad(Math.floor(Math.abs(offset) / 60));
+        const offsetMinutes = pad(Math.abs(offset) % 60);
+        const year = dateTime.getFullYear();
+        const month = pad(dateTime.getMonth() + 1);
+        const day = pad(dateTime.getDate());
+        const hours = pad(dateTime.getHours());
+        const minutesString = pad(dateTime.getMinutes());
+        const seconds = '00';
+        return `${year}-${month}-${day}T${hours}:${minutesString}:${seconds}${offsetSign}${offsetHours}:${offsetMinutes}`;
+    }
+    /**
+     * Trims the given HTML message by removing list items that correspond to zero counts.
+     *
+     * @param message - The HTML string containing the message with list items.
+     * @param counts - An array of number values corresponding to each list item.
+     * @param countToTrim - A count that will be trimmed with corresponding list item.
+     * @returns A trimmed HTML string with list items removed where the corresponding count is zero.
+     *
+     * Example:
+     * ```typescript
+     * const message = '<ul><li>Item 1</li><li>Item 2</li><li>Item 3</li></ul>';
+     * const counts = [1, 0, 2];
+     * const trimmedMessage = this.removeZeroCountListItems(message, counts);
+     * // Result: '<ul><li>Item 1</li><li>Item 3</li></ul>'
+     * ```
+     */
+    removeZeroCountListItems(message, counts, countToTrim = 0) {
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(message, 'text/html');
+        const listItems = doc.querySelectorAll('ul li');
+        listItems.forEach((item, index) => {
+            if (counts[index] === countToTrim) {
+                item.remove();
+            }
+        });
+        return doc.body.innerHTML;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DataFetchingService, deps: [{ token: i1.AlertService }, { token: i2.MeasurementService }, { token: i3.DomSanitizer }, { token: i4.TranslateService }, { token: UtilsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DataFetchingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DataFetchingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AlertService }, { type: i2.MeasurementService }, { type: i3.DomSanitizer }, { type: i4.TranslateService }, { type: UtilsService }] });
+
+class DatapointsExportSelectorFileExporterService {
+    constructor(aggregationService, alertService, datapointsExportSelectorDataProcessingService, translateService) {
+        this.aggregationService = aggregationService;
+        this.alertService = alertService;
+        this.datapointsExportSelectorDataProcessingService = datapointsExportSelectorDataProcessingService;
+        this.translateService = translateService;
+    }
+    /**
+     * Determines the interval between two dates.
+     *
+     * @param dateFrom - The starting date in ISO 8601 string format.
+     * @param dateTo - The ending date in ISO 8601 string format.
+     * @returns The time range interval unit.
+     */
+    determineInterval(dateFrom, dateTo) {
+        const from = new Date(dateFrom);
+        const to = new Date(dateTo);
+        const differenceInMilliseconds = to.getTime() - from.getTime();
+        const intervals = [
+            { value: TimeSpanInMs.MINUTE, label: TIME_RANGE_INTERVAL_UNITS_VALUES.minutes }, // milliseconds in one minute
+            { value: TimeSpanInMs.HOUR, label: TIME_RANGE_INTERVAL_UNITS_VALUES.hours }, // milliseconds in one hour
+            { value: TimeSpanInMs.DAY, label: TIME_RANGE_INTERVAL_UNITS_VALUES.days }, // milliseconds in one day
+            { value: TimeSpanInMs.WEEK, label: TIME_RANGE_INTERVAL_UNITS_VALUES.weeks }, // milliseconds in one week
+            { value: TimeSpanInMs.MONTH, label: TIME_RANGE_INTERVAL_UNITS_VALUES.months } // approximation for milliseconds in one month
+        ];
+        for (let i = 0; i < intervals.length; i++) {
+            if (differenceInMilliseconds <= intervals[i].value) {
+                return intervals[i].label;
+            }
+        }
+        return TIME_RANGE_INTERVAL_UNITS_VALUES.custom;
+    }
+    /**
+     * Updates the disabled state of aggregation options based on the current value of the time interval form control.
+     *
+     * This method:
+     * - Retrieves the current date range from the form controls.
+     * - Determines the current time interval based on the date range.
+     * - Sets the disabled state for each aggregation option based on predefined conditions.
+     *
+     * The disabled state is stored in the `disabledAggregationOptions` object,
+     * where the key is the aggregation value and the value is a boolean indicating whether the option should be disabled.
+     *
+     * The `disabledConditions` object defines the conditions under which each aggregation option should be disabled.
+     *
+     * @param dateFrom - The value of the "date from" input.
+     * @param dateTo - The value of the "date to" input.
+     * @param disabledAggregationOptions - The object containing the disabled state of aggregation options.
+     * @returns The updated object with the disabled state of aggregation options.
+     */
+    updateDisabledStateOfAggregationOptionEntries(dateFrom, dateTo, disabledAggregationOptions) {
+        disabledAggregationOptions = this.aggregationService.getDisabledAggregationOptions(dateFrom, dateTo);
+        return disabledAggregationOptions;
+    }
+    /**
+     * Sets the aggregation control to the first available (non-disabled) option if the current option is disabled.
+     *
+     * This method:
+     * - Retrieves the current value of the aggregation control.
+     * - Checks if the current aggregation option is disabled.
+     * - If the current option is disabled, sets the control to the first available (non-disabled) option based on the following order:
+     *   - If the current value is `DAILY`, it switches to `HOURLY` if it's not disabled, otherwise to `MINUTELY` if `HOURLY` is also disabled.
+     *   - If the current value is `HOURLY`, it switches to `MINUTELY` if it's not disabled.
+     *   - If all options are disabled, it sets the value to `NONE`.
+     *
+     * The disabled state is stored in the `disabledAggregationOptions` object,
+     * where the key is the aggregation value and the value is a boolean indicating whether the option is disabled.
+     *
+     * The `AGGREGATION_VALUES` object defines the possible aggregation values.
+     *
+     * @param aggregationValue - The value of the current aggregation option.
+     * @param disabledAggregationOptions - An object containing disabled aggregation options.
+     * @returns The new aggregation option to be set.
+     */
+    setToFirstAvailableAggregationOptionIfCurrentIsDisabled(aggregationValue, disabledAggregationOptions) {
+        const currentValue = aggregationValue;
+        const disabledOptions = disabledAggregationOptions;
+        if (disabledOptions[currentValue]) {
+            const { daily, hourly, minutely, none } = AGGREGATION_VALUES;
+            let newAggregationValue = none;
+            if (currentValue === daily) {
+                if (!disabledOptions[hourly]) {
+                    newAggregationValue = hourly;
+                }
+                else if (!disabledOptions[minutely]) {
+                    newAggregationValue = minutely;
+                }
+            }
+            else if (currentValue === hourly && !disabledOptions[minutely]) {
+                newAggregationValue = minutely;
+            }
+            return newAggregationValue;
+        }
+    }
+    async getMeasurementExportedDataBlob(extension, dataToExport) {
+        try {
+            return await this.getMeasurementDataZipBlob(extension, dataToExport);
+        }
+        catch (error) {
+            this.showZipCreationErrorAlert();
+            return null;
+        }
+    }
+    async getSeriesExportedDataBlob(fileType, dataToExport, mergedExportDetails) {
+        try {
+            return await this.getSeriesDataBlob(fileType, dataToExport, mergedExportDetails);
+        }
+        catch (error) {
+            this.showZipCreationErrorAlert();
+            return null;
+        }
+    }
+    cleanupCachedData() {
+        this.cachedRawExportSeriesData = null;
+        this.cachedFlatteredAndSortedSeriesExportData = null;
+    }
+    showZipCreationErrorAlert() {
+        const alertMessage = this.translateService.instant(gettext('Could not create zip file.'));
+        this.alertService.danger(alertMessage);
+        return null;
+    }
+    getMeasurementDataZipBlob(extension, dataToExportWithBackendCreatedFile) {
+        const files = [];
+        this.createRawMeasurementExportedFiles(dataToExportWithBackendCreatedFile, extension, files);
+        return this.datapointsExportSelectorDataProcessingService.zipFiles(files);
+    }
+    createRawMeasurementExportedFiles(dataToExportWithBackendCreatedFile, fileExtension, files) {
+        dataToExportWithBackendCreatedFile.forEach(data => {
+            if (data) {
+                const fragmentSeries = `${data.valueFragmentType}_${data.valueFragmentSeries}`;
+                const fileName = this.datapointsExportSelectorDataProcessingService.createFileName(data.source, fragmentSeries, fileExtension);
+                const fileData = data.fetchedMeasurementsBlobFile;
+                const exportedFile = { fileName, fileData };
+                files.push(exportedFile);
+            }
+        });
+    }
+    /**
+     * Converts data to a specified file type and returns the generated blob.
+     *
+     * Unlike measurements, data must be transformed to an exportable file structure before exporting.
+     *
+     * @param fileType - The type of file to which the data points should be exported. This can be 'csv' or 'excel'.
+     * @param dataToExport - An array of processed measurement data combined with the respective properties of the datapoint.
+     * @param mergedExportDetails - The details for the merged export, contains date range and aggregation.
+     * @returns A promise that resolves to the generated ZIP blob or null if an error occurs.
+     */
+    async getSeriesDataBlob(fileType, dataToExport, mergedExportDetails) {
+        this.transformSeriesDataToExportableFileStructure(dataToExport);
+        const exportParams = {
+            flattenedAndSortedExportData: this.cachedFlatteredAndSortedSeriesExportData,
+            fileType,
+            mergedExportDetails: mergedExportDetails
+        };
+        return await this.datapointsExportSelectorDataProcessingService.exportSeriesData(exportParams);
+    }
+    transformSeriesDataToExportableFileStructure(dataToExport) {
+        if (!this.cachedRawExportSeriesData) {
+            this.cachedRawExportSeriesData =
+                this.datapointsExportSelectorDataProcessingService.transformToExportFileStructure(dataToExport);
+            this.cachedFlatteredAndSortedSeriesExportData = this.cachedRawExportSeriesData
+                .flat()
+                .sort((a, b) => {
+                return new Date(a.time).getTime() - new Date(b.time).getTime();
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsExportSelectorFileExporterService, deps: [{ token: i1.AggregationService }, { token: i1.AlertService }, { token: DataProcessingService }, { token: i4.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsExportSelectorFileExporterService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsExportSelectorFileExporterService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AggregationService }, { type: i1.AlertService }, { type: DataProcessingService }, { type: i4.TranslateService }] });
+
+class DataPointsExportSelectorPreviewComponent {
+    constructor() {
+        this.MEASUREMENTS_PREVIEW_ITEMS_LIMIT = MEASUREMENTS_PREVIEW_ITEMS_LIMIT;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DataPointsExportSelectorPreviewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: DataPointsExportSelectorPreviewComponent, isStandalone: true, selector: "c8y-datapoints-export-selector-preview", inputs: { hasFetchedDataAnyValuesToExport: "hasFetchedDataAnyValuesToExport", isPreviewLoading: "isPreviewLoading", previewTableData: "previewTableData" }, ngImport: i0, template: "<div class=\"p-t-16 p-l-16 p-r-16 m-b-0\">\n  <div class=\"d-flex a-i-center\">\n    <label\n      class=\"m-b-0 d-flex a-i-center gap-4\"\n      [title]=\"'Preview`of exported file`' | translate\"\n    >\n      {{ 'Preview`of exported file`' | translate }}\n      <button\n        class=\"btn-help\"\n        [attr.aria-label]=\"'Help' | translate\"\n        [popover]=\"popoverPreviewTemplate\"\n        placement=\"right\"\n        triggers=\"focus\"\n        container=\"body\"\n        type=\"button\"\n        [adaptivePosition]=\"true\"\n      ></button>\n      <ng-template #popoverPreviewTemplate>\n        <span translate>\n          <p>The preview shows the structure of the raw file from a single source.</p>\n          <p>If no data is available, only the column headers are visible.</p>\n          <p>\n            The preview is limited to\n            <b>{{ MEASUREMENTS_PREVIEW_ITEMS_LIMIT }}</b>\n            records.\n          </p>\n        </span>\n      </ng-template>\n    </label>\n  </div>\n  <div\n    class=\"table-responsive\"\n    style=\"min-height: 275px\"\n  >\n    <table class=\"table\">\n      <thead>\n        <tr>\n          <th>{{ 'Time' | translate }}</th>\n          <th>{{ 'Source' | translate }}</th>\n          <th>{{ 'Device name' | translate }}</th>\n          <th>\n            {{ 'Fragment and series' | translate }}\n          </th>\n          <th>{{ 'Value' | translate }}</th>\n          <th>{{ 'Unit' | translate }}</th>\n        </tr>\n      </thead>\n      <ng-container *ngIf=\"hasFetchedDataAnyValuesToExport || isPreviewLoading; else emptyState\">\n        <ng-container *ngIf=\"!isPreviewLoading; else loading\">\n          <tbody>\n            <tr *ngFor=\"let row of previewTableData\">\n              <td>{{ row.time }}</td>\n              <td>{{ row.source }}</td>\n              <td>{{ row.device_name }}</td>\n              <td>\n                {{ row.fragment_series }}\n              </td>\n              <td>{{ row.value }}</td>\n              <td>{{ row.unit }}</td>\n            </tr>\n          </tbody>\n        </ng-container>\n      </ng-container>\n      <ng-template #emptyState>\n        <tbody>\n          <tr>\n            <td colspan=\"8\">\n              <div class=\"d-col a-i-center\">\n                <c8y-ui-empty-state\n                  [icon]=\"'search'\"\n                  [title]=\"'No data available.' | translate\"\n                  [horizontal]=\"true\"\n                  data-cy=\"datapoints-table-list--empty-state\"\n                ></c8y-ui-empty-state>\n              </div>\n            </td>\n          </tr>\n        </tbody>\n      </ng-template>\n      <ng-template #loading>\n        <tbody>\n          <tr>\n            <td colspan=\"8\">\n              <c8y-loading></c8y-loading>\n            </td>\n          </tr>\n        </tbody>\n      </ng-template>\n    </table>\n  </div>\n</div>\n", dependencies: [{ kind: "ngmodule", type: A11yModule }, { kind: "ngmodule", type: CoreModule }, { kind: "component", type: i1.EmptyStateComponent, selector: "c8y-ui-empty-state", inputs: ["icon", "title", "subtitle", "horizontal"] }, { kind: "pipe", type: i1.C8yTranslatePipe, name: "translate" }, { kind: "directive", type: i1.C8yTranslateDirective, selector: "[translate],[ngx-translate]" }, { kind: "directive", type: i2$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i1.LoadingComponent, selector: "c8y-loading", inputs: ["layout", "progress", "message"] }, { kind: "ngmodule", type: PopoverModule }, { kind: "directive", type: i3$1.PopoverDirective, selector: "[popover]", inputs: ["adaptivePosition", "boundariesElement", "popover", "popoverContext", "popoverTitle", "placement", "outsideClick", "triggers", "container", "containerClass", "isOpen", "delay"], outputs: ["onShown", "onHidden"], exportAs: ["bs-popover"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DataPointsExportSelectorPreviewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'c8y-datapoints-export-selector-preview', standalone: true, imports: [A11yModule, CoreModule, PopoverModule], template: "<div class=\"p-t-16 p-l-16 p-r-16 m-b-0\">\n  <div class=\"d-flex a-i-center\">\n    <label\n      class=\"m-b-0 d-flex a-i-center gap-4\"\n      [title]=\"'Preview`of exported file`' | translate\"\n    >\n      {{ 'Preview`of exported file`' | translate }}\n      <button\n        class=\"btn-help\"\n        [attr.aria-label]=\"'Help' | translate\"\n        [popover]=\"popoverPreviewTemplate\"\n        placement=\"right\"\n        triggers=\"focus\"\n        container=\"body\"\n        type=\"button\"\n        [adaptivePosition]=\"true\"\n      ></button>\n      <ng-template #popoverPreviewTemplate>\n        <span translate>\n          <p>The preview shows the structure of the raw file from a single source.</p>\n          <p>If no data is available, only the column headers are visible.</p>\n          <p>\n            The preview is limited to\n            <b>{{ MEASUREMENTS_PREVIEW_ITEMS_LIMIT }}</b>\n            records.\n          </p>\n        </span>\n      </ng-template>\n    </label>\n  </div>\n  <div\n    class=\"table-responsive\"\n    style=\"min-height: 275px\"\n  >\n    <table class=\"table\">\n      <thead>\n        <tr>\n          <th>{{ 'Time' | translate }}</th>\n          <th>{{ 'Source' | translate }}</th>\n          <th>{{ 'Device name' | translate }}</th>\n          <th>\n            {{ 'Fragment and series' | translate }}\n          </th>\n          <th>{{ 'Value' | translate }}</th>\n          <th>{{ 'Unit' | translate }}</th>\n        </tr>\n      </thead>\n      <ng-container *ngIf=\"hasFetchedDataAnyValuesToExport || isPreviewLoading; else emptyState\">\n        <ng-container *ngIf=\"!isPreviewLoading; else loading\">\n          <tbody>\n            <tr *ngFor=\"let row of previewTableData\">\n              <td>{{ row.time }}</td>\n              <td>{{ row.source }}</td>\n              <td>{{ row.device_name }}</td>\n              <td>\n                {{ row.fragment_series }}\n              </td>\n              <td>{{ row.value }}</td>\n              <td>{{ row.unit }}</td>\n            </tr>\n          </tbody>\n        </ng-container>\n      </ng-container>\n      <ng-template #emptyState>\n        <tbody>\n          <tr>\n            <td colspan=\"8\">\n              <div class=\"d-col a-i-center\">\n                <c8y-ui-empty-state\n                  [icon]=\"'search'\"\n                  [title]=\"'No data available.' | translate\"\n                  [horizontal]=\"true\"\n                  data-cy=\"datapoints-table-list--empty-state\"\n                ></c8y-ui-empty-state>\n              </div>\n            </td>\n          </tr>\n        </tbody>\n      </ng-template>\n      <ng-template #loading>\n        <tbody>\n          <tr>\n            <td colspan=\"8\">\n              <c8y-loading></c8y-loading>\n            </td>\n          </tr>\n        </tbody>\n      </ng-template>\n    </table>\n  </div>\n</div>\n" }]
+        }], propDecorators: { hasFetchedDataAnyValuesToExport: [{
+                type: Input
+            }], isPreviewLoading: [{
+                type: Input
+            }], previewTableData: [{
+                type: Input
+            }] } });
+
+class DataPointsExportSelectorDataScopeComponent {
+    constructor() {
+        this.onAggregationChange = new EventEmitter();
+        this.onExportTypeChange = new EventEmitter();
+        this.AGGREGATION_LABELS = AGGREGATION_LABELS;
+        this.AGGREGATION_VALUES_ARR = AGGREGATION_VALUES_ARR;
+        this.EXPORT_MODE_LABELS = EXPORT_MODE_LABELS;
+        this.EXPORT_MODE_VALUES_ARR = [EXPORT_MODE_VALUES.full, EXPORT_MODE_VALUES.compact];
+    }
+    emitAggregationChange(aggregation) {
+        this.onAggregationChange.emit(aggregation);
+    }
+    emitExportTypeChange(exportType) {
+        this.onExportTypeChange.emit(exportType);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DataPointsExportSelectorDataScopeComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: DataPointsExportSelectorDataScopeComponent, isStandalone: true, selector: "c8y-datapoints-export-selector-data-scope", inputs: { disabledAggregationOptions: "disabledAggregationOptions", formGroup: "formGroup" }, outputs: { onAggregationChange: "onAggregationChange", onExportTypeChange: "onExportTypeChange" }, ngImport: i0, template: "<fieldset class=\"c8y-fieldset\">\n    <legend class=\"d-flex a-i-center\">\n      {{ 'Data scope' | translate }}\n      <button\n        class=\"btn-help\"\n        [attr.aria-label]=\"'Help' | translate\"\n        [popover]=\"popoverDataScopeTemplate\"\n        placement=\"right\"\n        triggers=\"focus\"\n        container=\"body\"\n        type=\"button\"\n        [adaptivePosition]=\"true\"\n      ></button>\n      <ng-template #popoverDataScopeTemplate>\n        <p\n          class=\"m-b-8\"\n          translate\n        >\n          Choose type of an export to generate, the available options are:\n        </p>\n        <p><strong translate>Compact</strong></p>\n        <ul class=\"p-l-16\">\n          <li translate>\n            Up to 5,000 records per data point, or up to the data retention limit\n          </li>\n          <li translate>Creates a single merged file containing all the data</li>\n          <li translate>Preview is not available</li>\n          <li translate>Supports data aggregation (optional)</li>\n        </ul>\n        <p><strong translate>Full</strong></p>\n        <ul class=\"p-l-16\">\n          <li translate>\n            Up to 1,000,000 records per data point, or up to the data retention limit\n          </li>\n          <li translate>\n            If the export exceeds 50,000 records, the data will be sent via email\n          </li>\n          <li translate>\n            Creates a compressed ZIP file that contains separate data files for each of your\n            selected points\n          </li>\n          <li translate>Preview is available</li>\n          <li translate>No data aggregation</li>\n        </ul>\n      </ng-template>\n    </legend>\n    <c8y-form-group class=\"m-b-8\">\n      <label>\n        {{ 'Export mode' | translate }}\n      </label>\n      <div\n        class=\"c8y-select-wrapper\"\n        [formGroup]=\"formGroup\"\n      >\n        <select\n          class=\"form-control text-12\"\n          [title]=\"'Export mode' | translate\"\n          id=\"exportMode\"\n          formControlName=\"exportMode\"\n          (ngModelChange)=\"emitExportTypeChange($event)\"\n        >\n          <option\n            *ngFor=\"let exportModeValue of EXPORT_MODE_VALUES_ARR\"\n            [ngValue]=\"exportModeValue\"\n          >\n            {{ EXPORT_MODE_LABELS[exportModeValue] | translate }}\n          </option>\n        </select>\n      </div>\n    </c8y-form-group>\n    <c8y-form-group class=\"m-b-8\">\n      <label>\n        {{ 'Aggregation' | translate }}\n      </label>\n      <div\n        class=\"c8y-select-wrapper\"\n        [formGroup]=\"formGroup\"\n      >\n        <select\n          class=\"form-control text-12\"\n          [title]=\"'Aggregation' | translate\"\n          id=\"aggregation\"\n          formControlName=\"aggregation\"\n          (ngModelChange)=\"emitAggregationChange($event)\"\n        >\n          <option\n            *ngFor=\"let aggregationValue of AGGREGATION_VALUES_ARR\"\n            [ngValue]=\"aggregationValue\"\n            [disabled]=\"disabledAggregationOptions[aggregationValue]\"\n          >\n            {{ AGGREGATION_LABELS[aggregationValue] | translate }}\n          </option>\n        </select>\n      </div>\n    </c8y-form-group>\n  </fieldset>", dependencies: [{ kind: "ngmodule", type: CoreModule }, { kind: "pipe", type: i1.C8yTranslatePipe, name: "translate" }, { kind: "directive", type: i1.C8yTranslateDirective, selector: "[translate],[ngx-translate]" }, { kind: "directive", type: i2$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3$2.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i3$2.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i3$2.SelectControlValueAccessor, selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]", inputs: ["compareWith"] }, { kind: "directive", type: i3$2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3$2.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "component", type: i1.FormGroupComponent, selector: "c8y-form-group", inputs: ["hasError", "hasWarning", "hasSuccess", "novalidation", "status"] }, { kind: "directive", type: i3$2.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i3$2.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "ngmodule", type: FormsModule }, { kind: "ngmodule", type: PopoverModule }, { kind: "directive", type: i3$1.PopoverDirective, selector: "[popover]", inputs: ["adaptivePosition", "boundariesElement", "popover", "popoverContext", "popoverTitle", "placement", "outsideClick", "triggers", "container", "containerClass", "isOpen", "delay"], outputs: ["onShown", "onHidden"], exportAs: ["bs-popover"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DataPointsExportSelectorDataScopeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'c8y-datapoints-export-selector-data-scope', standalone: true, imports: [CoreModule, FormsModule, PopoverModule], template: "<fieldset class=\"c8y-fieldset\">\n    <legend class=\"d-flex a-i-center\">\n      {{ 'Data scope' | translate }}\n      <button\n        class=\"btn-help\"\n        [attr.aria-label]=\"'Help' | translate\"\n        [popover]=\"popoverDataScopeTemplate\"\n        placement=\"right\"\n        triggers=\"focus\"\n        container=\"body\"\n        type=\"button\"\n        [adaptivePosition]=\"true\"\n      ></button>\n      <ng-template #popoverDataScopeTemplate>\n        <p\n          class=\"m-b-8\"\n          translate\n        >\n          Choose type of an export to generate, the available options are:\n        </p>\n        <p><strong translate>Compact</strong></p>\n        <ul class=\"p-l-16\">\n          <li translate>\n            Up to 5,000 records per data point, or up to the data retention limit\n          </li>\n          <li translate>Creates a single merged file containing all the data</li>\n          <li translate>Preview is not available</li>\n          <li translate>Supports data aggregation (optional)</li>\n        </ul>\n        <p><strong translate>Full</strong></p>\n        <ul class=\"p-l-16\">\n          <li translate>\n            Up to 1,000,000 records per data point, or up to the data retention limit\n          </li>\n          <li translate>\n            If the export exceeds 50,000 records, the data will be sent via email\n          </li>\n          <li translate>\n            Creates a compressed ZIP file that contains separate data files for each of your\n            selected points\n          </li>\n          <li translate>Preview is available</li>\n          <li translate>No data aggregation</li>\n        </ul>\n      </ng-template>\n    </legend>\n    <c8y-form-group class=\"m-b-8\">\n      <label>\n        {{ 'Export mode' | translate }}\n      </label>\n      <div\n        class=\"c8y-select-wrapper\"\n        [formGroup]=\"formGroup\"\n      >\n        <select\n          class=\"form-control text-12\"\n          [title]=\"'Export mode' | translate\"\n          id=\"exportMode\"\n          formControlName=\"exportMode\"\n          (ngModelChange)=\"emitExportTypeChange($event)\"\n        >\n          <option\n            *ngFor=\"let exportModeValue of EXPORT_MODE_VALUES_ARR\"\n            [ngValue]=\"exportModeValue\"\n          >\n            {{ EXPORT_MODE_LABELS[exportModeValue] | translate }}\n          </option>\n        </select>\n      </div>\n    </c8y-form-group>\n    <c8y-form-group class=\"m-b-8\">\n      <label>\n        {{ 'Aggregation' | translate }}\n      </label>\n      <div\n        class=\"c8y-select-wrapper\"\n        [formGroup]=\"formGroup\"\n      >\n        <select\n          class=\"form-control text-12\"\n          [title]=\"'Aggregation' | translate\"\n          id=\"aggregation\"\n          formControlName=\"aggregation\"\n          (ngModelChange)=\"emitAggregationChange($event)\"\n        >\n          <option\n            *ngFor=\"let aggregationValue of AGGREGATION_VALUES_ARR\"\n            [ngValue]=\"aggregationValue\"\n            [disabled]=\"disabledAggregationOptions[aggregationValue]\"\n          >\n            {{ AGGREGATION_LABELS[aggregationValue] | translate }}\n          </option>\n        </select>\n      </div>\n    </c8y-form-group>\n  </fieldset>" }]
+        }], propDecorators: { disabledAggregationOptions: [{
+                type: Input
+            }], formGroup: [{
+                type: Input
+            }], onAggregationChange: [{
+                type: Output
+            }], onExportTypeChange: [{
+                type: Output
+            }] } });
+
+class DataPointsExportSelectorFileTypesComponent {
+    constructor() {
+        this.dynamicFilesTypeMetadata = {};
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DataPointsExportSelectorFileTypesComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: DataPointsExportSelectorFileTypesComponent, isStandalone: true, selector: "c8y-datapoints-export-selector-file-types", inputs: { dynamicFilesTypeMetadata: "dynamicFilesTypeMetadata", formGroup: "formGroup" }, ngImport: i0, template: "<fieldset class=\"c8y-fieldset\">\n  <legend class=\"d-flex a-i-center\">{{ 'File types' | translate }}</legend>\n  <div [formGroup]=\"formGroup\">\n    <div formGroupName=\"fileTypes\">\n      <c8y-form-group\n        class=\"m-b-8\"\n        *ngFor=\"let item of dynamicFilesTypeMetadata | keyvalue\"\n      >\n        <label>{{ item.value.label | translate }}</label>\n        <label\n          class=\"c8y-checkbox m-t-0\"\n          title=\"{{ item.value.title }}\"\n        >\n          <input\n            type=\"checkbox\"\n            formControlName=\"{{ item.key }}\"\n          />\n          <span></span>\n          <i\n            class=\"m-l-8 m-r-4\"\n            c8yIcon=\"{{ item.value.icon }}\"\n          ></i>\n        </label>\n      </c8y-form-group>\n    </div>\n  </div>\n</fieldset>\n", dependencies: [{ kind: "ngmodule", type: CoreModule }, { kind: "directive", type: i1.IconDirective, selector: "[c8yIcon]", inputs: ["c8yIcon"] }, { kind: "pipe", type: i1.C8yTranslatePipe, name: "translate" }, { kind: "directive", type: i2$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "pipe", type: i2$1.KeyValuePipe, name: "keyvalue" }, { kind: "directive", type: i3$2.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { kind: "directive", type: i3$2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3$2.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "component", type: i1.FormGroupComponent, selector: "c8y-form-group", inputs: ["hasError", "hasWarning", "hasSuccess", "novalidation", "status"] }, { kind: "directive", type: i1.RequiredInputPlaceholderDirective, selector: "input[required], input[formControlName]" }, { kind: "directive", type: i3$2.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i3$2.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "directive", type: i3$2.FormGroupName, selector: "[formGroupName]", inputs: ["formGroupName"] }, { kind: "ngmodule", type: FormsModule }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DataPointsExportSelectorFileTypesComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'c8y-datapoints-export-selector-file-types', standalone: true, imports: [CoreModule, FormsModule], template: "<fieldset class=\"c8y-fieldset\">\n  <legend class=\"d-flex a-i-center\">{{ 'File types' | translate }}</legend>\n  <div [formGroup]=\"formGroup\">\n    <div formGroupName=\"fileTypes\">\n      <c8y-form-group\n        class=\"m-b-8\"\n        *ngFor=\"let item of dynamicFilesTypeMetadata | keyvalue\"\n      >\n        <label>{{ item.value.label | translate }}</label>\n        <label\n          class=\"c8y-checkbox m-t-0\"\n          title=\"{{ item.value.title }}\"\n        >\n          <input\n            type=\"checkbox\"\n            formControlName=\"{{ item.key }}\"\n          />\n          <span></span>\n          <i\n            class=\"m-l-8 m-r-4\"\n            c8yIcon=\"{{ item.value.icon }}\"\n          ></i>\n        </label>\n      </c8y-form-group>\n    </div>\n  </div>\n</fieldset>\n" }]
+        }], propDecorators: { dynamicFilesTypeMetadata: [{
+                type: Input
+            }], formGroup: [{
+                type: Input
+            }] } });
+
+class DataPointsExportSelectorTimeRangeComponent {
+    constructor() {
+        this.onDateFromChange = new EventEmitter();
+        this.onDateToChange = new EventEmitter();
+        this.DATE_FROM = 'dateFrom';
+        this.DATE_TO = 'dateTo';
+        this.FROM_DATE = gettext('From`date`');
+        this.HAS_ERROR = HAS_ERROR;
+        this.INVALID_DATE_TIME = 'invalidDateTime';
+        this.THIS_DATE_IS_INVALID = gettext('This date is invalid.');
+        this.THIS_DATE_IS_AFTER_THE_LAST_ALLOWED_DATE = gettext('This date is after the latest allowed date.');
+        this.THIS_DATE_IS_BEFORE_THE_EARLIEST_ALLOWED_DATE = gettext('This date is before the earliest allowed date.');
+        this.TO_DATE = gettext('To`date`');
+    }
+    emitDateFromChange(updatedDate) {
+        this.onDateFromChange.emit(updatedDate);
+    }
+    emitDateToChange(updatedDate) {
+        this.onDateToChange.emit(updatedDate);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DataPointsExportSelectorTimeRangeComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: DataPointsExportSelectorTimeRangeComponent, isStandalone: true, selector: "c8y-datapoints-export-selector-time-range", inputs: { formGroup: "formGroup" }, outputs: { onDateFromChange: "onDateFromChange", onDateToChange: "onDateToChange" }, ngImport: i0, template: "<fieldset class=\"c8y-fieldset\">\n  <legend>{{ 'Time range' | translate }}</legend>\n  <c8y-form-group\n    class=\"m-b-8\"\n    [ngClass]=\"formGroup.controls.dateFrom.errors ? HAS_ERROR : ''\"\n  >\n    <label\n      [title]=\"FROM_DATE | translate\"\n      [for]=\"DATE_FROM\"\n    >\n      {{ FROM_DATE | translate }}\n    </label>\n    <div>\n      <c8y-date-time-picker\n        id=\"DATE_FROM\"\n        [maxDate]=\"formGroup.value.dateTo\"\n        [placeholder]=\"FROM_DATE | translate\"\n        [formControl]=\"formGroup.controls.dateFrom\"\n        [ngClass]=\"formGroup.controls.dateFrom.errors ? HAS_ERROR : ''\"\n        (ngModelChange)=\"emitDateFromChange($event)\"\n      ></c8y-date-time-picker>\n      <c8y-messages [show]=\"formGroup.controls.dateFrom.errors\">\n        <c8y-message\n          name=\"dateAfterRangeMax\"\n          [text]=\"THIS_DATE_IS_AFTER_THE_LAST_ALLOWED_DATE | translate\"\n        ></c8y-message>\n        <c8y-message\n          name=\"INVALID_DATE_TIME\"\n          [text]=\"THIS_DATE_IS_INVALID | translate\"\n        ></c8y-message>\n      </c8y-messages>\n    </div>\n  </c8y-form-group>\n  <c8y-form-group\n    class=\"m-b-8\"\n    [ngClass]=\"formGroup.controls.dateTo.errors ? HAS_ERROR : ''\"\n  >\n    <label\n      [title]=\"TO_DATE | translate\"\n      [for]=\"DATE_TO\"\n    >\n      {{ TO_DATE | translate }}\n    </label>\n    <div>\n      <c8y-date-time-picker\n        id=\"DATE_TO\"\n        [minDate]=\"formGroup.value.dateFrom\"\n        [placeholder]=\"TO_DATE | translate\"\n        [formControl]=\"formGroup.controls.dateTo\"\n        [ngClass]=\"formGroup.controls.dateTo.errors ? HAS_ERROR : ''\"\n        (ngModelChange)=\"emitDateToChange($event)\"\n      ></c8y-date-time-picker>\n      <c8y-messages [show]=\"formGroup.controls.dateTo.errors\">\n        <c8y-message\n          name=\"dateBeforeRangeMin\"\n          [text]=\"THIS_DATE_IS_BEFORE_THE_EARLIEST_ALLOWED_DATE | translate\"\n        ></c8y-message>\n        <c8y-message\n          name=\"INVALID_DATE_TIME\"\n          [text]=\"THIS_DATE_IS_INVALID | translate\"\n        ></c8y-message>\n      </c8y-messages>\n    </div>\n  </c8y-form-group>\n</fieldset>\n", dependencies: [{ kind: "ngmodule", type: CoreModule }, { kind: "pipe", type: i1.C8yTranslatePipe, name: "translate" }, { kind: "directive", type: i2$1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i3$2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "component", type: i1.FormGroupComponent, selector: "c8y-form-group", inputs: ["hasError", "hasWarning", "hasSuccess", "novalidation", "status"] }, { kind: "directive", type: i1.MessageDirective, selector: "c8y-message", inputs: ["name", "text"] }, { kind: "component", type: i1.MessagesComponent, selector: "c8y-messages", inputs: ["show", "defaults", "helpMessage"] }, { kind: "directive", type: i3$2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "component", type: i1.DateTimePickerComponent, selector: "c8y-date-time-picker", inputs: ["minDate", "maxDate", "placeholder", "dateInputFormat", "adaptivePosition", "size", "dateType", "config"], outputs: ["onDateSelected"] }, { kind: "ngmodule", type: FormsModule }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DataPointsExportSelectorTimeRangeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'c8y-datapoints-export-selector-time-range', standalone: true, imports: [CoreModule, FormsModule], template: "<fieldset class=\"c8y-fieldset\">\n  <legend>{{ 'Time range' | translate }}</legend>\n  <c8y-form-group\n    class=\"m-b-8\"\n    [ngClass]=\"formGroup.controls.dateFrom.errors ? HAS_ERROR : ''\"\n  >\n    <label\n      [title]=\"FROM_DATE | translate\"\n      [for]=\"DATE_FROM\"\n    >\n      {{ FROM_DATE | translate }}\n    </label>\n    <div>\n      <c8y-date-time-picker\n        id=\"DATE_FROM\"\n        [maxDate]=\"formGroup.value.dateTo\"\n        [placeholder]=\"FROM_DATE | translate\"\n        [formControl]=\"formGroup.controls.dateFrom\"\n        [ngClass]=\"formGroup.controls.dateFrom.errors ? HAS_ERROR : ''\"\n        (ngModelChange)=\"emitDateFromChange($event)\"\n      ></c8y-date-time-picker>\n      <c8y-messages [show]=\"formGroup.controls.dateFrom.errors\">\n        <c8y-message\n          name=\"dateAfterRangeMax\"\n          [text]=\"THIS_DATE_IS_AFTER_THE_LAST_ALLOWED_DATE | translate\"\n        ></c8y-message>\n        <c8y-message\n          name=\"INVALID_DATE_TIME\"\n          [text]=\"THIS_DATE_IS_INVALID | translate\"\n        ></c8y-message>\n      </c8y-messages>\n    </div>\n  </c8y-form-group>\n  <c8y-form-group\n    class=\"m-b-8\"\n    [ngClass]=\"formGroup.controls.dateTo.errors ? HAS_ERROR : ''\"\n  >\n    <label\n      [title]=\"TO_DATE | translate\"\n      [for]=\"DATE_TO\"\n    >\n      {{ TO_DATE | translate }}\n    </label>\n    <div>\n      <c8y-date-time-picker\n        id=\"DATE_TO\"\n        [minDate]=\"formGroup.value.dateFrom\"\n        [placeholder]=\"TO_DATE | translate\"\n        [formControl]=\"formGroup.controls.dateTo\"\n        [ngClass]=\"formGroup.controls.dateTo.errors ? HAS_ERROR : ''\"\n        (ngModelChange)=\"emitDateToChange($event)\"\n      ></c8y-date-time-picker>\n      <c8y-messages [show]=\"formGroup.controls.dateTo.errors\">\n        <c8y-message\n          name=\"dateBeforeRangeMin\"\n          [text]=\"THIS_DATE_IS_BEFORE_THE_EARLIEST_ALLOWED_DATE | translate\"\n        ></c8y-message>\n        <c8y-message\n          name=\"INVALID_DATE_TIME\"\n          [text]=\"THIS_DATE_IS_INVALID | translate\"\n        ></c8y-message>\n      </c8y-messages>\n    </div>\n  </c8y-form-group>\n</fieldset>\n" }]
+        }], propDecorators: { formGroup: [{
+                type: Input
+            }], onDateFromChange: [{
+                type: Output
+            }], onDateToChange: [{
+                type: Output
+            }] } });
+
+class CSVDataTransformer {
+    transformToMergedFormat(exportData) {
+        const timeSeries = new Map();
+        const uniqueColumnIdentifiers = new Set();
+        exportData.forEach(({ time, device_name, fragment_series, unit, value_min, value_max, source }) => {
+            const measurementIdentifier = this.createMeasurementIdentifier(device_name, fragment_series, unit, source);
+            if (!timeSeries.has(time)) {
+                timeSeries.set(time, {});
+            }
+            const timeEntry = timeSeries.get(time);
+            if (timeEntry) {
+                const minKey = this.formatMinKey(measurementIdentifier);
+                const maxKey = this.formatMaxKey(measurementIdentifier);
+                timeEntry[minKey] = value_min;
+                timeEntry[maxKey] = value_max;
+                uniqueColumnIdentifiers.add(minKey);
+                uniqueColumnIdentifiers.add(maxKey);
+            }
+        });
+        return {
+            timeSeries,
+            uniqueColumnIdentifiers: Array.from(uniqueColumnIdentifiers)
+        };
+    }
+    createMeasurementIdentifier(deviceName, fragmentSeries, unit, source) {
+        return unit
+            ? `(${source}) ${deviceName} -> ${fragmentSeries} [${unit}]`
+            : `(${source}) ${deviceName} -> ${fragmentSeries}`;
+    }
+    formatMinKey(baseKey) {
+        return `${baseKey} (min)`;
+    }
+    formatMaxKey(baseKey) {
+        return `${baseKey} (max)`;
+    }
+}
+class CSVFileCreator {
+    async createFile(content, mimeType) {
+        return new Blob([content], { type: mimeType });
+    }
+}
+class CSVGenerator {
+    static getLabel() {
+        return gettext('Comma-separated value');
+    }
+    static getTitle() {
+        return 'CSV';
+    }
+    static getType() {
+        return 'csv';
+    }
+    static getIcon() {
+        return 'table';
+    }
+    static getFileExtension() {
+        return 'csv';
+    }
+    static getAcceptType() {
+        return 'text/csv';
+    }
+    static getMimeType() {
+        return 'text/csv';
+    }
+    static getZipName() {
+        return 'export_csv.zip';
+    }
+    static async convertToMergedCSV(exportData, mergedExportDetails) {
+        const instance = CSVGenerator.getInstance();
+        const { timeSeries, uniqueColumnIdentifiers } = instance.dataTransformer.transformToMergedFormat(exportData);
+        const rows = [
+            instance.createMergedFileHeaderRow(uniqueColumnIdentifiers, mergedExportDetails),
+            ...instance.createMergedFileDataRows(timeSeries, uniqueColumnIdentifiers)
+        ];
+        const csvContent = rows.map(row => row.join(',')).join('\n');
+        return instance.fileCreator.createFile(csvContent, CSVGenerator.getMimeType());
+    }
+    static getInstance() {
+        if (!CSVGenerator.instance) {
+            CSVGenerator.instance = new CSVGenerator();
+        }
+        return CSVGenerator.instance;
+    }
+    constructor() {
+        this.dataTransformer = new CSVDataTransformer();
+        this.fileCreator = new CSVFileCreator();
+    }
+    createMergedFileHeaderRow(uniqueColumnIdentifiers, details) {
+        const time = details ? `time => from ${details.dateFrom} to ${details.dateTo}` : 'time';
+        return [time, ...uniqueColumnIdentifiers];
+    }
+    createMergedFileDataRows(timeSeries, uniqueColumnIdentifiers) {
+        return Array.from(timeSeries.entries())
+            .filter(([time, values]) => this.isValidEntry(time, values))
+            .map(([time, values]) => this.createDataRow(time, values, uniqueColumnIdentifiers));
+    }
+    isValidEntry(time, values) {
+        return time !== null && Object.values(values).some(value => value != null);
+    }
+    createDataRow(time, values, uniqueColumnIdentifiers) {
+        const row = [time];
+        uniqueColumnIdentifiers.forEach(key => {
+            const value = values[key];
+            row.push(value?.toString() || '');
+        });
+        return row;
+    }
+}
+const CSVGeneratorAdapter = {
+    getLabel: CSVGenerator.getLabel.bind(CSVGenerator),
+    getIcon: CSVGenerator.getIcon.bind(CSVGenerator),
+    getFileExtension: CSVGenerator.getFileExtension.bind(CSVGenerator),
+    getMimeType: CSVGenerator.getMimeType.bind(CSVGenerator),
+    generateMerged: CSVGenerator.convertToMergedCSV.bind(CSVGenerator),
+    getType: CSVGenerator.getType.bind(CSVGenerator),
+    getTitle: CSVGenerator.getTitle.bind(CSVGenerator),
+    getZipName: CSVGenerator.getZipName.bind(CSVGenerator),
+    getAcceptType: CSVGenerator.getAcceptType.bind(CSVGenerator)
+};
+
+// Utility functions
+class XmlUtils {
+    static escapeXml(unsafe) {
+        return unsafe.replace(/[<>&'"]/g, c => {
+            switch (c) {
+                case '<':
+                    return '&lt;';
+                case '>':
+                    return '&gt;';
+                case '&':
+                    return '&amp;';
+                case "'":
+                    return '&apos;';
+                case '"':
+                    return '&quot;';
+            }
+        });
+    }
+}
+class ExcelDataTransformer {
+    transformToMergedFormat(exportData) {
+        const timeSeries = new Map();
+        const uniqueColumnIdentifiers = new Set();
+        exportData.forEach(({ time, device_name, fragment_series, unit, value_min, value_max, source }) => {
+            const measurementIdentifier = this.createMeasurementIdentifier(device_name, fragment_series, unit, source);
+            if (!timeSeries.has(time)) {
+                timeSeries.set(time, {});
+            }
+            const timeEntry = timeSeries.get(time);
+            if (timeEntry) {
+                const minKey = this.formatMinKey(measurementIdentifier);
+                const maxKey = this.formatMaxKey(measurementIdentifier);
+                timeEntry[minKey] = value_min;
+                timeEntry[maxKey] = value_max;
+                uniqueColumnIdentifiers.add(minKey);
+                uniqueColumnIdentifiers.add(maxKey);
+            }
+        });
+        return {
+            timeSeries,
+            uniqueColumnIdentifiers: Array.from(uniqueColumnIdentifiers)
+        };
+    }
+    createMeasurementIdentifier(deviceName, fragmentSeries, unit, source) {
+        return unit
+            ? `(${source}) ${deviceName} -> ${fragmentSeries} [${unit}]`
+            : `(${source}) ${deviceName} -> ${fragmentSeries}`;
+    }
+    formatMinKey(baseKey) {
+        return `${baseKey} (min)`;
+    }
+    formatMaxKey(baseKey) {
+        return `${baseKey} (max)`;
+    }
+}
+class ExcelXmlGenerator {
+    constructor() {
+        this.columnWidths = {
+            time: 25,
+            source: 10,
+            device_name: 20,
+            'fragment.series': 20,
+            value_min: 15,
+            value_max: 15,
+            unit: 5
+        };
+        this.defaultWidth = 30;
+        this.RELS_XML = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+            '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">\n' +
+            '  <Relationship Id="rId1" Target="xl/workbook.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"/>\n' +
+            '  <Relationship Id="rId2" Target="docProps/app.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties"/>\n' +
+            '  <Relationship Id="rId3" Target="docProps/core.xml" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties"/>\n' +
+            '</Relationships>';
+        this.CONTENT_TYPES_XML = '<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n' +
+            '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">\n' +
+            '  <Default ContentType="application/vnd.openxmlformats-package.relationships+xml" Extension="rels"/>\n' +
+            '  <Default ContentType="application/xml" Extension="xml"/>\n' +
+            '  <Override ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml" PartName="/docProps/app.xml"/>\n' +
+            '  <Override ContentType="application/vnd.openxmlformats-package.core-properties+xml" PartName="/docProps/core.xml"/>\n' +
+            '  <Override ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml" PartName="/xl/sharedStrings.xml"/>\n' +
+            '  <Override ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml" PartName="/xl/workbook.xml"/>\n' +
+            '  <Override ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml" PartName="/xl/worksheets/sheet1.xml"/>\n' +
+            '</Types>';
+        this.WORKBOOK_RELS_XML = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+            '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">\n' +
+            '  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" Target="sharedStrings.xml"/>\n' +
+            '  <Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/>\n' +
+            '</Relationships>';
+        this.SHARED_STRINGS_XML = '<?xml version="1.0" encoding="UTF-8"?>\n' +
+            '<sst count="0" uniqueCount="0" xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"/>';
+    }
+    generateWorkbookXml(sheetName = 'Measurements') {
+        return ('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+            `<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><sheets><sheet name='${sheetName}' r:id="rId3" sheetId="1"/></sheets></workbook>`);
+    }
+    generateSheetXml(data) {
+        const headers = data[0];
+        const colsXml = this.generateColsXml(headers);
+        const rowsXml = this.generateRowsXml(data);
+        return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+      <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+        <cols>${colsXml}</cols>
+        <sheetData>${rowsXml}</sheetData>
+      </worksheet>`;
+    }
+    generateAppXml(name) {
+        return ('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+            '<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes">\n' +
+            `  <Application>${name}</Application>\n` +
+            '  <DocSecurity>0</DocSecurity>\n' +
+            '  <ScaleCrop>false</ScaleCrop>\n' +
+            '  <HeadingPairs>\n' +
+            '    <vt:vector size="2" baseType="variant">\n' +
+            '      <vt:variant>\n' +
+            '        <vt:lpstr>Worksheets</vt:lpstr>\n' +
+            '      </vt:variant>\n' +
+            '      <vt:variant>\n' +
+            '        <vt:i4>1</vt:i4>\n' +
+            '      </vt:variant>\n' +
+            '    </vt:vector>\n' +
+            '  </HeadingPairs>\n' +
+            '  <TitlesOfParts>\n' +
+            '    <vt:vector size="1" baseType="lpstr">\n' +
+            '      <vt:lpstr>Sheet1</vt:lpstr>\n' +
+            '    </vt:vector>\n' +
+            '  </TitlesOfParts>\n' +
+            '  <Company></Company>\n' +
+            '  <LinksUpToDate>false</LinksUpToDate>\n' +
+            '  <SharedDoc>false</SharedDoc>\n' +
+            '  <HyperlinksChanged>false</HyperlinksChanged>\n' +
+            '  <AppVersion>16.0300</AppVersion>\n' +
+            '</Properties>');
+    }
+    generateCoreXml(name) {
+        const now = new Date().toISOString();
+        return ('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+            '<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:dcmitype="http://purl.org/dc/dcmitype/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">\n' +
+            `  <dc:creator>${name}</dc:creator>\n` +
+            `  <cp:lastModifiedBy>${name}</cp:lastModifiedBy>\n` +
+            `  <dcterms:created xsi:type="dcterms:W3CDTF">${now}</dcterms:created>\n` +
+            `  <dcterms:modified xsi:type="dcterms:W3CDTF">${now}</dcterms:modified>\n` +
+            '</cp:coreProperties>');
+    }
+    generateColsXml(headers) {
+        return headers
+            .map((header, index) => {
+            const width = this.columnWidths[header] || this.defaultWidth;
+            return `<col min="${index + 1}" max="${index + 1}" width="${width}" customWidth="1"/>`;
+        })
+            .join('');
+    }
+    generateRowsXml(data) {
+        return data
+            .map(row => `<row>${row
+            .map(cell => {
+            if (isNil(cell) || isEmpty(cell)) {
+                return `<c t="inlineStr"><is><t></t></is></c>`; // String cell
+            }
+            else if (isNumber(Number(cell)) && !isNaN(Number(cell))) {
+                return `<c t="n"><v>${Number(cell)}</v></c>`; // Number cell
+            }
+            else {
+                return `<c t="inlineStr"><is><t>${XmlUtils.escapeXml(cell)}</t></is></c>`; // String cell
+            }
+        })
+            .join('')}</row>`)
+            .join('');
+    }
+}
+class ZipFileCreator {
+    async createZipFile(contents, compressionType, compressionLevel) {
+        const zip = new JSZip();
+        const blob = 'blob';
+        contents.forEach((content, filename) => {
+            zip.file(filename, content);
+        });
+        const options = { type: blob };
+        if (compressionType !== FILE_COMPRESSION_TYPES_VALUES.store) {
+            options.compression = compressionType;
+            options.compressionOptions = { level: compressionLevel };
+        }
+        return (await zip.generateAsync(options));
+    }
+}
+class ExcelGenerator {
+    static getLabel() {
+        return gettext('Microsoft Excel');
+    }
+    static getTitle() {
+        return 'Excel';
+    }
+    static getType() {
+        return 'excel';
+    }
+    static getIcon() {
+        return 'excel';
+    }
+    static getFileExtension() {
+        return 'xlsx';
+    }
+    static getAcceptType() {
+        return 'application/vnd.ms-excel';
+    }
+    static getMimeType() {
+        return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+    }
+    static getZipName() {
+        return 'export_excel.zip';
+    }
+    static async convertToMergedExcel(exportData, mergedExportDetails) {
+        const instance = ExcelGenerator.getInstance();
+        const { timeSeries, uniqueColumnIdentifiers } = instance.dataTransformer.transformToMergedFormat(exportData);
+        const rows = [
+            instance.createMergedFileHeaderRow(uniqueColumnIdentifiers, mergedExportDetails),
+            ...instance.createMergedFileDataRows(timeSeries, uniqueColumnIdentifiers)
+        ];
+        return instance.createExcelFile(rows, mergedExportDetails);
+    }
+    static getInstance() {
+        if (!ExcelGenerator.instance) {
+            ExcelGenerator.instance = new ExcelGenerator();
+        }
+        return ExcelGenerator.instance;
+    }
+    constructor() {
+        this.dataTransformer = new ExcelDataTransformer();
+        this.xmlGenerator = new ExcelXmlGenerator();
+        this.fileCreator = new ZipFileCreator();
+    }
+    async createExcelFile(data, details) {
+        const contents = new Map([
+            ['[Content_Types].xml', this.xmlGenerator.CONTENT_TYPES_XML],
+            ['_rels/.rels', this.xmlGenerator.RELS_XML],
+            [
+                'xl/workbook.xml',
+                this.xmlGenerator.generateWorkbookXml(details?.aggregation ? details?.aggregation : 'NO AGGREGATION')
+            ],
+            ['xl/worksheets/sheet1.xml', this.xmlGenerator.generateSheetXml(data)],
+            ['xl/sharedStrings.xml', this.xmlGenerator.SHARED_STRINGS_XML],
+            ['docProps/app.xml', this.xmlGenerator.generateAppXml('Custom Script')],
+            ['docProps/core.xml', this.xmlGenerator.generateCoreXml('Custom Script')],
+            ['xl/_rels/workbook.xml.rels', this.xmlGenerator.WORKBOOK_RELS_XML]
+        ]);
+        return this.fileCreator.createZipFile(contents, FILE_COMPRESSION_TYPES_VALUES.deflate, 9);
+    }
+    createMergedFileHeaderRow(uniqueColumnIdentifiers, details) {
+        const time = details ? `time => from ${details.dateFrom} to ${details.dateTo}` : 'time';
+        return [time, ...uniqueColumnIdentifiers];
+    }
+    createMergedFileDataRows(timeSeries, uniqueColumnIdentifiers) {
+        return Array.from(timeSeries.entries())
+            .filter(([time, values]) => this.isValidEntry(time, values))
+            .map(([time, values]) => this.createDataRow(time, values, uniqueColumnIdentifiers));
+    }
+    isValidEntry(time, values) {
+        return (time !== null && Object.values(values).some(value => value !== null && value !== undefined));
+    }
+    createDataRow(time, values, uniqueColumnIdentifiers) {
+        const row = [time];
+        uniqueColumnIdentifiers.forEach(key => {
+            const value = values[key];
+            row.push(value !== undefined && value !== null ? value.toString() : '');
+        });
+        return row;
+    }
+}
+const ExcelGeneratorAdapter = {
+    getLabel: ExcelGenerator.getLabel.bind(ExcelGenerator),
+    getIcon: ExcelGenerator.getIcon.bind(ExcelGenerator),
+    getFileExtension: ExcelGenerator.getFileExtension.bind(ExcelGenerator),
+    getMimeType: ExcelGenerator.getMimeType.bind(ExcelGenerator),
+    generateMerged: ExcelGenerator.convertToMergedExcel.bind(ExcelGenerator),
+    getType: ExcelGenerator.getType.bind(ExcelGenerator),
+    getTitle: ExcelGenerator.getTitle.bind(ExcelGenerator),
+    getZipName: ExcelGenerator.getZipName.bind(ExcelGenerator),
+    getAcceptType: ExcelGenerator.getAcceptType.bind(ExcelGenerator)
+};
+
+const FILE_GENERATORS = new InjectionToken('FILE_GENERATORS', {
+    providedIn: 'root',
+    factory: () => [ExcelGeneratorAdapter, CSVGeneratorAdapter]
+});
+const dateRangeValidator = (control) => {
+    const dateFrom = control.get('dateFrom');
+    const dateTo = control.get('dateTo');
+    if (!dateFrom || !dateTo) {
+        return null;
+    }
+    const dateFromValue = dateFrom.value;
+    const dateToValue = dateTo.value;
+    if (dateFromValue && dateToValue) {
+        if (new Date(dateFromValue) > new Date(dateToValue)) {
+            dateFrom.setErrors({ dateAfterRangeMax: true });
+            dateTo.setErrors({ dateBeforeRangeMin: true });
+        }
+        else {
+            dateFrom.setErrors(null);
+            dateTo.setErrors(null);
+        }
+    }
+    return null;
+};
+class DatapointsExportSelectorFileExporterComponent {
+    constructor(datapointsExportModalService, datapointsExportSelectorService, datapointsExportSelectorFileExporterService, formBuilder, generators) {
+        this.datapointsExportModalService = datapointsExportModalService;
+        this.datapointsExportSelectorService = datapointsExportSelectorService;
+        this.datapointsExportSelectorFileExporterService = datapointsExportSelectorFileExporterService;
+        this.formBuilder = formBuilder;
+        this.generators = generators;
+        this.onDownloadButtonStateChange = new EventEmitter();
+        /**
+         * Represents aggregation selector options that are disabled.
+         * This state is determined based on the current date range.
+         */
+        this.disabledAggregationOptions = {};
+        /**
+         * Contains all datapoints that number of records exceeds a threshold, where data for these datapoints will be processed by the backend.
+         * Applies only to measurement API which can return processed CSV, Excel or XML data.
+         */
+        this.datapointsExceedingBrowserDownloadLimit = [];
+        /**
+         * Indicates whether any of DataToExport objects timeValueMap property is not undefined (series data)
+         * or dataPointToExport is not undefined at all (measurement data).
+         */
+        this.hasFetchedDataAnyValuesToExport = false;
+        this.hasPermissionToReadAnyMeasurements = false;
+        this.isPreviewLoading = true;
+        /**
+         * Indicates whether the full or compact type of export is selected.
+         * Full type of export is based on measurement API data.
+         * Compact type of export is based on series API data.
+         */
+        this.isFullTypeOfExport = false;
+        /**
+         * Indicates whether the aggregation value was changed programmatically.
+         * It prevents a case where fetching may be triggered twice when export type is changed.
+         * Both options alone can trigger fetching data.
+         */
+        this.isAggregationChangedProgrammatically = false;
+        /**
+         * Indicates whether any of the export file types (CSV, Excel) are checked.
+         */
+        this.isAnyOfExportFileTypeChecked = false;
+        this.dateFromSubject = new Subject();
+        this.dateToSubject = new Subject();
+        this.destroy$ = new Subject();
+        this.dynamicFilesTypeMetadata = {};
+        this.setFilesType(this.generators);
+        this.dateFromSubject
+            .pipe(debounceTime(300), takeUntilDestroyed())
+            .subscribe(async (updatedDate) => {
+            await this.updateDateAndFetchData('dateFrom', updatedDate);
+        });
+        this.dateToSubject
+            .pipe(debounceTime(300), takeUntilDestroyed())
+            .subscribe(async (updatedDate) => {
+            await this.updateDateAndFetchData('dateTo', updatedDate);
+        });
+    }
+    setFilesType(generators) {
+        generators.forEach(g => {
+            this.dynamicFilesTypeMetadata[g.getType()] = {
+                label: g.getLabel(),
+                icon: g.getIcon(),
+                title: g.getTitle(),
+                extension: g.getFileExtension(),
+                zipName: g.getZipName(),
+                type: g.getType()
+            };
+        });
+    }
+    async ngOnInit() {
+        const sourcesPermittedToRead = await this.datapointsExportSelectorService.getSourcesWithPermissionsToRead(this.exportConfig.datapointDetails);
+        if (sourcesPermittedToRead.length === 0) {
+            return;
+        }
+        if (sourcesPermittedToRead.length !== this.exportConfig.datapointDetails.length) {
+            this.exportConfig.datapointDetails = this.exportConfig.datapointDetails.filter(dataPoint => sourcesPermittedToRead.includes(String(dataPoint.source)));
+        }
+        this.hasPermissionToReadAnyMeasurements = true;
+        this.storeInitialChangeableConfig();
+        this.fileTypeSelectionState = this.getInitialSelection(this.dynamicFilesTypeMetadata, [0]);
+        this.formGroup = this.createForm();
+        this.dataToExport = await this.datapointsExportSelectorService.fetchAndPrepareDataToExport(this.exportConfig, this.isFullTypeOfExport);
+        this.handleDateSelectorChanges();
+        this.determineShowingPreviewOrEmptyState();
+        this.handleExportModeChanges();
+        this.handleFileTypeSelectionChanges();
+        this.handleFormValidationChanges();
+        this.updateFileTypeControl();
+        this.updateDisabledAggregationOptionsState();
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.loadInitialChangeableConfig();
+    }
+    async exportAndDownload() {
+        const fileExports = Object.entries(this.dynamicFilesTypeMetadata).map(([_, value]) => ({
+            fileType: value.type,
+            zipName: value.zipName
+        }));
+        const selectedFileExports = this.getOnlySelectedFileExports(fileExports);
+        await Promise.all(selectedFileExports.map(async ({ fileType, zipName }) => {
+            const blob = await this.exportFile(fileType);
+            await this.downloadFile(blob, fileType, zipName);
+        }));
+        this.datapointsExportSelectorFileExporterService.cleanupCachedData();
+    }
+    getOnlySelectedFileExports(fileExports) {
+        return fileExports.filter(f => this.fileTypeSelectionState[f.fileType] === true);
+    }
+    async exportFile(fileType) {
+        return this.isFullTypeOfExport
+            ? await this.exportMeasurementFile(fileType)
+            : await this.exportSeriesFile(fileType);
+    }
+    async downloadFile(blob, fileType, measurementsZipFileName) {
+        this.datapointsExceedingBrowserDownloadLimit =
+            this.datapointsExceedingBrowserDownloadLimit.filter(datapoint => !this.dataPointsExceedingOneMillionLimit.includes(datapoint));
+        const shouldShowAlert = this.datapointsExceedingBrowserDownloadLimit.length > 0;
+        // Handles a case where all files are sent by email.
+        if (!blob && shouldShowAlert) {
+            this.datapointsExportSelectorService.showSendViaEmailInfoAlert(fileType, this.datapointsExceedingBrowserDownloadLimit);
+            return;
+        }
+        if (blob) {
+            // Handles the case where some of the files are sent by email.
+            if (shouldShowAlert) {
+                this.datapointsExportSelectorService.showSendViaEmailInfoAlert(fileType, this.datapointsExceedingBrowserDownloadLimit);
+            }
+            this.isFullTypeOfExport
+                ? saveAs(blob, measurementsZipFileName)
+                : saveAs(blob, blob[SERIES_DATA_MERGED_FILE_NAME]);
+        }
+    }
+    /**
+     * Exports a measurement file of the specified type.
+     *
+     * Measurements API does provide a way to fetch a preprocessed CSV/Excel file.
+     *
+     * At this point a backed file needs to be fetched.
+     * Measurement data used for a preview contains just 5 first records
+     * and it's not fetched with CSV/Excel headers.
+     *
+     * @param fileType - The type of file to export.
+     * @returns A Promise that resolves to a Blob representing the exported file or null when no data to export or it's sent via email.
+     */
+    async exportMeasurementFile(fileType) {
+        const { acceptType, extension } = this.datapointsExportModalService.fileTypesConfigs[fileType];
+        const updatedExportConfig = this.excludeDatapointsThatExceedsApiLimit(this.exportConfig);
+        const dataToExport = await this.datapointsExportSelectorService.fetchMeasurementDataFilesAndPairWithSourceDetails(acceptType, updatedExportConfig);
+        const isAllUndefined = dataToExport.every(data => data === undefined);
+        if (isAllUndefined) {
+            return null;
+        }
+        return this.datapointsExportSelectorFileExporterService.getMeasurementExportedDataBlob(extension, dataToExport);
+    }
+    excludeDatapointsThatExceedsApiLimit(exportConfig) {
+        const skippedDatapointsSource = this.dataPointsExceedingOneMillionLimit.map(datapoint => datapoint.datapointDetail.source.toString());
+        const filteredDatapoints = exportConfig.datapointDetails.filter(datapoint => !skippedDatapointsSource.includes(String(datapoint.source)));
+        exportConfig.datapointDetails = filteredDatapoints;
+        return exportConfig;
+    }
+    /**
+     * Exports the series data to a file of the specified type.
+     *
+     * Series API does not provide a way to fetch a preprocessed CSV/Excel file.
+     *
+     * Series data used for exporting a file is already fetched for a preview
+     * and can be reused for exporting.
+     *
+     * @param fileType - The type of file to export (e.g., CSV, Excel).
+     * @returns A Promise that resolves to a Blob representing the exported file.
+     */
+    async exportSeriesFile(fileType) {
+        const mergedExportDetails = {
+            aggregation: this.exportConfig.aggregation,
+            dateFrom: this.exportConfig.dateFrom,
+            dateTo: this.exportConfig.dateTo
+        };
+        return this.datapointsExportSelectorFileExporterService.getSeriesExportedDataBlob(fileType, this.dataToExport, mergedExportDetails);
+    }
+    async onAggregationChange(aggregation) {
+        this.exportConfig.aggregation = aggregation;
+        if (!this.isAggregationChangedProgrammatically) {
+            await this.updateExportConfigAndFetchData();
+            this.updateDownloadButtonState();
+        }
+    }
+    onDateFromChange(updatedDate) {
+        this.dateFromSubject.next(updatedDate);
+    }
+    onDateToChange(updatedDate) {
+        this.dateToSubject.next(updatedDate);
+    }
+    async updateDateAndFetchData(dateType, updatedDate) {
+        this.exportConfig[dateType] = updatedDate;
+        await this.updateExportConfigAndFetchData();
+        if (this.isFullTypeOfExport) {
+            await this.determineIfMeasurementResponseWillBeProcessedByBackend();
+        }
+        else {
+            this.updateDownloadButtonState();
+        }
+    }
+    async onExportTypeChange(exportType) {
+        if (exportType === EXPORT_MODE_VALUES.full) {
+            this.isAggregationChangedProgrammatically = true;
+            this.formGroup.controls.aggregation.setValue(AGGREGATION_VALUES.none);
+            this.isAggregationChangedProgrammatically = false;
+            this.isFullTypeOfExport = true;
+            await this.updateExportConfigAndFetchData();
+            await this.determineIfMeasurementResponseWillBeProcessedByBackend();
+            return;
+        }
+        this.resetFullExportRelatedProperties();
+        this.isFullTypeOfExport = false;
+        await this.updateExportConfigAndFetchData();
+        this.updateDisabledAggregationOptionsState();
+        this.updateDownloadButtonState();
+    }
+    updateDisabledAggregationOptionsState() {
+        this.disabledAggregationOptions =
+            this.datapointsExportSelectorFileExporterService.updateDisabledStateOfAggregationOptionEntries(this.formGroup.controls.dateFrom.value, this.formGroup.controls.dateTo.value, this.disabledAggregationOptions);
+    }
+    createForm() {
+        return this.formBuilder.group({
+            dateFrom: new FormControl(this.exportConfig.dateFrom),
+            dateTo: new FormControl(this.exportConfig.dateTo),
+            aggregation: new FormControl(this.exportConfig.aggregation ? this.exportConfig.aggregation : AGGREGATION_VALUES.none),
+            exportMode: new FormControl(EXPORT_MODE_VALUES.compact),
+            fileTypes: this.formBuilder.group(this.generators.reduce((a, c) => {
+                a[c.getType()] = false;
+                return a;
+            }, {}))
+        }, {
+            validators: [dateRangeValidator]
+        });
+    }
+    preparePreview() {
+        this.isPreviewLoading = true;
+        this.previewTableData =
+            this.datapointsExportModalService.transformToExportFileStructureForPreview(this.dataToExport);
+        this.isPreviewLoading = false;
+    }
+    handleDateSelectorChanges() {
+        const aggregationControl = this.formGroup.controls.aggregation;
+        const dateFromSelector = this.formGroup.controls.dateFrom;
+        const dateToSelector = this.formGroup.controls.dateTo;
+        const updateAggregationOptions = () => {
+            if (!this.isFullTypeOfExport) {
+                this.updateDisabledAggregationOptionsState();
+                const firstAvailableAggregationValue = this.datapointsExportSelectorFileExporterService.setToFirstAvailableAggregationOptionIfCurrentIsDisabled(aggregationControl.value, this.disabledAggregationOptions);
+                if (firstAvailableAggregationValue) {
+                    aggregationControl.setValue(firstAvailableAggregationValue);
+                }
+            }
+        };
+        merge(dateFromSelector.valueChanges, dateToSelector.valueChanges)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(updateAggregationOptions);
+    }
+    handleExportModeChanges() {
+        const aggregationControl = this.formGroup.controls.aggregation;
+        this.formGroup.controls.exportMode.valueChanges
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(exportModeValue => {
+            if (exportModeValue.toString() === EXPORT_MODE_VALUES.full) {
+                aggregationControl.disable();
+            }
+            else {
+                aggregationControl.enable();
+            }
+        });
+    }
+    handleFileTypeSelectionChanges() {
+        this.formGroup.controls.fileTypes.valueChanges
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(fileTypesSelectionState => {
+            this.updateFileTypeSelectionState(fileTypesSelectionState);
+        });
+    }
+    updateFileTypeSelectionState(checkboxesState) {
+        this.isAnyOfExportFileTypeChecked = Object.values(checkboxesState).some(value => value === true);
+        this.fileTypeSelectionState = checkboxesState;
+        this.updateDownloadButtonState();
+    }
+    handleFormValidationChanges() {
+        this.formGroup.statusChanges.pipe(takeUntil(this.destroy$)).subscribe(() => {
+            this.updateDownloadButtonState();
+        });
+    }
+    updateFileTypeControl() {
+        const fileTypesControl = this.formGroup.controls.fileTypes;
+        if (fileTypesControl) {
+            const currentValue = fileTypesControl.value || {};
+            const updatedValue = { ...currentValue };
+            Object.entries(this.fileTypeSelectionState).forEach(([fileType, isSelected]) => {
+                if (fileType in currentValue) {
+                    updatedValue[fileType] = isSelected;
+                }
+            });
+            fileTypesControl.patchValue(updatedValue);
+        }
+    }
+    determineShowingPreviewOrEmptyState() {
+        const hasDataToShow = this.dataToExport.some(dataToExportItem => this.isFullTypeOfExport
+            ? !!dataToExportItem
+            : dataToExportItem.timeValueMap && Object.keys(dataToExportItem.timeValueMap).length > 0);
+        this.hasFetchedDataAnyValuesToExport = hasDataToShow;
+        if (hasDataToShow) {
+            this.preparePreview();
+        }
+        else {
+            this.isPreviewLoading = false;
+        }
+    }
+    async determineIfMeasurementResponseWillBeProcessedByBackend() {
+        this.isPreviewLoading = true;
+        this.datapointsExceedingBrowserDownloadLimit =
+            await this.datapointsExportSelectorService.getDatapointsExceedingLimit(this.exportConfig);
+        const { browserDownloadableCount, emailDeliverableCount, nonRetrievableCount } = this.calculateDatapointCounts();
+        this.hasNoExportableData =
+            browserDownloadableCount === 0 && emailDeliverableCount === 0 && nonRetrievableCount > 0;
+        if (this.datapointsExceedingBrowserDownloadLimit.length > 0 && !this.hasNoExportableData) {
+            this.limitExceededMessage = this.datapointsExportSelectorService.getLimitExceededMessage(this.hasNoExportableData, emailDeliverableCount, browserDownloadableCount, nonRetrievableCount, this.exportConfig.datapointDetails.length);
+        }
+        if (this.datapointsExceedingBrowserDownloadLimit.length > 0 && this.hasNoExportableData) {
+            this.limitExceededMessage = this.datapointsExportSelectorService.getLimitExceededMessage(this.hasNoExportableData);
+        }
+        this.updateDownloadButtonState();
+        this.isPreviewLoading = false;
+    }
+    calculateDatapointCounts() {
+        const RECORD_API_LIMIT = 1_000_000;
+        this.dataPointsExceedingOneMillionLimit = this.datapointsExceedingBrowserDownloadLimit.filter(datapointsExceedingBrowserDownloadLimit => datapointsExceedingBrowserDownloadLimit.totalElements > RECORD_API_LIMIT);
+        const nonRetrievableCount = this.dataPointsExceedingOneMillionLimit.length;
+        const emailDeliverableCount = this.datapointsExceedingBrowserDownloadLimit.length - nonRetrievableCount;
+        const browserDownloadableCount = this.exportConfig.datapointDetails.length - emailDeliverableCount - nonRetrievableCount;
+        return {
+            browserDownloadableCount,
+            emailDeliverableCount,
+            nonRetrievableCount
+        };
+    }
+    storeInitialChangeableConfig() {
+        this.initialDateFrom = this.exportConfig.dateFrom;
+        this.initialDateTo = this.exportConfig.dateTo;
+        this.initialDatapointDetails = this.exportConfig.datapointDetails;
+        if (!this.isFullTypeOfExport) {
+            this.initialAggregation = this.exportConfig.aggregation;
+        }
+    }
+    loadInitialChangeableConfig() {
+        this.exportConfig.dateFrom = this.initialDateFrom;
+        this.exportConfig.dateTo = this.initialDateTo;
+        this.exportConfig.datapointDetails = this.initialDatapointDetails;
+        if (!this.isFullTypeOfExport) {
+            this.exportConfig.aggregation = this.initialAggregation;
+        }
+    }
+    async updateExportConfigAndFetchData() {
+        if (this.formGroup.invalid) {
+            return;
+        }
+        this.isPreviewLoading = true;
+        this.onDownloadButtonStateChange.emit(false);
+        this.dataToExport = await this.datapointsExportSelectorService.fetchAndPrepareDataToExport(this.exportConfig, this.isFullTypeOfExport);
+        this.determineShowingPreviewOrEmptyState();
+    }
+    updateDownloadButtonState() {
+        const canEnableDownloadButton = this.hasFetchedDataAnyValuesToExport &&
+            !this.formGroup.invalid &&
+            this.isAnyOfExportFileTypeChecked &&
+            !this.hasNoExportableData;
+        this.onDownloadButtonStateChange.emit(canEnableDownloadButton);
+    }
+    resetFullExportRelatedProperties() {
+        this.hasNoExportableData = false;
+        this.datapointsExceedingBrowserDownloadLimit = [];
+    }
+    getInitialSelection(fileType, selectByDefault) {
+        const keys = Object.keys(fileType);
+        if (keys.length === 0) {
+            return {};
+        }
+        const initialSelection = keys.reduce((acc, key) => {
+            acc[key] = false;
+            return acc;
+        }, {});
+        selectByDefault.forEach(index => {
+            if (index >= 0 && index < keys.length) {
+                initialSelection[keys[index]] = true;
+            }
+        });
+        return initialSelection;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsExportSelectorFileExporterComponent, deps: [{ token: DataProcessingService }, { token: DataFetchingService }, { token: DatapointsExportSelectorFileExporterService }, { token: i3$2.FormBuilder }, { token: FILE_GENERATORS }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: DatapointsExportSelectorFileExporterComponent, isStandalone: true, selector: "c8y-datapoints-export-selector-file-exporter", inputs: { exportConfig: "exportConfig" }, outputs: { onDownloadButtonStateChange: "onDownloadButtonStateChange" }, ngImport: i0, template: "<div class=\"p-b-16\">\n  <ng-container *ngIf=\"hasPermissionToReadAnyMeasurements; else hasNoRoleToReadAnyMeasurements\">\n    <div class=\"p-16 text-center separator-bottom sticky-top bg-component\">\n      <p class=\"text-medium text-16\">\n        {{ 'Configure export' | translate }}\n      </p>\n    </div>\n    <div\n      class=\"p-t-24 p-r-16 p-l-16 gap-8 p-b-16 flex-wrap\"\n      [ngClass]=\"{ 'separator-bottom': isFullTypeOfExport }\"\n    >\n      <div class=\"row\">\n        <div class=\"col-md-4\">\n          <c8y-datapoints-export-selector-time-range\n            *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n            [formGroup]=\"formGroup\"\n            (onDateFromChange)=\"onDateFromChange($event)\"\n            (onDateToChange)=\"onDateToChange($event)\"\n          ></c8y-datapoints-export-selector-time-range>\n        </div>\n        <div class=\"col-md-4\">\n          <c8y-datapoints-export-selector-data-scope\n            *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n            [disabledAggregationOptions]=\"disabledAggregationOptions\"\n            [formGroup]=\"formGroup\"\n            (onAggregationChange)=\"onAggregationChange($event)\"\n            (onExportTypeChange)=\"onExportTypeChange($event)\"\n          ></c8y-datapoints-export-selector-data-scope>\n        </div>\n        <div class=\"col-md-4\">\n          <c8y-datapoints-export-selector-file-types\n            *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n            [dynamicFilesTypeMetadata]=\"dynamicFilesTypeMetadata\"\n            [formGroup]=\"formGroup\"\n          ></c8y-datapoints-export-selector-file-types>\n        </div>\n      </div>\n    </div>\n    <ng-container\n      *ngIf=\"!isFullTypeOfExport && !hasFetchedDataAnyValuesToExport && !isPreviewLoading\"\n    >\n      <div class=\"p-t-24 p-r-16 p-l-16 p-b-16 separator-bottom d-flex\">\n        <div\n          class=\"alert alert-warning center-block\"\n          role=\"alert\"\n          data-cy=\"file-exporter--no-data-available\"\n          translate\n        >\n          No data available.\n        </div>\n      </div>\n    </ng-container>\n    <ng-container *ngIf=\"datapointsExceedingBrowserDownloadLimit.length > 0\">\n      <div class=\"p-t-24 p-r-16 p-l-16 p-b-16 separator-bottom d-flex\">\n        <div\n          [class]=\"\n            hasNoExportableData\n              ? 'alert alert-warning center-block'\n              : 'alert alert-info center-block'\n          \"\n          role=\"alert\"\n          [innerHTML]=\"limitExceededMessage\"\n        ></div>\n      </div>\n    </ng-container>\n    <ng-container *ngIf=\"isFullTypeOfExport\">\n      <c8y-datapoints-export-selector-preview\n        *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n        [hasFetchedDataAnyValuesToExport]=\"hasFetchedDataAnyValuesToExport\"\n        [isPreviewLoading]=\"isPreviewLoading\"\n        [previewTableData]=\"previewTableData\"\n      ></c8y-datapoints-export-selector-preview>\n    </ng-container>\n  </ng-container>\n  <ng-template #hasNoRoleToReadAnyMeasurements>\n    <div class=\"p-t-24 p-r-16 p-l-16 p-b-16 d-flex\">\n      <div\n        class=\"alert alert-info center-block\"\n        role=\"alert\"\n        translate\n      >\n        <p>To export data, you must meet at least one of these criteria:</p>\n        <ul>\n          <li>\n            Have\n            <b>READ permission for \"Measurements\" permission type</b>\n            (either as a global role or for the specific source)\n          </li>\n          <li>\n            Be the\n            <b>owner of the source</b>\n            you want to export data from\n          </li>\n        </ul>\n        <p>Don't meet these requirements? Contact your system administrator for assistance.</p>\n      </div>\n    </div>\n  </ng-template>\n</div>\n", dependencies: [{ kind: "ngmodule", type: CoreModule }, { kind: "pipe", type: i1.C8yTranslatePipe, name: "translate" }, { kind: "directive", type: i1.C8yTranslateDirective, selector: "[translate],[ngx-translate]" }, { kind: "directive", type: i2$1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3$2.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i3$2.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: DataPointsExportSelectorDataScopeComponent, selector: "c8y-datapoints-export-selector-data-scope", inputs: ["disabledAggregationOptions", "formGroup"], outputs: ["onAggregationChange", "onExportTypeChange"] }, { kind: "component", type: DataPointsExportSelectorFileTypesComponent, selector: "c8y-datapoints-export-selector-file-types", inputs: ["dynamicFilesTypeMetadata", "formGroup"] }, { kind: "component", type: DataPointsExportSelectorPreviewComponent, selector: "c8y-datapoints-export-selector-preview", inputs: ["hasFetchedDataAnyValuesToExport", "isPreviewLoading", "previewTableData"] }, { kind: "component", type: DataPointsExportSelectorTimeRangeComponent, selector: "c8y-datapoints-export-selector-time-range", inputs: ["formGroup"], outputs: ["onDateFromChange", "onDateToChange"] }, { kind: "ngmodule", type: ReactiveFormsModule }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsExportSelectorFileExporterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'c8y-datapoints-export-selector-file-exporter', standalone: true, imports: [
+                        CoreModule,
+                        DataPointsExportSelectorDataScopeComponent,
+                        DataPointsExportSelectorFileTypesComponent,
+                        DataPointsExportSelectorPreviewComponent,
+                        DataPointsExportSelectorTimeRangeComponent,
+                        KeyValuePipe,
+                        ReactiveFormsModule
+                    ], template: "<div class=\"p-b-16\">\n  <ng-container *ngIf=\"hasPermissionToReadAnyMeasurements; else hasNoRoleToReadAnyMeasurements\">\n    <div class=\"p-16 text-center separator-bottom sticky-top bg-component\">\n      <p class=\"text-medium text-16\">\n        {{ 'Configure export' | translate }}\n      </p>\n    </div>\n    <div\n      class=\"p-t-24 p-r-16 p-l-16 gap-8 p-b-16 flex-wrap\"\n      [ngClass]=\"{ 'separator-bottom': isFullTypeOfExport }\"\n    >\n      <div class=\"row\">\n        <div class=\"col-md-4\">\n          <c8y-datapoints-export-selector-time-range\n            *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n            [formGroup]=\"formGroup\"\n            (onDateFromChange)=\"onDateFromChange($event)\"\n            (onDateToChange)=\"onDateToChange($event)\"\n          ></c8y-datapoints-export-selector-time-range>\n        </div>\n        <div class=\"col-md-4\">\n          <c8y-datapoints-export-selector-data-scope\n            *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n            [disabledAggregationOptions]=\"disabledAggregationOptions\"\n            [formGroup]=\"formGroup\"\n            (onAggregationChange)=\"onAggregationChange($event)\"\n            (onExportTypeChange)=\"onExportTypeChange($event)\"\n          ></c8y-datapoints-export-selector-data-scope>\n        </div>\n        <div class=\"col-md-4\">\n          <c8y-datapoints-export-selector-file-types\n            *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n            [dynamicFilesTypeMetadata]=\"dynamicFilesTypeMetadata\"\n            [formGroup]=\"formGroup\"\n          ></c8y-datapoints-export-selector-file-types>\n        </div>\n      </div>\n    </div>\n    <ng-container\n      *ngIf=\"!isFullTypeOfExport && !hasFetchedDataAnyValuesToExport && !isPreviewLoading\"\n    >\n      <div class=\"p-t-24 p-r-16 p-l-16 p-b-16 separator-bottom d-flex\">\n        <div\n          class=\"alert alert-warning center-block\"\n          role=\"alert\"\n          data-cy=\"file-exporter--no-data-available\"\n          translate\n        >\n          No data available.\n        </div>\n      </div>\n    </ng-container>\n    <ng-container *ngIf=\"datapointsExceedingBrowserDownloadLimit.length > 0\">\n      <div class=\"p-t-24 p-r-16 p-l-16 p-b-16 separator-bottom d-flex\">\n        <div\n          [class]=\"\n            hasNoExportableData\n              ? 'alert alert-warning center-block'\n              : 'alert alert-info center-block'\n          \"\n          role=\"alert\"\n          [innerHTML]=\"limitExceededMessage\"\n        ></div>\n      </div>\n    </ng-container>\n    <ng-container *ngIf=\"isFullTypeOfExport\">\n      <c8y-datapoints-export-selector-preview\n        *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n        [hasFetchedDataAnyValuesToExport]=\"hasFetchedDataAnyValuesToExport\"\n        [isPreviewLoading]=\"isPreviewLoading\"\n        [previewTableData]=\"previewTableData\"\n      ></c8y-datapoints-export-selector-preview>\n    </ng-container>\n  </ng-container>\n  <ng-template #hasNoRoleToReadAnyMeasurements>\n    <div class=\"p-t-24 p-r-16 p-l-16 p-b-16 d-flex\">\n      <div\n        class=\"alert alert-info center-block\"\n        role=\"alert\"\n        translate\n      >\n        <p>To export data, you must meet at least one of these criteria:</p>\n        <ul>\n          <li>\n            Have\n            <b>READ permission for \"Measurements\" permission type</b>\n            (either as a global role or for the specific source)\n          </li>\n          <li>\n            Be the\n            <b>owner of the source</b>\n            you want to export data from\n          </li>\n        </ul>\n        <p>Don't meet these requirements? Contact your system administrator for assistance.</p>\n      </div>\n    </div>\n  </ng-template>\n</div>\n" }]
+        }], ctorParameters: () => [{ type: DataProcessingService }, { type: DataFetchingService }, { type: DatapointsExportSelectorFileExporterService }, { type: i3$2.FormBuilder }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [FILE_GENERATORS]
+                }] }], propDecorators: { exportConfig: [{
+                type: Input
+            }], onDownloadButtonStateChange: [{
+                type: Output
+            }] } });
+
+class DataProcessingService {
+    constructor(fileGenerators, utils) {
+        this.fileGenerators = fileGenerators;
+        this.utils = utils;
+        this.mergeMapping = {};
+        this.setGenerators(this.fileGenerators);
+        this.fileTypesConfigs = this.fileGenerators.reduce((acc, g) => {
+            acc[g.getType()] = {
+                extension: g.getFileExtension(),
+                mimeType: g.getMimeType(),
+                acceptType: g.getAcceptType()
+            };
+            return acc;
+        }, {});
+    }
+    setGenerators(fileGenerators) {
+        fileGenerators.forEach(g => {
+            this.mergeMapping[g.getType()] = g.generateMerged;
+        });
+    }
+    /**
+     * Transforms the data into a structured format for an export.
+     *
+     * @param dataToExport - An array of processed measurement data combined with the respective properties of the datapoint.
+     * @returns Provides a two-dimensional array of ExportData,
+     *          where each inner array contains ExportData entries representing the transformed measurements and metadata of each datapoint.
+     */
+    transformToExportFileStructure(dataToExport) {
+        const exportData = [];
+        for (const data of dataToExport) {
+            const rowsData = this.processDataToExport(data);
+            exportData.push(rowsData);
+        }
+        return exportData;
+    }
+    /**
+     * Transforms the input datapoints with values into a structured format for a preview.
+     *
+     * @param dataToExport - An array of processed measurement data combined with the respective properties of the datapoint.
+     * @returns Provides an array of up to 5 ExportData elements (no more is needed for a preview) or an empty array,
+     */
+    transformToExportFileStructureForPreview(dataToExport) {
+        const data = dataToExport.find(data => {
+            return data !== null && data.timeValueMap && data.unit;
+        });
+        if (!data) {
+            return [];
+        }
+        const exportData = this.processDataToExport(data);
+        return exportData.slice(0, MEASUREMENTS_PREVIEW_ITEMS_LIMIT);
+    }
+    /**
+     * Processes a single dataToExport and transforms it into an array of ExportData.
+     *
+     * Used further for creating series data based export and also for measurements and series data based preview.
+     * Series data provides min and max values for each timestamp.
+     *
+     * @param dataToExport - A processed measurement or series data combined with the respective properties of the datapoint to be precessed
+     * @returns An array of ExportData representing the processed datapoint,
+     *          that can be used as a row data in the exported files or for preview.
+     */
+    processDataToExport(dataToExport) {
+        const rowsData = [];
+        // When measurements or series data is not available, add an empty header row with only device_name, source and fragment_series.
+        // This data is needed later to be used to create the file name and merged file header string.
+        const responseDoesNotContainData = !dataToExport.timeValueMap?.size && !dataToExport.unit;
+        if (responseDoesNotContainData) {
+            rowsData.push({
+                time: null,
+                source: dataToExport.source,
+                device_name: dataToExport.deviceName,
+                fragment_series: `${dataToExport.valueFragmentType}.${dataToExport.valueFragmentSeries}`,
+                value: null,
+                value_min: null,
+                value_max: null,
+                unit: null
+            });
+            return rowsData;
+        }
+        for (const [time, value] of Object.entries(dataToExport.timeValueMap)) {
+            // Measurements data contains only one value as a number, series data contains object with min and max values.
+            const isMeasurementData = typeof value === 'number';
+            if (isMeasurementData) {
+                rowsData.push(this.createExportData(dataToExport, time, isMeasurementData, value));
+            }
+            else {
+                rowsData.push(this.createExportData(dataToExport, time, isMeasurementData, value.min, value.max));
+            }
+        }
+        return rowsData;
+    }
+    createExportData(dataToExport, time, isMeasurement, value, valueMax) {
+        const commonExportData = {
+            time: new Date(time).toISOString(),
+            source: dataToExport.source,
+            device_name: dataToExport.deviceName,
+            fragment_series: `${dataToExport.valueFragmentType}.${dataToExport.valueFragmentSeries}`,
+            unit: dataToExport.unit
+        };
+        return isMeasurement
+            ? { ...commonExportData, value }
+            : { ...commonExportData, value_min: value, value_max: valueMax };
+    }
+    /**
+     * Exports the given data to merged CSV or Excel files.
+     *
+     * @param exportData - An array containing ExportData objects that will be used as parts of the merged file.
+     * @param fileType - Indicates the type of the file to be exported.
+     * @param mergedExportDetails - An object containing the date range from which the export was created and aggregation type.
+     * @returns An objects containing file name and its respective content as Blob.
+     *
+     * Example of exported merged file structure:
+     * date from	date to
+     * 2024-04-15T12:14:00.000Z	2024-07-16T14:14:28+02:00
+     * time	                          G6Fit -> c8y_Acceleration.accelerationX [G]	G6Fit -> c8y_Acceleration.accelerationY [G]
+     * 2024-05-13T13:45:10.500+02:00	0.0109026359624273	                        0.789461628278069
+     *
+     * Example of exported file name format:
+     * 04dec231240-06dec232350.xlsx
+     */
+    async exportSeriesDataToMergedFiles(exportData, fileType, mergedExportDetails) {
+        const fileTypeConfig = this.fileTypesConfigs[fileType];
+        mergedExportDetails.dateFrom = new Date(mergedExportDetails.dateFrom).toISOString();
+        mergedExportDetails.dateTo = new Date(mergedExportDetails.dateTo).toISOString();
+        const mergedFileContent = this.mergeMapping[fileType](exportData, mergedExportDetails);
+        const mergedFileNameDateRange = this.utils.getFormattedDateRange(mergedExportDetails.dateFrom, mergedExportDetails.dateTo);
+        return {
+            fileName: `${mergedFileNameDateRange}.${fileTypeConfig.extension}`,
+            fileData: new Blob([await mergedFileContent], { type: fileTypeConfig.mimeType })
+        };
+    }
+    /**
+     * Zips all created files.
+     *
+     * @param files - An array of objects containing file names and their respective content as Blobs.
+     * @returns A Promise that resolves to a Blob representing the generated zip file.
+     */
+    async zipFiles(files) {
+        const zip = new JSZip();
+        files.forEach(file => {
+            zip.file(file.fileName, file.fileData);
+        });
+        return await this.generateZipBlob(zip, FILE_COMPRESSION_TYPES_VALUES.deflate, 9);
+    }
+    /**
+     * Exports the given data to CSV or Excel files.
+     *
+     * @param params - An object containing all the necessary parameters for the export and zip process.
+     * @returns A Promise that resolves to a Blob representing the exported file.
+     */
+    async exportSeriesData(params) {
+        const { flattenedAndSortedExportData, fileType, mergedExportDetails } = params;
+        const exportedMergedFile = await this.exportSeriesDataToMergedFiles(flattenedAndSortedExportData, fileType, mergedExportDetails);
+        const blob = new Blob([exportedMergedFile.fileData], { type: fileType });
+        Object.defineProperty(blob, SERIES_DATA_MERGED_FILE_NAME, {
+            value: exportedMergedFile.fileName,
+            writable: false,
+            enumerable: false,
+            configurable: true
+        });
+        return blob;
+    }
+    createFileName(source, fragmentSeries, fileExtension) {
+        return `${source}_${fragmentSeries}.${fileExtension}`;
+    }
+    /**
+     * Generates a zip blob using the provided zip object.
+     *
+     * @param zip - The zip object used for generating the blob.
+     * @param compressionType - The compression type for the zip file. 'STORE' is no compression, 'DEFLATE' is compression.
+     * @param compressionLevel - The compression level for the zip file.
+     *                           Level 1 is quickest, 9 is best compressed.
+     * @returns A Promise that resolves to a Blob containing the generated zip file.
+     */
+    async generateZipBlob(zip, compressionType = FILE_COMPRESSION_TYPES_VALUES.store, compressionLevel = 1) {
+        const blob = 'blob';
+        if (compressionType === FILE_COMPRESSION_TYPES_VALUES.store) {
+            return await zip.generateAsync({ type: blob });
+        }
+        return await zip.generateAsync({
+            type: blob,
+            compression: compressionType,
+            compressionOptions: {
+                level: compressionLevel
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DataProcessingService, deps: [{ token: FILE_GENERATORS }, { token: UtilsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DataProcessingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DataProcessingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [FILE_GENERATORS]
+                }] }, { type: UtilsService }] });
+
+class DatapointsExportSelectorModalComponent {
+    constructor(bsModalRef) {
+        this.bsModalRef = bsModalRef;
+        this.isDownloadEnabled = false;
+        this.labels = { ok: gettext('Download'), cancel: gettext('Cancel') };
+        this.result = new Promise(resolve => {
+            this._close = resolve;
+        });
+    }
+    handleKeyboardEvent(event) {
+        if (event.key === 'Escape') {
+            this.dismiss();
+        }
+    }
+    dismiss() {
+        this._close(false);
+        this.bsModalRef.hide();
+    }
+    async exportAndDownload() {
+        await this.datapointsExportSelectorFileExporterComponent.exportAndDownload();
+        this.dismiss();
+    }
+    changeDownloadButtonState(isEnabled) {
+        this.isDownloadEnabled = isEnabled;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsExportSelectorModalComponent, deps: [{ token: i1$1.BsModalRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: DatapointsExportSelectorModalComponent, isStandalone: true, selector: "c8y-datapoints-export-selector-modal", host: { listeners: { "document:keydown": "handleKeyboardEvent($event)" } }, viewQueries: [{ propertyName: "datapointsExportSelectorFileExporterComponent", first: true, predicate: DatapointsExportSelectorFileExporterComponent, descendants: true }], ngImport: i0, template: "<c8y-modal\n  [title]=\"'Generate export' | translate\"\n  [labels]=\"labels\"\n  [disabled]=\"!isDownloadEnabled\"\n  [headerClasses]=\"'dialog-header'\"\n  (onDismiss)=\"dismiss()\"\n  (onClose)=\"exportAndDownload()\"\n>\n  <ng-container c8y-modal-title>\n    <span [c8yIcon]=\"'data-export'\"></span>\n  </ng-container>\n  <c8y-datapoints-export-selector-file-exporter\n    [exportConfig]=\"exportConfig\"\n    (onDownloadButtonStateChange)=\"changeDownloadButtonState($event)\"\n  ></c8y-datapoints-export-selector-file-exporter>\n</c8y-modal>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.IconDirective, selector: "[c8yIcon]", inputs: ["c8yIcon"] }, { kind: "pipe", type: i1.C8yTranslatePipe, name: "translate" }, { kind: "component", type: DatapointsExportSelectorFileExporterComponent, selector: "c8y-datapoints-export-selector-file-exporter", inputs: ["exportConfig"], outputs: ["onDownloadButtonStateChange"] }, { kind: "ngmodule", type: ModalModule }, { kind: "component", type: i1.ModalComponent, selector: "c8y-modal", inputs: ["disabled", "close", "dismiss", "title", "body", "customFooter", "headerClasses", "labels"], outputs: ["onDismiss", "onClose"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsExportSelectorModalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'c8y-datapoints-export-selector-modal', standalone: true, imports: [CommonModule, DatapointsExportSelectorFileExporterComponent, ModalModule], template: "<c8y-modal\n  [title]=\"'Generate export' | translate\"\n  [labels]=\"labels\"\n  [disabled]=\"!isDownloadEnabled\"\n  [headerClasses]=\"'dialog-header'\"\n  (onDismiss)=\"dismiss()\"\n  (onClose)=\"exportAndDownload()\"\n>\n  <ng-container c8y-modal-title>\n    <span [c8yIcon]=\"'data-export'\"></span>\n  </ng-container>\n  <c8y-datapoints-export-selector-file-exporter\n    [exportConfig]=\"exportConfig\"\n    (onDownloadButtonStateChange)=\"changeDownloadButtonState($event)\"\n  ></c8y-datapoints-export-selector-file-exporter>\n</c8y-modal>\n" }]
+        }], ctorParameters: () => [{ type: i1$1.BsModalRef }], propDecorators: { datapointsExportSelectorFileExporterComponent: [{
+                type: ViewChild,
+                args: [DatapointsExportSelectorFileExporterComponent, { static: false }]
+            }], handleKeyboardEvent: [{
+                type: HostListener,
+                args: ['document:keydown', ['$event']]
+            }] } });
+
+class DatapointsExportSelectorComponent {
+    constructor(bsModalService) {
+        this.bsModalService = bsModalService;
+        this.isOpen = new EventEmitter();
+    }
+    async openExportModal() {
+        const exportConfig = this.exportConfig;
+        const initialState = {
+            exportConfig
+        };
+        this.isOpen.emit(true);
+        const modalRef = this.bsModalService.show(DatapointsExportSelectorModalComponent, {
+            class: 'modal-lg',
+            ariaDescribedby: 'modal-body',
+            ariaLabelledBy: 'modal-title',
+            initialState,
+            ignoreBackdropClick: true
+        }).content;
+        // Result will be 'false' on modal close or dismiss
+        this.isOpen.emit(await modalRef.result);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsExportSelectorComponent, deps: [{ token: i1$1.BsModalService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: DatapointsExportSelectorComponent, isStandalone: true, selector: "c8y-datapoints-export-selector", inputs: { exportConfig: "exportConfig" }, outputs: { isOpen: "isOpen" }, ngImport: i0, template: "<div class=\"input-group p-t-4 p-b-4 max-width-fit m-l-auto\">\n  <div class=\"input-group-btn\">\n    <button\n      class=\"btn btn-default\"\n      [attr.aria-label]=\"'Generate export' | translate\"\n      tooltip=\"{{ 'Generate export' | translate }}\"\n      container=\"body\"\n      type=\"button\"\n      (click)=\"openExportModal()\"\n      [adaptivePosition]=\"false\"\n      [disabled]=\"!exportConfig\"\n      [delay]=\"500\"\n    >\n      <i\n        class=\"icon-14\"\n        c8yIcon=\"data-export\"\n      ></i>\n    </button>\n  </div>\n</div>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.IconDirective, selector: "[c8yIcon]", inputs: ["c8yIcon"] }, { kind: "pipe", type: i1.C8yTranslatePipe, name: "translate" }, { kind: "ngmodule", type: TooltipModule }, { kind: "directive", type: i3$3.TooltipDirective, selector: "[tooltip], [tooltipHtml]", inputs: ["adaptivePosition", "tooltip", "placement", "triggers", "container", "containerClass", "boundariesElement", "isOpen", "isDisabled", "delay", "tooltipHtml", "tooltipPlacement", "tooltipIsOpen", "tooltipEnable", "tooltipAppendToBody", "tooltipAnimation", "tooltipClass", "tooltipContext", "tooltipPopupDelay", "tooltipFadeDuration", "tooltipTrigger"], outputs: ["tooltipChange", "onShown", "onHidden", "tooltipStateChanged"], exportAs: ["bs-tooltip"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsExportSelectorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'c8y-datapoints-export-selector', standalone: true, imports: [CommonModule, TooltipModule], template: "<div class=\"input-group p-t-4 p-b-4 max-width-fit m-l-auto\">\n  <div class=\"input-group-btn\">\n    <button\n      class=\"btn btn-default\"\n      [attr.aria-label]=\"'Generate export' | translate\"\n      tooltip=\"{{ 'Generate export' | translate }}\"\n      container=\"body\"\n      type=\"button\"\n      (click)=\"openExportModal()\"\n      [adaptivePosition]=\"false\"\n      [disabled]=\"!exportConfig\"\n      [delay]=\"500\"\n    >\n      <i\n        class=\"icon-14\"\n        c8yIcon=\"data-export\"\n      ></i>\n    </button>\n  </div>\n</div>\n" }]
+        }], ctorParameters: () => [{ type: i1$1.BsModalService }], propDecorators: { exportConfig: [{
+                type: Input
+            }], isOpen: [{
+                type: Output
+            }] } });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CSVGeneratorAdapter, DataFetchingService, DataPointsExportSelectorDataScopeComponent, DataPointsExportSelectorFileTypesComponent, DataPointsExportSelectorPreviewComponent, DataPointsExportSelectorTimeRangeComponent, DataProcessingService, DatapointsExportSelectorComponent, DatapointsExportSelectorFileExporterComponent, DatapointsExportSelectorFileExporterService, DatapointsExportSelectorModalComponent, EXPORT_MODE_LABELS, EXPORT_MODE_VALUES, ExcelDataTransformer, ExcelGeneratorAdapter, FILE_COMPRESSION_TYPES_VALUES, FILE_GENERATORS, HAS_ERROR, MEASUREMENTS_PREVIEW_ITEMS_LIMIT, SERIES_DATA_MERGED_FILE_NAME, TIME_RANGE_INTERVAL_UNITS_VALUES, UtilsService, dateRangeValidator };
+//# sourceMappingURL=c8y-ngx-components-datapoints-export-selector.mjs.map