@infomaximum/widget-sdk 6.0.0-view-theme.5 → 6.0.0-view-theme.6

package/dist/index.js

@@ -65,6 +65,40 @@ exports.EActionButtonsTypes = void 0;
     EActionButtonsTypes["SECONDARY"] = "primary-outlined";
 })(exports.EActionButtonsTypes || (exports.EActionButtonsTypes = {}));
 
+var id = 1;
+var AutoIdentifiedArrayItemSchema = function (z) {
+    return z.object({
+        /**
+         * Идентификатор, добавляемый системой "на лету" для удобства разработки, не сохраняется на сервер.
+         * Гарантируется уникальность id в пределах settings виджета.
+         */
+        id: z
+            .number()
+            .default(-1)
+            .transform(function (currentId) { return (currentId === -1 ? id++ : currentId); }),
+    });
+};
+var BaseWidgetSettingsSchema = function (z) {
+    return z.object({
+        title: z.string().optional(),
+        titleSize: z.number().optional(),
+        titleColor: ColorSchema(z).optional(),
+        titleWeight: z.enum(exports.EFontWeight).optional(),
+        stateName: z.string().nullable().optional(),
+        showMarkdown: z.boolean().optional(),
+        markdownMeasures: z.array(MarkdownMeasureSchema(z)).optional(),
+        markdownText: z.string().optional(),
+        markdownTextSize: z.number().optional(),
+        filters: z.array(SettingsFilterSchema(z)).optional(),
+        filterMode: z.enum(exports.EWidgetFilterMode).optional(),
+        ignoreFilters: z.boolean().optional(),
+        sorting: z.array(WidgetSortingIndicatorSchema(z)).optional(),
+        actionButtons: z.array(ActionButtonSchema(z)).optional(),
+        paddings: z.union([z.number(), z.string()]).optional(),
+        viewTheme: z.boolean().optional(),
+    });
+};
+
 exports.ESimpleDataType = void 0;
 (function (ESimpleDataType) {
     ESimpleDataType["OTHER"] = "OTHER";
@@ -77,285 +111,6 @@ exports.ESimpleDataType = void 0;
     ESimpleDataType["BOOLEAN"] = "BOOLEAN";
 })(exports.ESimpleDataType || (exports.ESimpleDataType = {}));
 
