@qrvey/utils 1.5.0-0 → 1.5.0-11

package/README.md

@@ -1,4 +1,4 @@
-# [@qrvey/utils](https://bitbucket.org/qrvey/qrvey_utils/wiki/Home) *1.5.0-0*
+# [@qrvey/utils](https://bitbucket.org/qrvey/qrvey_utils/wiki/Home) *$npm_config_np_new_version*
 
 > Helper, Utils for all Qrvey Projects
 

package/dist/charts/adapters/endpointData.d.ts

@@ -0,0 +1,90 @@
+import { IFUData } from "../../filters";
+export declare function configSetup(config?: any): {
+    config: {
+        id: any;
+        data: any;
+        type: any;
+        domain: any;
+        model: any;
+        tab_id: any;
+        app_id: any;
+        api_key: any;
+        user_id: any;
+        view_id: any;
+        page_id: any;
+        chart_id: any;
+        qv_token: any;
+        qrvey_id: any;
+        question: any;
+        metric_id: any;
+        summary_id: any;
+        formulaType: any;
+        summary_type: any;
+        custom_tokens: any;
+        section: any;
+        panel_view: any;
+        previewFilters: any;
+        filterData: any;
+        i18n: any;
+        visibleFilters: IFUData;
+        appliedFilters: IFUData;
+        customDrillLogic: any[];
+        isFromAN: any;
+        editable: any;
+        inBuilder: any;
+        clickable: any;
+        userFilters: any;
+        customdrill: any;
+        widgetConfig: any;
+        drilldowns: any;
+        filterPermissions: any;
+        chartBuilderConfig: any;
+        other_config: any;
+        predefined_filters: any;
+        locale: any;
+        lang: string;
+        panel: {
+            header: {
+                menu: any;
+                filter: any;
+                draggable: any;
+                title_prefix: any;
+                fit_panel: any;
+                visible: any;
+                ui: {
+                    isFiltered: boolean;
+                    isDisplayReady: boolean;
+                    isScrollableXY: boolean;
+                };
+                externalDownload: any;
+            };
+            body: {
+                popup: any;
+                tooltip: any;
+                hasTimeout: boolean;
+                hasOverlay: any;
+                stylesTheme: {
+                    original_match_color: any;
+                    match_color: any;
+                };
+                ui: {
+                    isLoading: boolean;
+                    settingsStyle: any;
+                    timeoutMessage: string;
+                };
+            };
+            footer: {
+                visible: any;
+            };
+        };
+    };
+    data: {};
+    scopes: {};
+    baseConfig: {};
+    customdrills: any[];
+};
+export declare function configMetricData(metricObj?: any): any;
+export declare function configChartData(chartData: any, model: any, setup?: any): {
+    charts: any;
+    logic: import("../../filters").IFBLogic[];
+};

package/dist/charts/adapters/endpointData.js