-var prepareValuesForSql = function (simpleType, values) {
-    return simpleType === exports.ESimpleDataType.INTEGER ||
-        simpleType === exports.ESimpleDataType.FLOAT ||
-        simpleType === exports.ESimpleDataType.BOOLEAN
-        ? values
-        : values.map(function (value) {
-            return value === null ? null : "'".concat(escapeSingularQuotes$1(escapeReverseSlash(value)), "'");
-        });
-};
-var escapeReverseSlash = function (formula) {
-    return formula.replaceAll(/\\/gm, "\\\\");
-};
-var escapeSingularQuotes$1 = function (formula) {
-    return formula.replaceAll("'", "\\'");
-};
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
-
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
-
-function __values(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-}
-
-function __read(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-}
-
-function __makeTemplateObject(cooked, raw) {
-    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
-    return cooked;
-}
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-exports.ECalculatorFilterMethods = void 0;
-(function (ECalculatorFilterMethods) {
-    ECalculatorFilterMethods["EQUAL_TO"] = "EQUAL_TO";
-    ECalculatorFilterMethods["NOT_EQUAL_TO"] = "NOT_EQUAL_TO";
-    ECalculatorFilterMethods["GREATER_THAN"] = "GREATER_THAN";
-    ECalculatorFilterMethods["LESS_THAN"] = "LESS_THAN";
-    ECalculatorFilterMethods["GREATER_THAN_OR_EQUAL_TO"] = "GREATER_THAN_OR_EQUAL_TO";
-    ECalculatorFilterMethods["LESS_THAN_OR_EQUAL_TO"] = "LESS_THAN_OR_EQUAL_TO";
-    ECalculatorFilterMethods["STARTS_WITH"] = "STARTS_WITH";
-    ECalculatorFilterMethods["ENDS_WITH"] = "ENDS_WITH";
-    ECalculatorFilterMethods["CONTAINS"] = "CONTAINS";
-    ECalculatorFilterMethods["NOT_CONTAINS"] = "NOT_CONTAINS";
-    ECalculatorFilterMethods["IN_RANGE"] = "IN_RANGE";
-    ECalculatorFilterMethods["NOT_IN_RANGE"] = "NOT_IN_RANGE";
-    ECalculatorFilterMethods["INCLUDE"] = "INCLUDE";
-    ECalculatorFilterMethods["EXCLUDE"] = "EXCLUDE";
-    ECalculatorFilterMethods["NONEMPTY"] = "NONEMPTY";
-    ECalculatorFilterMethods["EMPTY"] = "EMPTY";
-})(exports.ECalculatorFilterMethods || (exports.ECalculatorFilterMethods = {}));
-
-var formulaFilterMethods = __assign(__assign({}, exports.ECalculatorFilterMethods), { LAST_TIME: "LAST_TIME" });
-exports.EProcessFilterNames = void 0;
-(function (EProcessFilterNames) {
-    /** Наличие события */
-    EProcessFilterNames["presenceOfEvent"] = "presenceOfEvent";
-    /** Количество повторов события */
-    EProcessFilterNames["repetitionOfEvent"] = "repetitionOfEvent";
-    /** Наличие перехода */
-    EProcessFilterNames["presenceOfTransition"] = "presenceOfTransition";
-    /** Длительность перехода */
-    EProcessFilterNames["durationOfTransition"] = "durationOfTransition";
-})(exports.EProcessFilterNames || (exports.EProcessFilterNames = {}));
-exports.EFormulaFilterFieldKeys = void 0;
-(function (EFormulaFilterFieldKeys) {
-    EFormulaFilterFieldKeys["date"] = "date";
-    EFormulaFilterFieldKeys["dateRange"] = "dateRange";
-    EFormulaFilterFieldKeys["numberRange"] = "numberRange";
-    EFormulaFilterFieldKeys["string"] = "string";
-    EFormulaFilterFieldKeys["lastTimeValue"] = "lastTimeValue";
-    EFormulaFilterFieldKeys["lastTimeUnit"] = "lastTimeUnit";
-    EFormulaFilterFieldKeys["durationUnit"] = "durationUnit";
-})(exports.EFormulaFilterFieldKeys || (exports.EFormulaFilterFieldKeys = {}));
-exports.EDimensionProcessFilterTimeUnit = void 0;
-(function (EDimensionProcessFilterTimeUnit) {
-    EDimensionProcessFilterTimeUnit["YEARS"] = "YEARS";
-    EDimensionProcessFilterTimeUnit["MONTHS"] = "MONTHS";
-    EDimensionProcessFilterTimeUnit["HOURS"] = "HOURS";
-    EDimensionProcessFilterTimeUnit["DAYS"] = "DAYS";
-    EDimensionProcessFilterTimeUnit["MINUTES"] = "MINUTES";
-})(exports.EDimensionProcessFilterTimeUnit || (exports.EDimensionProcessFilterTimeUnit = {}));
-var isFormulaFilterValue = function (value) {
-    return "filteringMethod" in value;
-};
-var isDimensionProcessFilter = function (filter) { return "value" in filter && "condition" in filter; };
-
-var compact = function (items) { return ((items === null || items === void 0 ? void 0 : items.filter(Boolean)) || []); };
-var compactMap = function (items, f) {
-    return compact(items === null || items === void 0 ? void 0 : items.map(f));
-};
-var isNil = function (value) {
-    return value === null || value === undefined;
-};
-function memoize(fn) {
-    var cache = new Map();
-    return function (arg) {
-        if (cache.has(arg)) {
-            return cache.get(arg);
-        }
-        var result = fn(arg);
-        cache.set(arg, result);
-        return result;
-    };
-}
-
-exports.EClickHouseBaseTypes = void 0;
-(function (EClickHouseBaseTypes) {
-    // DATE
-    EClickHouseBaseTypes["Date"] = "Date";
-    EClickHouseBaseTypes["Date32"] = "Date32";
-    // DATETIME
-    EClickHouseBaseTypes["DateTime"] = "DateTime";
-    EClickHouseBaseTypes["DateTime32"] = "DateTime32";
-    // DATETIME64
-    EClickHouseBaseTypes["DateTime64"] = "DateTime64";
-    // STRING
-    EClickHouseBaseTypes["FixedString"] = "FixedString";
-    EClickHouseBaseTypes["String"] = "String";
-    // FLOAT
-    EClickHouseBaseTypes["Decimal"] = "Decimal";
-    EClickHouseBaseTypes["Decimal32"] = "Decimal32";
-    EClickHouseBaseTypes["Decimal64"] = "Decimal64";
-    EClickHouseBaseTypes["Decimal128"] = "Decimal128";
-    EClickHouseBaseTypes["Decimal256"] = "Decimal256";
-    EClickHouseBaseTypes["Float32"] = "Float32";
-    EClickHouseBaseTypes["Float64"] = "Float64";
-    // INTEGER
-    EClickHouseBaseTypes["Int8"] = "Int8";
-    EClickHouseBaseTypes["Int16"] = "Int16";
-    EClickHouseBaseTypes["Int32"] = "Int32";
-    EClickHouseBaseTypes["Int64"] = "Int64";
-    EClickHouseBaseTypes["Int128"] = "Int128";
-    EClickHouseBaseTypes["Int256"] = "Int256";
-    EClickHouseBaseTypes["UInt8"] = "UInt8";
-    EClickHouseBaseTypes["UInt16"] = "UInt16";
-    EClickHouseBaseTypes["UInt32"] = "UInt32";
-    EClickHouseBaseTypes["UInt64"] = "UInt64";
-    EClickHouseBaseTypes["UInt128"] = "UInt128";
-    EClickHouseBaseTypes["UInt256"] = "UInt256";
-    // BOOLEAN
-    EClickHouseBaseTypes["Bool"] = "Bool";
-})(exports.EClickHouseBaseTypes || (exports.EClickHouseBaseTypes = {}));
-var stringTypes = ["String", "FixedString"];
-var parseClickHouseType = memoize(function (type) {
-    if (isNil(type)) {
-        return {
-            simpleBaseType: exports.ESimpleDataType.OTHER,
-            dbBaseDataType: undefined,
-            containers: [],
-            simpleType: exports.ESimpleDataType.OTHER,
-        };
-    }
-    var _a = extractInnerType(type), containers = _a.containers, dbBaseDataType = _a.dbBaseDataType;
-    if (!dbBaseDataType) {
-        throw new Error("Invalid ClickHouse type: ".concat(type));
-    }
-    return {
-        dbBaseDataType: dbBaseDataType,
-        simpleBaseType: simplifyBaseType(dbBaseDataType),
-        containers: containers,
-        get simpleType() {
-            return containers.includes("Array") ? exports.ESimpleDataType.OTHER : this.simpleBaseType;
-        },
-    };
-});
-/** 'A(B(C))' -> ['A', 'B', 'C'] */
-var splitByBrackets = function (input) { return input.split(/[\(\)]/).filter(Boolean); };
-/**
- * Отделить внутренний тип от оберток.
- * Не поддерживаются обертки Tuple и LowCardinality.
- */
-var extractInnerType = function (type) {
-    var tokens = splitByBrackets(type);
-    // Удаление параметров типа.
-    if (tokens.length > 0 && isTypeParameters(tokens.at(-1))) {
-        tokens.pop();
-    }
-    var dbBaseDataType = tokens.pop();
-    return { containers: tokens, dbBaseDataType: dbBaseDataType };
-};
-var simplifyBaseType = function (dbBaseType) {
-    var isSourceTypeStartsWith = function (prefix) { return dbBaseType.startsWith(prefix); };
-    if (isSourceTypeStartsWith("Int") || isSourceTypeStartsWith("UInt")) {
-        return exports.ESimpleDataType.INTEGER;
-    }
-    if (isSourceTypeStartsWith("Decimal") || isSourceTypeStartsWith("Float")) {
-        return exports.ESimpleDataType.FLOAT;
-    }
-    if (stringTypes.some(isSourceTypeStartsWith)) {
-        return exports.ESimpleDataType.STRING;
-    }
-    if (isSourceTypeStartsWith("DateTime64")) {
-        return exports.ESimpleDataType.DATETIME64;
-    }
-    if (isSourceTypeStartsWith("DateTime")) {
-        return exports.ESimpleDataType.DATETIME;
-    }
-    if (isSourceTypeStartsWith("Date")) {
-        return exports.ESimpleDataType.DATE;
-    }
-    if (isSourceTypeStartsWith("Bool")) {
-        return exports.ESimpleDataType.BOOLEAN;
-    }
-    return exports.ESimpleDataType.OTHER;
-};
-/**
- * - `3` -> true
- * - `3, 'Europe/Moscow'` -> true
- * - `3, Europe/Moscow` -> false
- *
- * Пример типа с параметрами: `DateTime64(3, 'Europe/Moscow')`
- */
-var isTypeParameters = function (stringifiedParameters) {
-    return stringifiedParameters.split(", ").some(function (p) { return !Number.isNaN(Number(p)) || p.startsWith("'"); });
-};
-
 exports.EFormatTypes = void 0;
 (function (EFormatTypes) {
     /** Дата */
@@ -649,6 +404,942 @@ var formattingConfig = {
     },
 };
 
+exports.EWidgetIndicatorType = void 0;
+(function (EWidgetIndicatorType) {
+    EWidgetIndicatorType["MEASURE"] = "MEASURE";
+    EWidgetIndicatorType["EVENT_INDICATOR"] = "EVENT_INDICATOR";
+    EWidgetIndicatorType["TRANSITION_INDICATOR"] = "TRANSITION_INDICATOR";
+    EWidgetIndicatorType["DIMENSION"] = "DIMENSION";
+    EWidgetIndicatorType["SORTING"] = "SORTING";
+})(exports.EWidgetIndicatorType || (exports.EWidgetIndicatorType = {}));
+exports.EOuterAggregation = void 0;
+(function (EOuterAggregation) {
+    EOuterAggregation["avg"] = "avg";
+    EOuterAggregation["median"] = "median";
+    EOuterAggregation["count"] = "count";
+    EOuterAggregation["countDistinct"] = "countDistinct";
+    EOuterAggregation["min"] = "min";
+    EOuterAggregation["max"] = "max";
+    EOuterAggregation["sum"] = "sum";
+    EOuterAggregation["top"] = "top";
+})(exports.EOuterAggregation || (exports.EOuterAggregation = {}));
+/** Режимы значения показателя (на основе чего генерируется формула) */
+exports.EWidgetIndicatorValueModes = void 0;
+(function (EWidgetIndicatorValueModes) {
+    /** Готовая формула (как правило, введенная пользователем через редактор формул) */
+    EWidgetIndicatorValueModes["FORMULA"] = "FORMULA";
+    /** Шаблон формулы, предоставляемый системой */
+    EWidgetIndicatorValueModes["TEMPLATE"] = "TEMPLATE";
+    EWidgetIndicatorValueModes["AGGREGATION"] = "AGGREGATION";
+    EWidgetIndicatorValueModes["DURATION"] = "DURATION";
+    EWidgetIndicatorValueModes["CONVERSION"] = "CONVERSION";
+    EWidgetIndicatorValueModes["START_TIME"] = "START_TIME";
+    EWidgetIndicatorValueModes["END_TIME"] = "END_TIME";
+})(exports.EWidgetIndicatorValueModes || (exports.EWidgetIndicatorValueModes = {}));
+/** Режимы сортировки (на что ссылается сортировка) */
+exports.ESortingValueModes = void 0;
+(function (ESortingValueModes) {
+    /** Сортировка по формуле */
+    ESortingValueModes["FORMULA"] = "FORMULA";
+    /** Сортировка по показателю(разрезу или мере) виджета */
+    ESortingValueModes["IN_WIDGET"] = "IN_WIDGET";
+})(exports.ESortingValueModes || (exports.ESortingValueModes = {}));
+exports.EFormatOrFormattingMode = void 0;
+(function (EFormatOrFormattingMode) {
+    EFormatOrFormattingMode["BASE"] = "BASE";
+    EFormatOrFormattingMode["TEMPLATE"] = "TEMPLATE";
+})(exports.EFormatOrFormattingMode || (exports.EFormatOrFormattingMode = {}));
+/** Тип показателя */
+exports.EIndicatorType = void 0;
+(function (EIndicatorType) {
+    /** Показатели процесса */
+    EIndicatorType["PROCESS_MEASURE"] = "PROCESS_MEASURE";
+    /** Вводимое значение */
+    EIndicatorType["STATIC"] = "STATIC";
+    /** Статический список */
+    EIndicatorType["STATIC_LIST"] = "STATIC_LIST";
+    /** Динамический список */
+    EIndicatorType["DYNAMIC_LIST"] = "DYNAMIC_LIST";
+    /** Список колонок */
+    EIndicatorType["COLUMN_LIST"] = "COLUMN_LIST";
+    /** Разрез */
+    EIndicatorType["DIMENSION"] = "DIMENSION";
+    /** Мера */
+    EIndicatorType["MEASURE"] = "MEASURE";
+    /** Иерархия */
+    EIndicatorType["DYNAMIC_DIMENSION"] = "DYNAMIC_DIMENSION";
+    /** Пользовательская сортировка */
+    EIndicatorType["USER_SORTING"] = "USER_SORTING";
+})(exports.EIndicatorType || (exports.EIndicatorType = {}));
+/** Обобщенные типы значений переменных */
+exports.ESimpleInputType = void 0;
+(function (ESimpleInputType) {
+    /** Число (точность Float64) */
+    ESimpleInputType["NUMBER"] = "FLOAT";
+    /** Целое число (точность Int64) */
+    ESimpleInputType["INTEGER_NUMBER"] = "INTEGER";
+    /** Текст */
+    ESimpleInputType["TEXT"] = "STRING";
+    /** Дата (точность Date) */
+    ESimpleInputType["DATE"] = "DATE";
+    /** Дата и время (точность DateTime64) */
+    ESimpleInputType["DATE_AND_TIME"] = "DATETIME";
+    /** Логический тип */
+    ESimpleInputType["BOOLEAN"] = "BOOLEAN";
+})(exports.ESimpleInputType || (exports.ESimpleInputType = {}));
+function isDimensionsHierarchy(indicator) {
+    return "hierarchyDimensions" in indicator;
+}
+exports.OuterAggregation = void 0;
+(function (OuterAggregation) {
+    OuterAggregation["avg"] = "avgIf";
+    OuterAggregation["median"] = "medianIf";
+    OuterAggregation["count"] = "countIf";
+    OuterAggregation["countDistinct"] = "countIfDistinct";
+    OuterAggregation["min"] = "minIf";
+    OuterAggregation["max"] = "maxIf";
+    OuterAggregation["sum"] = "sumIf";
+})(exports.OuterAggregation || (exports.OuterAggregation = {}));
+exports.EDurationTemplateName = void 0;
+(function (EDurationTemplateName) {
+    EDurationTemplateName["avg"] = "avg";
+    EDurationTemplateName["median"] = "median";
+})(exports.EDurationTemplateName || (exports.EDurationTemplateName = {}));
+exports.EEventAppearances = void 0;
+(function (EEventAppearances) {
+    EEventAppearances["FIRST"] = "FIRST";
+    EEventAppearances["LAST"] = "LAST";
+})(exports.EEventAppearances || (exports.EEventAppearances = {}));
+
+// Типы, используемые в значениях элементов управления.
+exports.EWidgetFilterMode = void 0;
+(function (EWidgetFilterMode) {
+    EWidgetFilterMode["DEFAULT"] = "DEFAULT";
+    EWidgetFilterMode["SINGLE"] = "SINGLE";
+    EWidgetFilterMode["DISABLED"] = "DISABLED";
+})(exports.EWidgetFilterMode || (exports.EWidgetFilterMode = {}));
+exports.EMarkdownDisplayMode = void 0;
+(function (EMarkdownDisplayMode) {
+    EMarkdownDisplayMode["NONE"] = "NONE";
+    EMarkdownDisplayMode["INDICATOR"] = "INDICATOR";
+})(exports.EMarkdownDisplayMode || (exports.EMarkdownDisplayMode = {}));
+exports.EDisplayConditionMode = void 0;
+(function (EDisplayConditionMode) {
+    EDisplayConditionMode["DISABLED"] = "DISABLED";
+    EDisplayConditionMode["FORMULA"] = "FORMULA";
+    EDisplayConditionMode["VARIABLE"] = "VARIABLE";
+})(exports.EDisplayConditionMode || (exports.EDisplayConditionMode = {}));
+exports.EFontWeight = void 0;
+(function (EFontWeight) {
+    EFontWeight["NORMAL"] = "NORMAL";
+    EFontWeight["BOLD"] = "BOLD";
+})(exports.EFontWeight || (exports.EFontWeight = {}));
+exports.EHeightMode = void 0;
+(function (EHeightMode) {
+    EHeightMode["FIXED"] = "FIXED";
+    EHeightMode["PERCENT"] = "PERCENT";
+})(exports.EHeightMode || (exports.EHeightMode = {}));
+
+var SortDirectionSchema = function (z) {
+    return z.union([z.literal(exports.ESortDirection.ascend), z.literal(exports.ESortDirection.descend)]);
+};
+var WidgetSortingValueSchema = function (z) {
+    return z.discriminatedUnion("mode", [
+        z.object({
+            mode: z.literal(exports.ESortingValueModes.FORMULA),
+            formula: z.string(),
+            dbDataType: z.string(),
+        }),
+        z.object({
+            mode: z.literal(exports.ESortingValueModes.IN_WIDGET),
+            group: z.string(),
+            index: z.number(),
+        }),
+    ]);
+};
+
+var RangeSchema = function (z) {
+    return z.object({
+        unit: z.string().optional(),
+        min: z.number().optional(),
+        max: z.number().optional(),
+    });
+};
+var DisplayConditionSchema = function (z) {
+    return z.discriminatedUnion("mode", [
+        z.object({
+            mode: z.literal(exports.EDisplayConditionMode.DISABLED),
+        }),
+        z.object({
+            mode: z.literal(exports.EDisplayConditionMode.FORMULA),
+            formula: z.string().nullish(),
+        }),
+        z.object({
+            mode: z.literal(exports.EDisplayConditionMode.VARIABLE),
+            variableName: z.string().nullish(),
+            variableValue: z.string().nullish(),
+        }),
+    ]);
+};
+
+var WidgetIndicatorSchema = function (z) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+    });
+};
+var FormatSchema = function (z) {
+    return z.object({
+        value: z.enum(exports.EFormatTypes).optional(),
+        mode: z.enum(exports.EFormatOrFormattingMode).default(exports.EFormatOrFormattingMode.BASE),
+    });
+};
+var FormattingSchema = function (z) {
+    return z.object({
+        value: z.enum(exports.EFormattingPresets).optional(),
+        mode: z.enum(exports.EFormatOrFormattingMode),
+    });
+};
+var WidgetColumnIndicatorSchema = function (z) {
+    return WidgetIndicatorSchema(z).extend({
+        dbDataType: z.string().optional(),
+        format: FormatSchema(z).optional(),
+        formatting: FormattingSchema(z).optional(),
+        displayCondition: DisplayConditionSchema(z).optional(),
+        onClick: z.array(ActionsOnClickSchema(z)).optional(),
+    });
+};
+var ColumnIndicatorValueSchema = function (z) {
+    return z.discriminatedUnion("mode", [
+        z.object({
+            mode: z.literal(exports.EWidgetIndicatorValueModes.FORMULA),
+            formula: z.string().optional(),
+        }),
+        z.object({
+            mode: z.literal(exports.EWidgetIndicatorValueModes.TEMPLATE),
+            /** Имя шаблонной формулы, использующей колонку таблицы */
+            templateName: z.string().optional(),
+            /** Имя таблицы */
+            tableName: z.string().optional(),
+            /** Имя колонки */
+            columnName: z.string().optional(),
+        }),
+    ]);
+};
+var WidgetIndicatorAggregationValueSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EWidgetIndicatorValueModes.AGGREGATION),
+        templateName: z.string(),
+        processKey: z.string().nullable(),
+        eventName: z.string().nullable(),
+        eventNameFormula: z.string().nullable(),
+        anyEvent: z.literal(true).optional(),
+        caseCaseIdFormula: z.string().nullable(),
+        filters: z.array(ExtendedFormulaFilterValueSchema(z)),
+        tableName: z.string().optional(),
+        columnName: z.string().optional(),
+        eventTimeFormula: z.string().nullable().optional(),
+    });
+};
+var WidgetIndicatorTimeValueSchema = function (z) {
+    return z.object({
+        templateName: z.string(),
+        mode: z.union([
+            z.literal(exports.EWidgetIndicatorValueModes.START_TIME),
+            z.literal(exports.EWidgetIndicatorValueModes.END_TIME),
+        ]),
+        processKey: z.string().nullable(),
+        eventName: z.string().nullable(),
+        eventTimeFormula: z.string().nullable(),
+        caseCaseIdFormula: z.string().nullable(),
+        eventNameFormula: z.string().nullable(),
+        filters: z.array(ExtendedFormulaFilterValueSchema(z)),
+    });
+};
+var WidgetDimensionSchema = function (z) {
+    return WidgetColumnIndicatorSchema(z).extend({
+        value: z
+            .discriminatedUnion("mode", [
+            ColumnIndicatorValueSchema(z),
+            WidgetIndicatorAggregationValueSchema(z).extend({
+                innerTemplateName: z.string().optional(),
+            }),
+            WidgetIndicatorTimeValueSchema(z),
+        ])
+            .optional(),
+        hideEmptyValues: z.boolean(),
+    });
+};
+var WidgetDimensionHierarchySchema = function (z, dimensionSchema) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+        hierarchyDimensions: z.array(dimensionSchema),
+        displayCondition: DisplayConditionSchema(z).optional(),
+    });
+};
+var WidgetIndicatorConversionValue = function (z) {
+    return z.object({
+        mode: z.literal(exports.EWidgetIndicatorValueModes.CONVERSION),
+        startEventNameFormula: z.string().nullable(),
+        startEventProcessKey: z.string().nullable(),
+        startEventName: z.string().nullable(),
+        startEventFilters: z.array(ExtendedFormulaFilterValueSchema(z)),
+        startEventTimeFormula: z.string().nullable(),
+        endEventNameFormula: z.string().nullable(),
+        endEventProcessKey: z.string().nullable(),
+        endEventName: z.string().nullable(),
+        endEventFilters: z.array(ExtendedFormulaFilterValueSchema(z)),
+        endCaseCaseIdFormula: z.string().nullable(),
+        endEventTimeFormula: z.string().nullable(),
+    });
+};
+var WidgetIndicatorDurationValue = function (z) {
+    return WidgetIndicatorConversionValue(z).extend({
+        mode: z.literal(exports.EWidgetIndicatorValueModes.DURATION),
+        templateName: z.string(),
+        startEventAppearances: z.enum(exports.EEventAppearances),
+        endEventAppearances: z.enum(exports.EEventAppearances),
+    });
+};
+var WidgetMeasureSchema = function (z) {
+    return WidgetColumnIndicatorSchema(z).extend({
+        value: z
+            .discriminatedUnion("mode", [
+            ColumnIndicatorValueSchema(z),
+            WidgetIndicatorAggregationValueSchema(z).extend({
+                outerAggregation: z.enum(exports.EOuterAggregation),
+            }),
+            WidgetIndicatorConversionValue(z),
+            WidgetIndicatorDurationValue(z),
+        ])
+            .optional(),
+    });
+};
+var MarkdownMeasureSchema = function (z) {
+    return WidgetMeasureSchema(z).extend({
+        displaySign: z.enum(exports.EMarkdownDisplayMode),
+    });
+};
+var WidgetSortingIndicatorSchema = function (z) {
+    return WidgetIndicatorSchema(z).extend({
+        direction: SortDirectionSchema(z),
+        value: WidgetSortingValueSchema(z),
+    });
+};
+
+var FormulaFilterValueSchema = function (z) {
+    var _a;
+    return z.object({
+        name: z.string().nullish(),
+        formula: z.string(),
+        sliceIndex: z.number().optional(),
+        dbDataType: z.string(),
+        format: z.enum(exports.EFormatTypes),
+        filteringMethod: z.enum(Object.values(formulaFilterMethods)),
+        checkedValues: z.array(z.string().nullable()).optional(),
+        formValues: z
+            .object((_a = {},
+            _a[exports.EFormulaFilterFieldKeys.date] = z.string().nullable(),
+            _a[exports.EFormulaFilterFieldKeys.dateRange] = z.tuple([z.string(), z.string()]),
+            _a[exports.EFormulaFilterFieldKeys.numberRange] = z.tuple([
+                z.number().optional(),
+                z.number().optional(),
+            ]),
+            _a[exports.EFormulaFilterFieldKeys.string] = z.string(),
+            _a[exports.EFormulaFilterFieldKeys.lastTimeValue] = z.number(),
+            _a[exports.EFormulaFilterFieldKeys.lastTimeUnit] = z.enum(exports.ELastTimeUnit),
+            _a[exports.EFormulaFilterFieldKeys.durationUnit] = z.enum(exports.EDurationUnit),
+            _a))
+            .partial()
+            .optional(),
+    });
+};
+var ExtendedFormulaFilterValueSchema = function (z) {
+    return z.union([z.object({ formula: z.string() }), FormulaFilterValueSchema(z)]);
+};
+var DimensionProcessFilterSchema = function (z) {
+    return z.object({
+        value: z.discriminatedUnion("mode", [
+            WidgetIndicatorAggregationValueSchema(z).extend({
+                outerAggregation: z.enum(exports.EOuterAggregation),
+            }),
+            WidgetIndicatorAggregationValueSchema(z).extend({
+                innerTemplateName: z.string().optional(),
+            }),
+            WidgetIndicatorTimeValueSchema(z),
+            z.object({
+                mode: z.literal(exports.EWidgetIndicatorValueModes.FORMULA),
+                formula: z.string().optional(),
+            }),
+        ]),
+        dbDataType: z.string(),
+        condition: z.object({
+            filteringMethod: z.enum(Object.values(formulaFilterMethods)),
+            timeUnit: z.enum(exports.EDimensionProcessFilterTimeUnit).optional(),
+            values: z.array(z.string().nullable()),
+        }),
+    });
+};
+var SettingsFilterSchema = function (z) {
+    return z.union([ExtendedFormulaFilterValueSchema(z), DimensionProcessFilterSchema(z)]);
+};
+
+var ActionOnClickParameterCommonSchema = function (z) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+    });
+};
+var ParameterFromColumnSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.COLUMN),
+        tableName: z.string(),
+        columnName: z.string(),
+        dbDataType: z.string().optional(),
+    });
+};
+var ParameterFromVariableSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.VARIABLE),
+        sourceVariable: z.string(),
+    });
+};
+var ParameterFromFormulaSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.FORMULA),
+        formula: z.string(),
+        considerFilters: z.boolean(),
+        dbDataType: z.string().optional(),
+    });
+};
+var ParameterFromEventSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.EVENT),
+    });
+};
+var ParameterFromStartEventSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.START_EVENT),
+    });
+};
+var ParameterFromEndEventSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.FINISH_EVENT),
+    });
+};
+var ParameterFromAggregationSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.AGGREGATION),
+        formula: z.string(),
+        considerFilters: z.boolean(),
+        dbDataType: z.string().optional(),
+    });
+};
+var ParameterFromManualInputSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.MANUALLY),
+        description: z.string(),
+        defaultValue: z.string().optional(),
+        dbDataType: z.string().optional(),
+        filterByRows: z.boolean().optional(),
+        validation: z.string().optional(),
+        acceptEmptyValue: z.boolean().optional(),
+    });
+};
+var ParameterFromStaticListSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.STATIC_LIST),
+        options: z.string(),
+        defaultValue: z.union([z.string(), z.array(z.string())]),
+        acceptEmptyValue: z.boolean().optional(),
+    });
+};
+var ParameterFromDynamicListSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.DYNAMIC_LIST),
+        options: z.string(),
+        defaultValue: z.string(),
+        dbDataType: z.string().optional(),
+        displayOptions: z.string(),
+        filters: z.array(ExtendedFormulaFilterValueSchema(z)),
+        filterByRows: z.boolean().optional(),
+        considerFilters: z.boolean(),
+        insertAnyValues: z.boolean().optional(),
+        validation: z.string().optional(),
+        acceptEmptyValue: z.boolean().optional(),
+    });
+};
+var ParameterFromDataModelBaseSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.DATA_MODEL),
+        option: z.enum(exports.EDataModelOption),
+    });
+};
+var ParameterColumnListSchema = function (z) {
+    return ParameterFromDataModelBaseSchema(z).extend({
+        option: z.literal(exports.EDataModelOption.COLUMN_LIST),
+        /* Название параметра, содержащего имя таблицы, от которой зависит текущий параметр   */
+        parent: z.string(),
+    });
+};
+var ParameterTableListSchema = function (z) {
+    return ParameterFromDataModelBaseSchema(z).extend({
+        option: z.literal(exports.EDataModelOption.TABLE_LIST),
+    });
+};
+var ParameterFromDataModelSchema = function (z) {
+    return z.discriminatedUnion("option", [ParameterColumnListSchema(z), ParameterTableListSchema(z)]);
+};
+var ActionOnClickParameterSchema = function (z) {
+    return z.intersection(ActionOnClickParameterCommonSchema(z), z.discriminatedUnion("inputMethod", [
+        ParameterFromColumnSchema(z),
+        ParameterFromVariableSchema(z),
+        ParameterFromFormulaSchema(z),
+        ParameterFromEventSchema(z),
+        ParameterFromStartEventSchema(z),
+        ParameterFromEndEventSchema(z),
+        ParameterFromAggregationSchema(z),
+        ParameterFromManualInputSchema(z),
+        ParameterFromStaticListSchema(z),
+        ParameterFromDynamicListSchema(z),
+        ParameterFromDataModelSchema(z),
+    ]));
+};
+var ActionCommonSchema = function (z) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+    });
+};
+var ActionGoToURLSchema = function (z) {
+    return ActionCommonSchema(z).extend({
+        type: z.literal(exports.EActionTypes.OPEN_URL),
+        url: z.string(),
+        newWindow: z.boolean(),
+    });
+};
+var ActivateConditionSchema = function (z) {
+    return z.discriminatedUnion("mode", [
+        z.object({
+            mode: z.literal(exports.EActivateConditionMode.FORMULA),
+            formula: z.string(),
+        }),
+        z.object({
+            mode: z.literal(exports.EActivateConditionMode.VARIABLE),
+            variableName: z.string(),
+            variableValue: z.string(),
+        }),
+    ]);
+};
+var ActionRunScriptSchema = function (z) {
+    return ActionCommonSchema(z).extend({
+        type: z.literal(exports.EActionTypes.EXECUTE_SCRIPT),
+        parameters: z.array(ActionOnClickParameterSchema(z)),
+        scriptKey: z.string(),
+        autoUpdate: z.enum(exports.EAutoUpdateMode),
+        hideInactiveButton: z.boolean().optional(),
+        activateCondition: ActivateConditionSchema(z).optional(),
+        hint: z.string().optional(),
+    });
+};
+var ActionUpdateVariableSchema = function (z) {
+    return ActionCommonSchema(z).extend({
+        type: z.literal(exports.EActionTypes.UPDATE_VARIABLE),
+        variables: z.array(ActionOnClickParameterSchema(z)),
+    });
+};
+var ActionOpenInSchema = function (z) {
+    return z.discriminatedUnion("openIn", [
+        z.object({
+            openIn: z.literal(exports.EViewOpenIn.DRAWER_WINDOW),
+            alignment: z.enum(exports.EDrawerPlacement),
+        }),
+        z.object({
+            openIn: z.literal(exports.EViewOpenIn.PLACEHOLDER),
+            placeholderName: z.string(),
+        }),
+        z.object({
+            openIn: z.literal(exports.EViewOpenIn.MODAL_WINDOW),
+            positionByClick: z.boolean().optional(),
+        }),
+        z.object({
+            openIn: z.literal(exports.EViewOpenIn.WINDOW),
+            newWindow: z.boolean(),
+        }),
+    ]);
+};
+var ActionOpenViewCommonSchema = function (z) {
+    return ActionCommonSchema(z).extend({ type: z.literal(exports.EActionTypes.OPEN_VIEW) });
+};
+var ActionOpenViewSchema = function (z) {
+    return z.intersection(z.discriminatedUnion("mode", [
+        ActionOpenViewCommonSchema(z).extend({
+            mode: z.literal(exports.EViewMode.GENERATED_BY_SCRIPT),
+            scriptKey: z.string(),
+            parameters: z.array(ActionOnClickParameterSchema(z)),
+            displayName: z.string(),
+        }),
+        ActionOpenViewCommonSchema(z).extend({
+            mode: z.literal(exports.EViewMode.EXISTED_VIEW),
+            viewKey: z.string(),
+            parameters: z.array(ActionOnClickParameterSchema(z)),
+        }),
+        ActionOpenViewCommonSchema(z).extend({
+            mode: z.literal(exports.EViewMode.EMPTY),
+            placeholderName: z.string(),
+            openIn: z.literal(exports.EViewOpenIn.PLACEHOLDER),
+        }),
+    ]), ActionOpenInSchema(z));
+};
+var ActionsOnClickSchema = function (z) {
+    return z.union([
+        ActionGoToURLSchema(z),
+        ActionRunScriptSchema(z),
+        ActionUpdateVariableSchema(z),
+        ActionOpenViewSchema(z),
+    ]);
+};
+var WidgetActionParameterCommonSchema = function (z) {
+    return z.object({
+        name: z.string(),
+        displayName: z.string(),
+        isHidden: z.boolean(),
+    });
+};
+var WidgetActionParameterSchema = function (z) {
+    return z.intersection(WidgetActionParameterCommonSchema(z), z.discriminatedUnion("inputMethod", [
+        ParameterFromColumnSchema(z),
+        ParameterFromVariableSchema(z),
+        ParameterFromFormulaSchema(z),
+        ParameterFromManualInputSchema(z),
+        ParameterFromStaticListSchema(z),
+        ParameterFromDynamicListSchema(z),
+        ParameterFromAggregationSchema(z),
+        ParameterFromDataModelSchema(z),
+    ]));
+};
+var WidgetActionSchema = function (z) {
+    return ActionCommonSchema(z).extend({
+        parameters: z.array(WidgetActionParameterSchema(z)),
+        type: z.literal(exports.EActionTypes.EXECUTE_SCRIPT),
+        scriptKey: z.string(),
+        autoUpdate: z.enum(exports.EAutoUpdateMode),
+        description: z.string(),
+        hideInactiveButton: z.boolean().optional(),
+        hint: z.string().optional(),
+        activateCondition: ActivateConditionSchema(z),
+    });
+};
+var ViewActionParameterSchema = function (z) {
+    return z.intersection(AutoIdentifiedArrayItemSchema(z).extend({ name: z.string() }), z.discriminatedUnion("inputMethod", [
+        ParameterFromAggregationSchema(z),
+        ParameterFromVariableSchema(z),
+    ]));
+};
+var ViewActionSchema = function (z) {
+    return z.object({
+        name: z.string(),
+        buttonType: z.enum(exports.EActionButtonsTypes),
+        type: z.literal(exports.EActionTypes.EXECUTE_SCRIPT),
+        parameters: z.array(ViewActionParameterSchema(z)),
+        scriptKey: z.string(),
+        id: z.number().optional(),
+        autoUpdate: z
+            .union([z.literal(exports.EAutoUpdateMode.NONE), z.literal(exports.EAutoUpdateMode.ALL_VIEWS)])
+            .optional(),
+    });
+};
+var ActionSchema = function (z) {
+    return z.union([ActionsOnClickSchema(z), WidgetActionSchema(z), ViewActionSchema(z)]);
+};
+var ActionButtonSchema = function (z) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+        onClick: z.array(WidgetActionSchema(z)),
+        buttonType: z.enum(exports.EActionButtonsTypes),
+        backgroundColor: ColorSchema(z).optional(),
+        borderColor: ColorSchema(z).optional(),
+        color: ColorSchema(z),
+        hint: z.string().optional(),
+    });
+};
+
+var prepareValuesForSql = function (simpleType, values) {
+    return simpleType === exports.ESimpleDataType.INTEGER ||
+        simpleType === exports.ESimpleDataType.FLOAT ||
+        simpleType === exports.ESimpleDataType.BOOLEAN
+        ? values
+        : values.map(function (value) {
+            return value === null ? null : "'".concat(escapeSingularQuotes$1(escapeReverseSlash(value)), "'");
+        });
+};
+var escapeReverseSlash = function (formula) {
+    return formula.replaceAll(/\\/gm, "\\\\");
+};
+var escapeSingularQuotes$1 = function (formula) {
+    return formula.replaceAll("'", "\\'");
+};
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+function __makeTemplateObject(cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+}
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+exports.ECalculatorFilterMethods = void 0;
+(function (ECalculatorFilterMethods) {
+    ECalculatorFilterMethods["EQUAL_TO"] = "EQUAL_TO";
+    ECalculatorFilterMethods["NOT_EQUAL_TO"] = "NOT_EQUAL_TO";
+    ECalculatorFilterMethods["GREATER_THAN"] = "GREATER_THAN";
+    ECalculatorFilterMethods["LESS_THAN"] = "LESS_THAN";
+    ECalculatorFilterMethods["GREATER_THAN_OR_EQUAL_TO"] = "GREATER_THAN_OR_EQUAL_TO";
+    ECalculatorFilterMethods["LESS_THAN_OR_EQUAL_TO"] = "LESS_THAN_OR_EQUAL_TO";
+    ECalculatorFilterMethods["STARTS_WITH"] = "STARTS_WITH";
+    ECalculatorFilterMethods["ENDS_WITH"] = "ENDS_WITH";
+    ECalculatorFilterMethods["CONTAINS"] = "CONTAINS";
+    ECalculatorFilterMethods["NOT_CONTAINS"] = "NOT_CONTAINS";
+    ECalculatorFilterMethods["IN_RANGE"] = "IN_RANGE";
+    ECalculatorFilterMethods["NOT_IN_RANGE"] = "NOT_IN_RANGE";
+    ECalculatorFilterMethods["INCLUDE"] = "INCLUDE";
+    ECalculatorFilterMethods["EXCLUDE"] = "EXCLUDE";
+    ECalculatorFilterMethods["NONEMPTY"] = "NONEMPTY";
+    ECalculatorFilterMethods["EMPTY"] = "EMPTY";
+})(exports.ECalculatorFilterMethods || (exports.ECalculatorFilterMethods = {}));
+
+var formulaFilterMethods = __assign(__assign({}, exports.ECalculatorFilterMethods), { LAST_TIME: "LAST_TIME" });
+exports.EProcessFilterNames = void 0;
+(function (EProcessFilterNames) {
+    /** Наличие события */
+    EProcessFilterNames["presenceOfEvent"] = "presenceOfEvent";
+    /** Количество повторов события */
+    EProcessFilterNames["repetitionOfEvent"] = "repetitionOfEvent";
+    /** Наличие перехода */
+    EProcessFilterNames["presenceOfTransition"] = "presenceOfTransition";
+    /** Длительность перехода */
+    EProcessFilterNames["durationOfTransition"] = "durationOfTransition";
+})(exports.EProcessFilterNames || (exports.EProcessFilterNames = {}));
+exports.EFormulaFilterFieldKeys = void 0;
+(function (EFormulaFilterFieldKeys) {
+    EFormulaFilterFieldKeys["date"] = "date";
+    EFormulaFilterFieldKeys["dateRange"] = "dateRange";
+    EFormulaFilterFieldKeys["numberRange"] = "numberRange";
+    EFormulaFilterFieldKeys["string"] = "string";
+    EFormulaFilterFieldKeys["lastTimeValue"] = "lastTimeValue";
+    EFormulaFilterFieldKeys["lastTimeUnit"] = "lastTimeUnit";
+    EFormulaFilterFieldKeys["durationUnit"] = "durationUnit";
+})(exports.EFormulaFilterFieldKeys || (exports.EFormulaFilterFieldKeys = {}));
+exports.EDimensionProcessFilterTimeUnit = void 0;
+(function (EDimensionProcessFilterTimeUnit) {
+    EDimensionProcessFilterTimeUnit["YEARS"] = "YEARS";
+    EDimensionProcessFilterTimeUnit["MONTHS"] = "MONTHS";
+    EDimensionProcessFilterTimeUnit["HOURS"] = "HOURS";
+    EDimensionProcessFilterTimeUnit["DAYS"] = "DAYS";
+    EDimensionProcessFilterTimeUnit["MINUTES"] = "MINUTES";
+})(exports.EDimensionProcessFilterTimeUnit || (exports.EDimensionProcessFilterTimeUnit = {}));
+var isFormulaFilterValue = function (value) {
+    return "filteringMethod" in value;
+};
+var isDimensionProcessFilter = function (filter) { return "value" in filter && "condition" in filter; };
+
+var compact = function (items) { return ((items === null || items === void 0 ? void 0 : items.filter(Boolean)) || []); };
+var compactMap = function (items, f) {
+    return compact(items === null || items === void 0 ? void 0 : items.map(f));
+};
+var isNil = function (value) {
+    return value === null || value === undefined;
+};
+function memoize(fn) {
+    var cache = new Map();
+    return function (arg) {
+        if (cache.has(arg)) {
+            return cache.get(arg);
+        }
+        var result = fn(arg);
+        cache.set(arg, result);
+        return result;
+    };
+}
+
+exports.EClickHouseBaseTypes = void 0;
+(function (EClickHouseBaseTypes) {
+    // DATE
+    EClickHouseBaseTypes["Date"] = "Date";
+    EClickHouseBaseTypes["Date32"] = "Date32";
+    // DATETIME
+    EClickHouseBaseTypes["DateTime"] = "DateTime";
+    EClickHouseBaseTypes["DateTime32"] = "DateTime32";
+    // DATETIME64
+    EClickHouseBaseTypes["DateTime64"] = "DateTime64";
+    // STRING
+    EClickHouseBaseTypes["FixedString"] = "FixedString";
+    EClickHouseBaseTypes["String"] = "String";
+    // FLOAT
+    EClickHouseBaseTypes["Decimal"] = "Decimal";
+    EClickHouseBaseTypes["Decimal32"] = "Decimal32";
+    EClickHouseBaseTypes["Decimal64"] = "Decimal64";
+    EClickHouseBaseTypes["Decimal128"] = "Decimal128";
+    EClickHouseBaseTypes["Decimal256"] = "Decimal256";
+    EClickHouseBaseTypes["Float32"] = "Float32";
+    EClickHouseBaseTypes["Float64"] = "Float64";
+    // INTEGER
+    EClickHouseBaseTypes["Int8"] = "Int8";
+    EClickHouseBaseTypes["Int16"] = "Int16";
+    EClickHouseBaseTypes["Int32"] = "Int32";
+    EClickHouseBaseTypes["Int64"] = "Int64";
+    EClickHouseBaseTypes["Int128"] = "Int128";
+    EClickHouseBaseTypes["Int256"] = "Int256";
+    EClickHouseBaseTypes["UInt8"] = "UInt8";
+    EClickHouseBaseTypes["UInt16"] = "UInt16";
+    EClickHouseBaseTypes["UInt32"] = "UInt32";
+    EClickHouseBaseTypes["UInt64"] = "UInt64";
+    EClickHouseBaseTypes["UInt128"] = "UInt128";
+    EClickHouseBaseTypes["UInt256"] = "UInt256";
+    // BOOLEAN
+    EClickHouseBaseTypes["Bool"] = "Bool";
+})(exports.EClickHouseBaseTypes || (exports.EClickHouseBaseTypes = {}));
+var stringTypes = ["String", "FixedString"];
+var parseClickHouseType = memoize(function (type) {
+    if (isNil(type)) {
+        return {
+            simpleBaseType: exports.ESimpleDataType.OTHER,
+            dbBaseDataType: undefined,
+            containers: [],
+            simpleType: exports.ESimpleDataType.OTHER,
+        };
+    }
+    var _a = extractInnerType(type), containers = _a.containers, dbBaseDataType = _a.dbBaseDataType;
+    if (!dbBaseDataType) {
+        throw new Error("Invalid ClickHouse type: ".concat(type));
+    }
+    return {
+        dbBaseDataType: dbBaseDataType,
+        simpleBaseType: simplifyBaseType(dbBaseDataType),
+        containers: containers,
+        get simpleType() {
+            return containers.includes("Array") ? exports.ESimpleDataType.OTHER : this.simpleBaseType;
+        },
+    };
+});
+/** 'A(B(C))' -> ['A', 'B', 'C'] */
+var splitByBrackets = function (input) { return input.split(/[\(\)]/).filter(Boolean); };
+/**
+ * Отделить внутренний тип от оберток.
+ * Не поддерживаются обертки Tuple и LowCardinality.
+ */
+var extractInnerType = function (type) {
+    var tokens = splitByBrackets(type);
+    // Удаление параметров типа.
+    if (tokens.length > 0 && isTypeParameters(tokens.at(-1))) {
+        tokens.pop();
+    }
+    var dbBaseDataType = tokens.pop();
+    return { containers: tokens, dbBaseDataType: dbBaseDataType };
+};
+var simplifyBaseType = function (dbBaseType) {
+    var isSourceTypeStartsWith = function (prefix) { return dbBaseType.startsWith(prefix); };
+    if (isSourceTypeStartsWith("Int") || isSourceTypeStartsWith("UInt")) {
+        return exports.ESimpleDataType.INTEGER;
+    }
+    if (isSourceTypeStartsWith("Decimal") || isSourceTypeStartsWith("Float")) {
+        return exports.ESimpleDataType.FLOAT;
+    }
+    if (stringTypes.some(isSourceTypeStartsWith)) {
+        return exports.ESimpleDataType.STRING;
+    }
+    if (isSourceTypeStartsWith("DateTime64")) {
+        return exports.ESimpleDataType.DATETIME64;
+    }
+    if (isSourceTypeStartsWith("DateTime")) {
+        return exports.ESimpleDataType.DATETIME;
+    }
+    if (isSourceTypeStartsWith("Date")) {
+        return exports.ESimpleDataType.DATE;
+    }
+    if (isSourceTypeStartsWith("Bool")) {
+        return exports.ESimpleDataType.BOOLEAN;
+    }
+    return exports.ESimpleDataType.OTHER;
+};
+/**
+ * - `3` -> true
+ * - `3, 'Europe/Moscow'` -> true
+ * - `3, Europe/Moscow` -> false
+ *
+ * Пример типа с параметрами: `DateTime64(3, 'Europe/Moscow')`
+ */
+var isTypeParameters = function (stringifiedParameters) {
+    return stringifiedParameters.split(", ").some(function (p) { return !Number.isNaN(Number(p)) || p.startsWith("'"); });
+};
+
 var _a$5;
 exports.EDimensionTemplateNames = void 0;
 (function (EDimensionTemplateNames) {
@@ -679,113 +1370,6 @@ var dimensionTemplateFormulas = (_a$5 = {},
     _a$5[exports.EDimensionTemplateNames.hour] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toHour({columnFormula}))",
     _a$5);
 
-exports.EWidgetIndicatorType = void 0;
-(function (EWidgetIndicatorType) {
-    EWidgetIndicatorType["MEASURE"] = "MEASURE";
-    EWidgetIndicatorType["EVENT_INDICATOR"] = "EVENT_INDICATOR";
-    EWidgetIndicatorType["TRANSITION_INDICATOR"] = "TRANSITION_INDICATOR";
-    EWidgetIndicatorType["DIMENSION"] = "DIMENSION";
-    EWidgetIndicatorType["SORTING"] = "SORTING";
-})(exports.EWidgetIndicatorType || (exports.EWidgetIndicatorType = {}));
-exports.EOuterAggregation = void 0;
-(function (EOuterAggregation) {
-    EOuterAggregation["avg"] = "avg";
-    EOuterAggregation["median"] = "median";
-    EOuterAggregation["count"] = "count";
-    EOuterAggregation["countDistinct"] = "countDistinct";
-    EOuterAggregation["min"] = "min";
-    EOuterAggregation["max"] = "max";
-    EOuterAggregation["sum"] = "sum";
-    EOuterAggregation["top"] = "top";
-})(exports.EOuterAggregation || (exports.EOuterAggregation = {}));
-/** Режимы значения показателя (на основе чего генерируется формула) */
-exports.EWidgetIndicatorValueModes = void 0;
-(function (EWidgetIndicatorValueModes) {
-    /** Готовая формула (как правило, введенная пользователем через редактор формул) */
-    EWidgetIndicatorValueModes["FORMULA"] = "FORMULA";
-    /** Шаблон формулы, предоставляемый системой */
-    EWidgetIndicatorValueModes["TEMPLATE"] = "TEMPLATE";
-    EWidgetIndicatorValueModes["AGGREGATION"] = "AGGREGATION";
-    EWidgetIndicatorValueModes["DURATION"] = "DURATION";
-    EWidgetIndicatorValueModes["CONVERSION"] = "CONVERSION";
-    EWidgetIndicatorValueModes["START_TIME"] = "START_TIME";
-    EWidgetIndicatorValueModes["END_TIME"] = "END_TIME";
-})(exports.EWidgetIndicatorValueModes || (exports.EWidgetIndicatorValueModes = {}));
-/** Режимы сортировки (на что ссылается сортировка) */
-exports.ESortingValueModes = void 0;
-(function (ESortingValueModes) {
-    /** Сортировка по формуле */
-    ESortingValueModes["FORMULA"] = "FORMULA";
-    /** Сортировка по показателю(разрезу или мере) виджета */
-    ESortingValueModes["IN_WIDGET"] = "IN_WIDGET";
-})(exports.ESortingValueModes || (exports.ESortingValueModes = {}));
-exports.EFormatOrFormattingMode = void 0;
-(function (EFormatOrFormattingMode) {
-    EFormatOrFormattingMode["BASE"] = "BASE";
-    EFormatOrFormattingMode["TEMPLATE"] = "TEMPLATE";
-})(exports.EFormatOrFormattingMode || (exports.EFormatOrFormattingMode = {}));
-/** Тип показателя */
-exports.EIndicatorType = void 0;
-(function (EIndicatorType) {
-    /** Показатели процесса */
-    EIndicatorType["PROCESS_MEASURE"] = "PROCESS_MEASURE";
-    /** Вводимое значение */
-    EIndicatorType["STATIC"] = "STATIC";
-    /** Статический список */
-    EIndicatorType["STATIC_LIST"] = "STATIC_LIST";
-    /** Динамический список */
-    EIndicatorType["DYNAMIC_LIST"] = "DYNAMIC_LIST";
-    /** Список колонок */
-    EIndicatorType["COLUMN_LIST"] = "COLUMN_LIST";
-    /** Разрез */
-    EIndicatorType["DIMENSION"] = "DIMENSION";
-    /** Мера */
-    EIndicatorType["MEASURE"] = "MEASURE";
-    /** Иерархия */
-    EIndicatorType["DYNAMIC_DIMENSION"] = "DYNAMIC_DIMENSION";
-    /** Пользовательская сортировка */
-    EIndicatorType["USER_SORTING"] = "USER_SORTING";
-})(exports.EIndicatorType || (exports.EIndicatorType = {}));
-/** Обобщенные типы значений переменных */
-exports.ESimpleInputType = void 0;
-(function (ESimpleInputType) {
-    /** Число (точность Float64) */
-    ESimpleInputType["NUMBER"] = "FLOAT";
-    /** Целое число (точность Int64) */
-    ESimpleInputType["INTEGER_NUMBER"] = "INTEGER";
-    /** Текст */
-    ESimpleInputType["TEXT"] = "STRING";
-    /** Дата (точность Date) */
-    ESimpleInputType["DATE"] = "DATE";
-    /** Дата и время (точность DateTime64) */
-    ESimpleInputType["DATE_AND_TIME"] = "DATETIME";
-    /** Логический тип */
-    ESimpleInputType["BOOLEAN"] = "BOOLEAN";
-})(exports.ESimpleInputType || (exports.ESimpleInputType = {}));
-function isDimensionsHierarchy(indicator) {
-    return "hierarchyDimensions" in indicator;
-}
-exports.OuterAggregation = void 0;
-(function (OuterAggregation) {
-    OuterAggregation["avg"] = "avgIf";
-    OuterAggregation["median"] = "medianIf";
-    OuterAggregation["count"] = "countIf";
-    OuterAggregation["countDistinct"] = "countIfDistinct";
-    OuterAggregation["min"] = "minIf";
-    OuterAggregation["max"] = "maxIf";
-    OuterAggregation["sum"] = "sumIf";
-})(exports.OuterAggregation || (exports.OuterAggregation = {}));
-exports.EDurationTemplateName = void 0;
-(function (EDurationTemplateName) {
-    EDurationTemplateName["avg"] = "avg";
-    EDurationTemplateName["median"] = "median";
-})(exports.EDurationTemplateName || (exports.EDurationTemplateName = {}));
-exports.EEventAppearances = void 0;
-(function (EEventAppearances) {
-    EEventAppearances["FIRST"] = "FIRST";
-    EEventAppearances["LAST"] = "LAST";
-})(exports.EEventAppearances || (exports.EEventAppearances = {}));
-
 function createAggregationTemplate$1(functionName, options) {
     return "process(".concat(functionName, "(").concat((options === null || options === void 0 ? void 0 : options.distinct) ? "distinct " : "", "{columnFormula}, {eventNameFormula} ={eventName}{filters}), {caseCaseIdFormula})");
 }
@@ -1454,35 +2038,6 @@ function getTransitionMeasureFormula(_a, process) {
     return "";
 }
 
-// Типы, используемые в значениях элементов управления.
-exports.EWidgetFilterMode = void 0;
-(function (EWidgetFilterMode) {
-    EWidgetFilterMode["DEFAULT"] = "DEFAULT";
-    EWidgetFilterMode["SINGLE"] = "SINGLE";
-    EWidgetFilterMode["DISABLED"] = "DISABLED";
-})(exports.EWidgetFilterMode || (exports.EWidgetFilterMode = {}));
-exports.EMarkdownDisplayMode = void 0;
-(function (EMarkdownDisplayMode) {
-    EMarkdownDisplayMode["NONE"] = "NONE";
-    EMarkdownDisplayMode["INDICATOR"] = "INDICATOR";
-})(exports.EMarkdownDisplayMode || (exports.EMarkdownDisplayMode = {}));
-exports.EDisplayConditionMode = void 0;
-(function (EDisplayConditionMode) {
-    EDisplayConditionMode["DISABLED"] = "DISABLED";
-    EDisplayConditionMode["FORMULA"] = "FORMULA";
-    EDisplayConditionMode["VARIABLE"] = "VARIABLE";
-})(exports.EDisplayConditionMode || (exports.EDisplayConditionMode = {}));
-exports.EFontWeight = void 0;
-(function (EFontWeight) {
-    EFontWeight["NORMAL"] = "NORMAL";
-    EFontWeight["BOLD"] = "BOLD";
-})(exports.EFontWeight || (exports.EFontWeight = {}));
-exports.EHeightMode = void 0;
-(function (EHeightMode) {
-    EHeightMode["FIXED"] = "FIXED";
-    EHeightMode["PERCENT"] = "PERCENT";
-})(exports.EHeightMode || (exports.EHeightMode = {}));
-
 function checkDisplayCondition(displayCondition, variables) {
     var _a;
     if ((displayCondition === null || displayCondition === void 0 ? void 0 : displayCondition.mode) === exports.EDisplayConditionMode.VARIABLE) {
@@ -2239,6 +2794,75 @@ var themed = function (scheme, selectThemeValue) {
     return scheme.meta((_a = {}, _a[themeValueMetaKey] = selectThemeValue, _a));
 };
 
+var ColorBaseSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.BASE),
+        value: z.string(),
+    });
+};
+var ColorRuleSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.RULE),
+        formula: z.string(),
+    });
+};
+var ColorAutoSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.AUTO),
+    });
+};
+var ColorDisabledSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.DISABLED),
+    });
+};
+var ColorGradientSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.GRADIENT),
+        startValue: z.string(),
+        endValue: z.string(),
+        classCount: z.number().min(3).max(10).nullish(),
+    });
+};
+var ColorFormulaSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.FORMULA),
+        formula: z.string(),
+    });
+};
+var ColorValuesSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.VALUES),
+        items: z.array(z.object({ value: z.string(), color: z.union([ColorBaseSchema(z), ColorRuleSchema(z)]) })),
+    });
+};
+var ColorByDimensionSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.BY_DIMENSION),
+        /** Имя разреза из области видимости правила отображения */
+        dimensionName: z.string(),
+        items: z.array(z.object({ value: z.string(), color: z.union([ColorBaseSchema(z), ColorRuleSchema(z)]) })),
+    });
+};
+var ColoredValueSchema = function (z) {
+    return z.object({
+        value: z.string(),
+        color: z.union([ColorBaseSchema(z), ColorRuleSchema(z)]),
+    });
+};
+var ColorSchema = function (z) {
+    return z.discriminatedUnion("mode", [
+        ColorAutoSchema(z),
+        ColorDisabledSchema(z),
+        ColorBaseSchema(z),
+        ColorRuleSchema(z),
+        ColorGradientSchema(z),
+        ColorFormulaSchema(z),
+        ColorValuesSchema(z),
+        ColorByDimensionSchema(z),
+    ]);
+};
+
 Object.defineProperty(exports, "ELanguages", {
     enumerable: true,
     get: function () { return localization$1.ELanguages; }
@@ -2247,6 +2871,59 @@ Object.defineProperty(exports, "EFilteringMethodValues", {
     enumerable: true,
     get: function () { return baseFilter.EFilteringMethodValues; }
 });
+exports.ActionButtonSchema = ActionButtonSchema;
+exports.ActionGoToURLSchema = ActionGoToURLSchema;
+exports.ActionOnClickParameterSchema = ActionOnClickParameterSchema;
+exports.ActionOpenInSchema = ActionOpenInSchema;
+exports.ActionOpenViewSchema = ActionOpenViewSchema;
+exports.ActionRunScriptSchema = ActionRunScriptSchema;
+exports.ActionSchema = ActionSchema;
+exports.ActionUpdateVariableSchema = ActionUpdateVariableSchema;
+exports.ActionsOnClickSchema = ActionsOnClickSchema;
+exports.AutoIdentifiedArrayItemSchema = AutoIdentifiedArrayItemSchema;
+exports.BaseWidgetSettingsSchema = BaseWidgetSettingsSchema;
+exports.ColorAutoSchema = ColorAutoSchema;
+exports.ColorBaseSchema = ColorBaseSchema;
+exports.ColorByDimensionSchema = ColorByDimensionSchema;
+exports.ColorDisabledSchema = ColorDisabledSchema;
+exports.ColorFormulaSchema = ColorFormulaSchema;
+exports.ColorGradientSchema = ColorGradientSchema;
+exports.ColorRuleSchema = ColorRuleSchema;
+exports.ColorSchema = ColorSchema;
+exports.ColorValuesSchema = ColorValuesSchema;
+exports.ColoredValueSchema = ColoredValueSchema;
+exports.ColumnIndicatorValueSchema = ColumnIndicatorValueSchema;
+exports.DisplayConditionSchema = DisplayConditionSchema;
+exports.FormatSchema = FormatSchema;
+exports.FormattingSchema = FormattingSchema;
+exports.MarkdownMeasureSchema = MarkdownMeasureSchema;
+exports.ParameterColumnListSchema = ParameterColumnListSchema;
+exports.ParameterFromAggregationSchema = ParameterFromAggregationSchema;
+exports.ParameterFromColumnSchema = ParameterFromColumnSchema;
+exports.ParameterFromDynamicListSchema = ParameterFromDynamicListSchema;
+exports.ParameterFromEndEventSchema = ParameterFromEndEventSchema;
+exports.ParameterFromEventSchema = ParameterFromEventSchema;
+exports.ParameterFromFormulaSchema = ParameterFromFormulaSchema;
+exports.ParameterFromManualInputSchema = ParameterFromManualInputSchema;
+exports.ParameterFromStartEventSchema = ParameterFromStartEventSchema;
+exports.ParameterFromStaticListSchema = ParameterFromStaticListSchema;
+exports.ParameterFromVariableSchema = ParameterFromVariableSchema;
+exports.ParameterTableListSchema = ParameterTableListSchema;
+exports.RangeSchema = RangeSchema;
+exports.ViewActionParameterSchema = ViewActionParameterSchema;
+exports.ViewActionSchema = ViewActionSchema;
+exports.WidgetActionParameterSchema = WidgetActionParameterSchema;
+exports.WidgetActionSchema = WidgetActionSchema;
+exports.WidgetColumnIndicatorSchema = WidgetColumnIndicatorSchema;
+exports.WidgetDimensionHierarchySchema = WidgetDimensionHierarchySchema;
+exports.WidgetDimensionSchema = WidgetDimensionSchema;
+exports.WidgetIndicatorAggregationValueSchema = WidgetIndicatorAggregationValueSchema;
+exports.WidgetIndicatorConversionValue = WidgetIndicatorConversionValue;
+exports.WidgetIndicatorDurationValue = WidgetIndicatorDurationValue;
+exports.WidgetIndicatorSchema = WidgetIndicatorSchema;
+exports.WidgetIndicatorTimeValueSchema = WidgetIndicatorTimeValueSchema;
+exports.WidgetMeasureSchema = WidgetMeasureSchema;
+exports.WidgetSortingIndicatorSchema = WidgetSortingIndicatorSchema;
 exports.applyIndexToArrayFormula = applyIndexToArrayFormula;
 exports.bindContentWithIndicator = bindContentWithIndicator;
 exports.bindContentsWithIndicators = bindContentsWithIndicators;