@@ -0,0 +1,513 @@
+import { CHART_TYPE } from "../../constants";
+import { adaptFilterData, excludeFiltersByAggregateColumn, FDToLogic, FILTER_SCOPE, FILTER_STRUCTURE_VERSION, getAvailableScopes, getAvailableScopesIDsByConfig, UIToOldLogic, } from "../../filters";
+import { chooseLang, getLang } from "../../format";
+import { cloneDeep, getAttribute, isEmpty, _get, _hasProperty, } from "../../general";
+import { getAggFiltersResults, getCategoryBody, getComboBody, getDrilldownId, getLayerBody, getPivotBody, getRefenceBody, getRefenceBodyU, getSmallMultipleBody, getSummariesBody, getTrendBody, getValidSortingType, } from "./endpointDataGet";
+import { hasMinorVersion, isNotValid, validChartTypeWithEndPoint, } from "./endpointDataValidators";
+function makeBodyRequest(body, filters = []) {
+    if (!body)
+        return;
+    const category = _get(body, "layerList[0].category");
+    if (category && category.bucketId)
+        category.id = category.bucketId;
+    const distribution = _get(body, "layerList[0].distribution");
+    let categoryId = null;
+    if (category) {
+        categoryId = category.id;
+    }
+    else if (distribution) {
+        categoryId = distribution.id;
+    }
+    const dataType = _get(body, "layerList[0].category.type");
+    const maxDataPoints = _get(body, "globalSettings.maxNumDataPoints", 50);
+    const sorting = _get(body, "globalSettings.sortX", {});
+    const sortOption = {
+        sortBy: getValidSortingType(body) === "Label" ? "CATEGORY" : "VALUE",
+        sortDirection: (sorting.order || "ASC").toUpperCase(),
+    };
+    let label;
+    if (categoryId) {
+        label = {
+            questionid: categoryId,
+            qrveyid: (category || distribution).qrveyid || body.qrveyid,
+            property: (category || distribution).property || body.property,
+            type: (category || distribution).type || body.type,
+        };
+    }
+    if (body.layerList)
+        return body.layerList.reduce(function (charts, layer, index) {
+            if (index > 0 && !_get(layer, "combopt.label"))
+                return charts;
+            let chart;
+            if (index > 0 && layer.combopt.label === "MULTI") {
+                chart = { type: "MULTI_SERIE" };
+            }
+            else if (index > 0 &&
+                ["TREND", "REFERENCE"].includes(layer.combopt.label)) {
+                chart =
+                    layer.combopt.label === "TREND"
+                        ? getTrendBody(layer)
+                        : getRefenceBody(layer);
+                if (typeof chart.value == "object" && !chart.value.qrveyid)
+                    chart.value.qrveyid = body.qrveyid;
+            }
+            else if (_get(layer, "combopt.label") !== "SMALL_MULTIPLES") {
+                if (layer.value)
+                    layer.value.qrveyid = layer.value.qrveyid || body.qrveyid;
+                chart = getLayerBody(layer, body.dateGroup || layer.dateGroup, body.qrveyid);
+                if (chart) {
+                    chart.labelId = categoryId;
+                    chart.dataType = dataType;
+                    // this object is for new datalink feature
+                    if (chart.value)
+                        chart.label = label;
+                    if (layer.type === "BOXWHISKER_CHART") {
+                        if (!dataType) {
+                            delete chart.label;
+                            delete chart.labelId;
+                        }
+                        if (distribution) {
+                            chart.distribution = {
+                                aggregate: chart.aggregate,
+                                questionid: distribution.id || distribution.bucketId,
+                                qrveyid: body.qrveyid,
+                                type: distribution.type,
+                            };
+                        }
+                        delete chart.aggregate;
+                    }
+                    if ((layer.type === "WORD_CLOUD" ||
+                        (layer.type === "GEO_CHART" &&
+                            _get(layer, "mapType.label") === "DOT")) &&
+                        !chart.value) {
+                        chart.label = label;
+                        if (label.type !== "BUCKET") {
+                            // AN-7111 so far charts doesn't support bucket columns as value
+                            chart.value = label;
+                        }
+                    }
+                    if ([CHART_TYPE.GEO_CHART, CHART_TYPE.GEO_CHART_BUBBLE].includes(layer.type)) {
+                        chart.aggFilters = getAggFiltersResults(filters, [
+                            Object.assign(Object.assign({}, chart.value), { aggregate: chart.aggregate }),
+                        ]);
+                        if (chart.label)
+                            chart.property = chart.label.property;
+                    }
+                }
+            }
+            if (chart) {
+                chart.id = index;
+                if (_get(body, "globalSettings.maxDataPoints", false))
+                    chart.maxDataPoints = maxDataPoints;
+                chart.sortOption = sortOption;
+                const bucketData = category;
+                if (bucketData && bucketData.type === "BUCKET" && bucketData.bucketId) {
+                    chart.labelBucketId = bucketData.bucketId;
+                    delete chart.label; // deleted unnecessary chart label property in buckets
+                }
+                charts.push(chart);
+            }
+            return charts;
+        }, []);
+}
+function makeBodyRequestU(body, filters, newModel = false) {
+    var _a, _b, _c;
+    if (!body)
+        return;
+    const pSmallMultiple = getSmallMultipleBody(body.layerList.find((ly) => _get(ly, "combopt.label") === "SMALL_MULTIPLES"), body);
+    let pSummaries = getSummariesBody(_get(body, "layerList[0]"), body);
+    const pCategory = getCategoryBody(_get(body, "layerList[0]"), body);
+    const pPivot = getPivotBody(_get(body, "layerList[0]"), body);
+    const aggFilters = getAggFiltersResults(filters, pSummaries);
+    let requestBody = [];
+    if (body.layerList) {
+        requestBody = body.layerList.reduce(function (charts, layer, index) {
+            if (index <= 0 || !_get(layer, "combopt.label"))
+                return charts;
+            let chart;
+            switch (layer.combopt.label) {
+                case "TREND":
+                    chart = getTrendBody(layer);
+                    break;
+                case "REFERENCE":
+                    chart = getRefenceBodyU(layer, body);
+                    break;
+                case "COMBO":
+                    chart = getComboBody(layer, body, filters, newModel);
+                    break;
+                case "MULTI":
+                    chart = {
+                        type: layer.combopt.label,
+                    };
+                    break;
+            }
+            if (chart)
+                charts.push(chart);
+            return charts;
+        }, []);
+    }
+    if (newModel) {
+        const dimensions = [];
+        if (pSmallMultiple)
+            dimensions.push(pSmallMultiple);
+        if (pCategory)
+            dimensions.push(pCategory);
+        if (pPivot)
+            dimensions.push(pPivot);
+        if (!pSummaries[0].aggregate && !((_c = (_b = (_a = pCategory.sortOption) === null || _a === void 0 ? void 0 : _a.order) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.hidden)) {
+            let sortValue = {};
+            if (_get(pCategory, "sortOption.sortBy") === "VALUE") {
+                sortValue = Object.assign({}, pCategory.sortOption);
+                sortValue.sortBy = "CATEGORY";
+                pCategory.sortOption = {};
+            }
+            const newSummary = Object.assign(pSummaries[0], {
+                maxDataPoints: body.globalSettings.maxNumValuePoints,
+            });
+            if (!newSummary.sortOption)
+                newSummary.sortOption = sortValue;
+            dimensions.push(newSummary);
+            pSummaries = [];
+        }
+        // TODO: Mejorar estructura  para que la propiedad venga directamente del chart builder
+        if (body.type === "HEATMAP_CHART" &&
+            pSummaries &&
+            pSummaries[0].calculations) {
+            const direction = _get(body.globalSettings, "calculation_direction", "Across") === "Down"
+                ? "vertical"
+                : "horizontal";
+            pSummaries[0].calculations.direction = direction;
+        }
+        requestBody.unshift({
+            dimensions: dimensions,
+            summaries: pSummaries,
+            aggFilters: aggFilters,
+        });
+    }
+    else {
+        requestBody.unshift({
+            category: pCategory,
+            summaries: pSummaries,
+            aggFilters: aggFilters,
+            pivot: pPivot,
+        });
+    }
+    return requestBody;
+}
+export function configSetup(config) {
+    var _a;
+    const cfg = cloneDeep(config || {});
+    cfg.panel = cfg.panel || {};
+    const body = getAttribute(cfg.panel, "body") || {};
+    const header = getAttribute(cfg.panel, "header") || {};
+    const footer = getAttribute(cfg.panel, "footer") || {};
+    let filterSettings = header.filter;
+    filterSettings = {
+        button: {
+            display: _get(header.filter, "button.display", _get(header, "filter", false)),
+            disable: _get(header.filter, "button.disable", false),
+        },
+        card: {
+            display: _get(header.filter, "card.display", true),
+            addFilter: _get(header.filter, "card.addFilter", true),
+            editFilter: _get(header.filter, "card.editFilter", true),
+            removeFilter: _get(header.filter, "card.removeFilter", true),
+        },
+    };
+    cfg.panel.styles = cfg.panel.styles || {};
+    const ctx = {
+        config: {
+            id: cfg.id,
+            data: cfg.data,
+            type: cfg.type,
+            domain: cfg.domain,
+            model: getAttribute(cfg, "model"),
+            tab_id: getAttribute(cfg, "tab_id"),
+            app_id: getAttribute(cfg, "app_id"),
+            api_key: getAttribute(cfg, "api_key"),
+            user_id: getAttribute(cfg, "user_id"),
+            view_id: getAttribute(cfg, "view_id"),
+            page_id: getAttribute(cfg, "page_id"),
+            chart_id: getAttribute(cfg, "chart_id"),
+            qv_token: getAttribute(cfg, "qv_token"),
+            qrvey_id: getAttribute(cfg, "qrvey_id"),
+            question: getAttribute(cfg, "question"),
+            metric_id: getAttribute(cfg, "metric_id"),
+            summary_id: getAttribute(cfg, "summary_id"),
+            formulaType: _get(cfg, "question.formulaType"),
+            summary_type: getAttribute(cfg, "summary_type"),
+            custom_tokens: getAttribute(cfg, "custom_tokens"),
+            section: getAttribute(cfg, "section") || "ANYWHERE",
+            panel_view: getAttribute(cfg, "panel_view") || "ANYWHERE",
+            previewFilters: cfg.previewFilters || [],
+            filterData: !isEmpty(cfg.filterData)
+                ? cfg.filterData
+                : { scopes: [], version: FILTER_STRUCTURE_VERSION },
+            i18n: cfg.i18n,
+            visibleFilters: {},
+            appliedFilters: {},
+            customDrillLogic: [],
+            isFromAN: cfg.isFromAN,
+            editable: cfg.editable,
+            inBuilder: cfg.inBuilder,
+            clickable: cfg.clickable,
+            userFilters: cfg.userFilters,
+            customdrill: cfg.customdrill,
+            widgetConfig: cfg.widgetConfig,
+            drilldowns: cfg.drilldowns || {},
+            filterPermissions: cfg.filterPermissions,
+            chartBuilderConfig: cfg.chartBuilderConfig,
+            other_config: getAttribute(cfg, "other_config"),
+            predefined_filters: getAttribute(cfg, "predefined_filters"),
+            locale: getLang((_a = cfg === null || cfg === void 0 ? void 0 : cfg.i18n) === null || _a === void 0 ? void 0 : _a.locale) || cfg.locale,
+            lang: chooseLang(cfg),
+            panel: {
+                header: {
+                    menu: header.menu,
+                    filter: filterSettings,
+                    draggable: header.draggable,
+                    title_prefix: header.title_prefix,
+                    fit_panel: header.fit_panel || false,
+                    visible: _hasProperty(header, "visible") ? header.visible : true,
+                    ui: {
+                        isFiltered: false,
+                        isDisplayReady: false,
+                        isScrollableXY: false,
+                    },
+                    externalDownload: header.externalDownload,
+                },
+                body: {
+                    popup: body.popup,
+                    tooltip: body.tooltip,
+                    hasTimeout: cfg.type === "CHART",
+                    hasOverlay: _hasProperty(body, "hasOverlay") ? body.hasOverlay : true,
+                    stylesTheme: {
+                        original_match_color: _get(cfg, "panel.styles.match_color", _get(cfg, "stylesTheme.match_color")),
+                        match_color: undefined,
+                    },
+                    ui: {
+                        isLoading: true,
+                        settingsStyle: cfg.panel.styles,
+                        timeoutMessage: `Calculating ${(cfg.type || "").toLowerCase()}. This process may take a while.`,
+                    },
+                },
+                footer: {
+                    visible: _hasProperty(footer, "visible") ? footer.visible : false,
+                },
+            },
+        },
+        data: {},
+        scopes: {},
+        baseConfig: {},
+        customdrills: [],
+    };
+    ctx.baseConfig = {
+        pb_version: cfg.pb_version,
+        lang: ctx.config.lang,
+        domain: ctx.config.domain,
+        app_id: ctx.config.app_id,
+        api_key: ctx.config.api_key,
+        user_id: ctx.config.user_id,
+        qrvey_id: ctx.config.qrvey_id,
+        qv_token: ctx.config.qv_token,
+        custom_tokens: ctx.config.custom_tokens,
+    };
+    ctx.scopes = getAvailableScopes(Object.assign(Object.assign({}, getAvailableScopesIDsByConfig(ctx.config)), { predefinedScopes: [{ label: FILTER_SCOPE.DATA, id: ctx.config.qrvey_id }] }));
+    return ctx;
+}
+function updateDimensionsByChart(data, model) {
+    var _a, _b, _c, _d;
+    if (!((_a = data === null || data === void 0 ? void 0 : data.globalSettings) === null || _a === void 0 ? void 0 : _a.chartVersion) &&
+        ((_b = data === null || data === void 0 ? void 0 : data.globalSettings) === null || _b === void 0 ? void 0 : _b.match_colors)) {
+        data.globalSettings.match_colors = false;
+    }
+    if (((_c = data === null || data === void 0 ? void 0 : data.globalSettings) === null || _c === void 0 ? void 0 : _c.match_colors) &&
+        hasMinorVersion(((_d = data === null || data === void 0 ? void 0 : data.globalSettings) === null || _d === void 0 ? void 0 : _d.chartVersion) || "1.0", "2.0")) {
+        data.globalSettings.match_colors = false;
+        data.globalSettings.chartVersion = "2.0";
+    }
+    const questions = _get(model, "questions.data");
+    if (!isEmpty(questions)) {
+        if (!isEmpty(_get(data, "chart.fields"))) {
+            Object.keys(data.chart.fields).forEach((field) => {
+                data.chart.fields[field].forEach((column, index) => {
+                    const question = questions.find((q) => q.id === column.data.id);
+                    if (!isEmpty(question) && question.text !== column.data.text) {
+                        if (column.data.text === column.data.label)
+                            data.chart.fields[field][index].data.label = question.text;
+                        if (column.data.text === column.label)
+                            data.chart.fields[field][index].label = question.text;
+                        data.chart.fields[field][index].data.text = question.text;
+                    }
+                });
+            });
+        }
+        if (!isEmpty(_get(data, "layerList"))) {
+            data.layerList.forEach((layer, index) => {
+                if (!isEmpty(layer.category)) {
+                    const question = questions.find((q) => q.id === layer.category.id);
+                    if (!isEmpty(question)) {
+                        data.layerList[index].category.text = question.text;
+                    }
+                }
+                if (!isEmpty(layer.value)) {
+                    const question = questions.find((q) => q.id === layer.value.id);
+                    if (!isEmpty(question)) {
+                        data.layerList[index].value.text = question.text;
+                    }
+                }
+                if (!isEmpty(_get(layer, "multiserie.serie"))) {
+                    const question = questions.find((q) => q.id === layer.multiserie.serie.id);
+                    if (!isEmpty(question)) {
+                        data.layerList[index].multiserie.serie.text = question.text;
+                    }
+                }
+            });
+        }
+        if (!isEmpty(_get(data, "v2.dimensions"))) {
+            Object.keys(data.v2.dimensions).forEach((dimension) => {
+                data.v2.dimensions[dimension].forEach((column, index) => {
+                    const question = questions.find((q) => q.id === column.id);
+                    if (!isEmpty(question) && question.text !== column.text) {
+                        if (column.text === column.label)
+                            data.v2.dimensions[dimension][index].label = question.text;
+                        data.v2.dimensions[dimension][index].text = question.text;
+                    }
+                });
+            });
+        }
+    }
+    return data;
+}
+export function configMetricData(metricObj //
+) {
+    var _a, _b;
+    const body = {};
+    const data = metricObj.data;
+    try {
+        metricObj.logic = FDToLogic(Object.assign({}, excludeFiltersByAggregateColumn((_a = metricObj === null || metricObj === void 0 ? void 0 : metricObj.defaultFilters) === null || _a === void 0 ? void 0 : _a.data)));
+        body.logic = (_b = metricObj.logic) !== null && _b !== void 0 ? _b : {};
+        body.qrveyid = data.dataSet.qrveyid;
+        body.apptype = data.dataSet.appType;
+        body.valueDetails = {
+            id: data.value.id,
+            aggType: data.valueAggregate.label,
+            dataType: data.value.type,
+            property: data.value.property,
+        };
+    }
+    catch (e) {
+        return false;
+    }
+    if (data.dateColumn) {
+        const dateColum = data.dateColumn.id;
+        const timeZoneOffset = 0;
+        // TIME PERIOD
+        try {
+            const timePeriod = data.timePeriod.label;
+            body.timePeriodDetails = {
+                id: dateColum,
+                type: timePeriod,
+                dataType: data.dateColumn.type,
+                timeZoneOffset,
+            };
+            if (timePeriod === "CUSTOM_RANGE") {
+                const type = data.timePeriodCustomRange.label;
+                body.timePeriodDetails.customRangeType = type;
+                body.timePeriodDetails.range = {};
+                if ("AFTER" === type) {
+                    if (!data.timePeriodDate)
+                        throw 0;
+                    body.timePeriodDetails.range.from = data.timePeriodDate;
+                }
+                else if ("BEFORE" === type) {
+                    if (!data.timePeriodDate)
+                        throw 0;
+                    body.timePeriodDetails.range.to = data.timePeriodDate;
+                }
+                else {
+                    if (!data.timePeriodDate || !data.timePeriodEndDate)
+                        throw 0;
+                    body.timePeriodDetails.range.from = data.timePeriodDate;
+                    body.timePeriodDetails.range.to = data.timePeriodEndDate;
+                }
+            }
+        }
+        catch (e) {
+            delete body.timePeriodDetails;
+        }
+        try {
+            const comparison = data.comparison.label;
+            body.comparisonDetails = {
+                id: dateColum,
+                type: comparison,
+                dataType: data.dateColumn.type,
+                timeZoneOffset,
+            };
+            if (comparison === "CUSTOM_RANGE") {
+                const type = data.comparisonCustomRange.label;
+                body.comparisonDetails.customRangeType = type;
+                body.comparisonDetails.range = {};
+                if ("AFTER" === type) {
+                    if (!data.comparisonDate)
+                        throw 0;
+                    body.comparisonDetails.range.from = data.comparisonDate;
+                }
+                else if ("BEFORE" === type) {
+                    if (!data.comparisonDate)
+                        throw 0;
+                    body.comparisonDetails.range.to = data.comparisonDate;
+                }
+                else {
+                    if (!data.comparisonDate || !data.comparisonEndDate)
+                        throw 0;
+                    body.comparisonDetails.range.from = data.comparisonDate;
+                    body.comparisonDetails.range.to = data.comparisonEndDate;
+                }
+            }
+        }
+        catch (e) {
+            delete body.comparisonDetails;
+        }
+    }
+    return body;
+}
+export function configChartData(chartData, model, setup) {
+    var _a, _b;
+    const ctx = configSetup(setup);
+    const _chartData = updateDimensionsByChart(chartData, model);
+    if (!_chartData.defaultFilters)
+        _chartData.defaultFilters = {};
+    if (!isEmpty(_chartData.defaultFilters) &&
+        isEmpty(_get(_chartData.defaultFilters, "data.version"))) {
+        _chartData.defaultFilters = {
+            data: adaptFilterData(_chartData.defaultFilters),
+        };
+    }
+    const logic = FDToLogic(Object.assign({}, excludeFiltersByAggregateColumn(_chartData.defaultFilters.data)));
+    const chart = {
+        data: _chartData,
+        type: _chartData.layerList[0].type,
+    };
+    if (isNotValid(_get(_chartData, "layerList[0]")))
+        return;
+    let drillData = {};
+    const customData = {};
+    const drilldowns = ctx.config.drilldowns[getDrilldownId(ctx, _chartData)] || [];
+    if (drilldowns.length > 0)
+        drillData = Object.assign({}, drilldowns[drilldowns.length - 1]);
+    if (drillData.chart)
+        customData.chart = Object.assign({}, drillData.chart);
+    if (((_a = drillData.filters) === null || _a === void 0 ? void 0 : _a.length) > 0)
+        customData.filters = [...drillData.filters];
+    const validEndPoint = validChartTypeWithEndPoint(chart.type);
+    const bodyRequest = customData.chart || _chartData;
+    const filterRequest = (_b = UIToOldLogic(_chartData.defaultFilters.data)) === null || _b === void 0 ? void 0 : _b.logic;
+    const charts = validEndPoint
+        ? makeBodyRequestU(bodyRequest, filterRequest, true)
+        : makeBodyRequest(bodyRequest, filterRequest);
+    return {
+        charts,
+        logic,
+    };
+}

package/dist/charts/adapters/endpointDataGet.d.ts

@@ -0,0 +1,14 @@
+import { OLD_IFilterLogic, IFBFilterAggregate } from "../../filters";
+export declare function getDrilldownId(ctx: any, data: any): string;
+export declare function getPivotBody(layer: any, body: any): any;
+export declare function getValidSortingType(body: any): "Value" | "Label";
+export declare function getCategoryBody(layer: any, body: any): any;
+export declare function getComboBody(layer: any, body: any, filters: any, newModel?: boolean): any;
+export declare function getSmallMultipleBody(layer: any, body: any): any;
+export declare function getAggFiltersResults(logics?: OLD_IFilterLogic[], summaries?: any[]): IFBFilterAggregate;
+export declare function getRefenceBody(layer: any): any;
+export declare function getTrendBody(layer: any): any;
+export declare function getRefenceBodyU(layer: any, body: any): any;
+export declare function getLayerBody(layer: any, dateGroup: any, qrveyid: any): any;
+export declare function setDateGroup(column: any, body: any, obj: any): void;
+export declare function getSummariesBody(layer: any, body: any): any;