@infomaximum/widget-sdk 7.0.0-14 → 7.0.0-16

package/dist/index.esm.js

@@ -31,6 +31,7 @@ var apiVersions = [
     "16.2", // Для версии системы 250709
     "17", // 2508
     "18", // 2601
+    "19", // 2602
 ];
 /**
  * Актуальная версия settings, с которой работает система.
@@ -101,46 +102,6 @@ var EActionButtonsTypes;
     EActionButtonsTypes["SECONDARY"] = "primary-outlined";
 })(EActionButtonsTypes || (EActionButtonsTypes = {}));
 
-/**
- * Глобальный счетчик для генерации ID.
- *
- * @todo
- * В будущем можно заменить единый счетчик на изолированные счетчики в разных контекстах.
- */
-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().default(""),
-        titleSize: themed(z.number().default(14), function (theme) { return theme.widgets.titleSize; }),
-        titleColor: themed(ColorSchema(z), function (theme) { return theme.widgets.titleColor; }),
-        titleWeight: themed(z.enum(EFontWeight).default(EFontWeight.NORMAL), function (theme) { return theme.widgets.titleWeight; }),
-        stateName: z.string().nullable().default(null),
-        showMarkdown: z.boolean().default(false),
-        markdownMeasures: z.array(MarkdownMeasureSchema(z)).default([]),
-        markdownText: z.string().default(""),
-        markdownTextSize: z.number().default(14),
-        filters: z.array(SettingsFilterSchema(z)).default([]),
-        filterMode: z.enum(EWidgetFilterMode).default(EWidgetFilterMode.DEFAULT),
-        ignoreFilters: z.boolean().default(false),
-        sorting: z.array(WidgetSortingIndicatorSchema(z)).default([]),
-        actionButtons: z.array(ActionButtonSchema(z)).default([]),
-        paddings: themed(z.union([z.number(), z.string()]).default(8), function (theme) { return theme.widgets.paddings; }),
-        viewTheme: z.boolean().default(false),
-    });
-};
-
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -157,6 +118,20 @@ PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
 /* global Reflect, Promise, SuppressedError, Symbol */
 
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
 
 var __assign = function() {
     __assign = Object.assign || function __assign(t) {
@@ -210,6 +185,16 @@ function __read(o, n) {
     return ar;
 }
 
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
 function __makeTemplateObject(cooked, raw) {
     if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
     return cooked;
@@ -219,6 +204,217 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+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;
+    };
+}
+var clamp = function (value, min, max) {
+    if (value < min) {
+        return min;
+    }
+    if (value > max) {
+        return max;
+    }
+    return value;
+};
+/** Добавляет свойства к функции */
+function assignPropsToFn(fn, props) {
+    return Object.assign(fn, props);
+}
+
+/** Фабрика версионированных схем. Не содержит состояния */
+var VersionedSchemaFactory = /** @class */ (function () {
+    function VersionedSchemaFactory() {
+    }
+    VersionedSchemaFactory.compareVersions = function (a, b) {
+        var _a, _b;
+        var partsA = a.split(".").map(Number);
+        var partsB = b.split(".").map(Number);
+        var length = Math.max(partsA.length, partsB.length);
+        for (var i = 0; i < length; i++) {
+            var pa = (_a = partsA[i]) !== null && _a !== void 0 ? _a : 0;
+            var pb = (_b = partsB[i]) !== null && _b !== void 0 ? _b : 0;
+            var diff = Math.sign(pa - pb);
+            if (diff !== 0) {
+                return diff;
+            }
+        }
+        return 0;
+    };
+    VersionedSchemaFactory.findClosestVersion = function (versions, targetVersion, compare) {
+        return versions
+            .toSorted(function (a, b) { return compare(b, a); })
+            .find(function (version) { return compare(version, targetVersion) <= 0; });
+    };
+    /** Добавляет метаданные к схеме (curried) */
+    VersionedSchemaFactory.annotateSchema = function (meta) {
+        if (meta === undefined) {
+            return function (schemaFactory) { return schemaFactory; };
+        }
+        return function (schemaFactory) {
+            return (function (z) {
+                var restArgs = [];
+                for (var _i = 1; _i < arguments.length; _i++) {
+                    restArgs[_i - 1] = arguments[_i];
+                }
+                return schemaFactory.apply(void 0, __spreadArray([z], __read(restArgs), false)).meta(meta);
+            });
+        };
+    };
+    /** Построить версионированную схему */
+    VersionedSchemaFactory.build = function (_a) {
+        var _this = this;
+        var history = _a.history, latestVersion = _a.latestVersion, meta = _a.meta;
+        var latestFactory = history[latestVersion];
+        if (!latestFactory) {
+            throw new Error("Не найдено записи в 'history' по 'latestVersion'");
+        }
+        var map = this.annotateSchema(meta);
+        var schema = assignPropsToFn(map(latestFactory), {
+            forVersion: function (targetVersion) {
+                if (targetVersion === null || targetVersion === undefined) {
+                    return map(latestFactory);
+                }
+                if (targetVersion in history) {
+                    return map(history[targetVersion]);
+                }
+                var closestVersion = _this.findClosestVersion(Object.keys(history), targetVersion, VersionedSchemaFactory.compareVersions);
+                if (closestVersion === undefined || !(closestVersion in history)) {
+                    throw new Error("\u041D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E \u043F\u043E\u0434\u0445\u043E\u0434\u044F\u0449\u0435\u0439 \u0441\u0445\u0435\u043C\u044B \u0434\u043B\u044F \u0432\u0435\u0440\u0441\u0438\u0438 '".concat(targetVersion, "'"));
+                }
+                return map(history[closestVersion]);
+            },
+        });
+        return schema;
+    };
+    return VersionedSchemaFactory;
+}());
+
+/**
+ * Глобальный реестр версионированных схем (публичный слой, только чтение).
+ *
+ * Отвечает за:
+ *
+ * 1. Хранение зарегистрированных схем
+ * 2. Поиск схем по ключу
+ *
+ * Не предоставляет API для модификации registry.
+ */
+var SchemaRegistryReader = /** @class */ (function () {
+    function SchemaRegistryReader() {
+    }
+    /** Получить версионированную схему из `registry` по ключу схемы */
+    SchemaRegistryReader.get = function (schemaKey) {
+        return this.registry.get(schemaKey);
+    };
+    /**
+     * Имя поля в метаданных схемы, в котором хранится идентификатор типа схемы.
+     *
+     * Это поле добавляется ко всем схемам, зарегистрированным через `SchemaRegistry`.
+     */
+    SchemaRegistryReader.typeKey = "type";
+    SchemaRegistryReader.registry = new Map();
+    return SchemaRegistryReader;
+}());
+/**
+ * Глобальный реестр версионированных схем (внутренний слой).
+ *
+ * Расширяет SchemaRegistryReader возможностью создать запись в registry.
+ *
+ * Отвечает за:
+ * 1. Декларацию схем (build + аннотация)
+ * 2. Регистрацию схем по ключу
+ */
+var SchemaRegistry = /** @class */ (function (_super) {
+    __extends(SchemaRegistry, _super);
+    function SchemaRegistry() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /** Объявляет версионированную схему и регистрирует её во внутреннем `registry` */
+    SchemaRegistry.define = function (_a) {
+        var _b;
+        var key = _a.key, history = _a.history, latestVersion = _a.latestVersion;
+        var schema = VersionedSchemaFactory.build({
+            history: history,
+            latestVersion: latestVersion,
+            meta: (_b = {}, _b[this.typeKey] = key, _b),
+        });
+        this.registry.set(key, schema);
+        return schema;
+    };
+    return SchemaRegistry;
+}(SchemaRegistryReader));
+
+/**
+ * Глобальный счетчик для генерации ID.
+ *
+ * @todo
+ * В будущем можно заменить единый счетчик на изолированные счетчики в разных контекстах.
+ */
+var id = 1;
+var AutoIdentifiedArrayItemSchema = SchemaRegistry.define({
+    key: "AutoIdentifiedArrayItem",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                /**
+                 * Идентификатор, добавляемый системой "на лету" для удобства разработки, не сохраняется на сервер.
+                 * Гарантируется уникальность id в пределах settings виджета.
+                 */
+                id: z
+                    .number()
+                    .default(-1)
+                    .transform(function (currentId) { return (currentId === -1 ? id++ : currentId); }),
+            });
+        },
+    },
+});
+var BaseWidgetSettingsSchema = SchemaRegistry.define({
+    key: "BaseWidgetSettings",
+    latestVersion: "19",
+    get history() {
+        var v17 = function (z) {
+            return z.object({
+                title: z.string().default(""),
+                titleSize: themed(z.number().default(14), function (theme) { return theme.widgets.titleSize; }),
+                titleColor: themed(ColorSchema.forVersion("17")(z), function (theme) { return theme.widgets.titleColor; }),
+                titleWeight: themed(z.enum(EFontWeight).default(EFontWeight.NORMAL), function (theme) { return theme.widgets.titleWeight; }),
+                stateName: z.string().nullable().default(null),
+                showMarkdown: z.boolean().default(false),
+                markdownMeasures: z.array(MarkdownMeasureSchema.forVersion("17")(z)).default([]),
+                markdownText: z.string().default(""),
+                markdownTextSize: z.number().default(14),
+                filters: z.array(SettingsFilterSchema.forVersion("17")(z)).default([]),
+                filterMode: z.enum(EWidgetFilterMode).default(EWidgetFilterMode.DEFAULT),
+                ignoreFilters: z.boolean().default(false),
+                sorting: z.array(WidgetSortingIndicatorSchema.forVersion("17")(z)).default([]),
+                actionButtons: z.array(ActionButtonSchema.forVersion("17")(z)).default([]),
+                paddings: z.union([z.number(), z.string()]).default(8),
+                viewTheme: z.boolean().default(false),
+            });
+        };
+        return {
+            "17": v17,
+            "19": function (z) { return v17(z).omit({ paddings: true }); },
+        };
+    },
+});
+
 var EWidgetIndicatorType;
 (function (EWidgetIndicatorType) {
     EWidgetIndicatorType["MEASURE"] = "MEASURE";
@@ -358,35 +554,53 @@ var EHeightMode;
     EHeightMode["PERCENT"] = "PERCENT";
 })(EHeightMode || (EHeightMode = {}));
 
-var SortDirectionSchema = function (z) {
-    return z.union([z.literal(ESortDirection.ascend), z.literal(ESortDirection.descend)]);
-};
-var SortOrderSchema = function (z) {
-    return z.object({
-        /** Формула сортировки */
-        formula: FormulaSchema(z),
-        /** Тип данных формулы */
-        dbDataType: z.string().optional(),
-        /** Направление сортировки */
-        direction: SortDirectionSchema(z),
-        /** Условие применения сортировки */
-        displayCondition: FormulaSchema(z).optional(),
-    });
-};
-var WidgetSortingValueSchema = function (z) {
-    return z.discriminatedUnion("mode", [
-        z.object({
-            mode: z.literal(ESortingValueModes.FORMULA),
-            formula: FormulaSchema(z),
-            dbDataType: z.string().optional(),
-        }),
-        z.object({
-            mode: z.literal(ESortingValueModes.IN_WIDGET),
-            group: z.string(),
-            index: z.number(),
-        }),
-    ]);
-};
+var SortDirectionSchema = SchemaRegistry.define({
+    key: "SortDirection",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.union([z.literal(ESortDirection.ascend), z.literal(ESortDirection.descend)]);
+        },
+    },
+});
+var SortOrderSchema = SchemaRegistry.define({
+    key: "SortOrder",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                /** Формула сортировки */
+                formula: FormulaSchema.forVersion("17")(z),
+                /** Тип данных формулы */
+                dbDataType: z.string().optional(),
+                /** Направление сортировки */
+                direction: SortDirectionSchema.forVersion("17")(z),
+                /** Условие применения сортировки */
+                displayCondition: FormulaSchema.forVersion("17")(z).optional(),
+            });
+        },
+    },
+});
+var WidgetSortingValueSchema = SchemaRegistry.define({
+    key: "WidgetSortingValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.discriminatedUnion("mode", [
+                z.object({
+                    mode: z.literal(ESortingValueModes.FORMULA),
+                    formula: FormulaSchema.forVersion("17")(z),
+                    dbDataType: z.string().optional(),
+                }),
+                z.object({
+                    mode: z.literal(ESortingValueModes.IN_WIDGET),
+                    group: z.string(),
+                    index: z.number(),
+                }),
+            ]);
+        },
+    },
+});
 
 /** Ключи мета-данных внутри схем настроек */
 var ESettingsSchemaMetaKey;
@@ -398,35 +612,59 @@ var ESettingsSchemaMetaKey;
 })(ESettingsSchemaMetaKey || (ESettingsSchemaMetaKey = {}));
 
 var _a$7;
-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(EDisplayConditionMode.DISABLED),
-        }),
-        z.object({
-            mode: z.literal(EDisplayConditionMode.FORMULA),
-            formula: FormulaSchema(z),
-        }),
-        z.object({
-            mode: z.literal(EDisplayConditionMode.VARIABLE),
-            variableName: NameNullableSchema(z),
-            variableValue: z.string().nullable().default(null),
-        }),
-    ])
-        .default({ mode: EDisplayConditionMode.DISABLED });
-};
+var RangeSchema = SchemaRegistry.define({
+    key: "Range",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                unit: z.string().optional(),
+                min: z.number().optional(),
+                max: z.number().optional(),
+            });
+        },
+    },
+});
+var DisplayConditionSchema = SchemaRegistry.define({
+    key: "DisplayCondition",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z
+                .discriminatedUnion("mode", [
+                z.object({
+                    mode: z.literal(EDisplayConditionMode.DISABLED),
+                }),
+                z.object({
+                    mode: z.literal(EDisplayConditionMode.FORMULA),
+                    formula: FormulaSchema.forVersion("17")(z),
+                }),
+                z.object({
+                    mode: z.literal(EDisplayConditionMode.VARIABLE),
+                    variableName: NameNullableSchema.forVersion("17")(z),
+                    variableValue: z.string().nullable().default(null),
+                }),
+            ])
+                .default({ mode: EDisplayConditionMode.DISABLED });
+        },
+    },
+});
 /** Схема ключа сущности (с возможностью находиться в неинициализированном состоянии) */
-var KeyNullableSchema = function (z) { return z.string().nullable().default(null); };
+var KeyNullableSchema = SchemaRegistry.define({
+    key: "KeyNullable",
+    latestVersion: "17",
+    history: {
+        "17": function (z) { return z.string().nullable().default(null); },
+    },
+});
 /** Схема имени сущности (с возможностью находиться в неинициализированном состоянии) */
-var NameNullableSchema = function (z) { return z.string().nullable().default(null); };
+var NameNullableSchema = SchemaRegistry.define({
+    key: "NameNullable",
+    latestVersion: "17",
+    history: {
+        "17": function (z) { return z.string().nullable().default(null); },
+    },
+});
 /**
  * Перечисление системных типов сущностей в схеме настроек виджетов.
  * @note при расширении лучше положить на более общий уровень.
@@ -437,571 +675,929 @@ var EEntity;
 })(EEntity || (EEntity = {}));
 var formulaMeta = Object.freeze((_a$7 = {}, _a$7[ESettingsSchemaMetaKey.entity] = EEntity.formula, _a$7));
 /** Схема формулы */
-var FormulaSchema = function (z) { return z.string().default("").meta(formulaMeta); };
+var FormulaSchema = SchemaRegistry.define({
+    key: "Formula",
+    latestVersion: "17",
+    history: {
+        "17": function (z) { return z.string().default("").meta(formulaMeta); },
+    },
+});
 /**
  * Схема формулы, которая не может быть пустой строкой, но может быть в
  * неинициализированном состоянии null (вместо пустой строки)
  *
  * @note для обратной совместимости без необходимости писать миграции
  */
-var FormulaNullableSchema = function (z) {
-    return z.string().nullable().default(null).meta(formulaMeta);
-};
+var FormulaNullableSchema = SchemaRegistry.define({
+    key: "FormulaNullable",
+    latestVersion: "17",
+    history: {
+        "17": function (z) { return z.string().nullable().default(null).meta(formulaMeta); },
+    },
+});
 
-var WidgetIndicatorSchema = function (z) {
-    return AutoIdentifiedArrayItemSchema(z).extend({
-        name: z.string(),
-    });
-};
-var FormatSchema = function (z) {
-    return z
-        .discriminatedUnion("mode", [
-        z.object({
-            mode: z.literal(EFormatOrFormattingMode.BASE),
-            value: z.enum(EFormatTypes).default(EFormatTypes.STRING).optional(),
-        }),
-        z.object({
-            mode: z.literal(EFormatOrFormattingMode.TEMPLATE),
-            value: z.string().default("").optional(),
-        }),
-    ])
-        .default({ mode: EFormatOrFormattingMode.BASE, value: EFormatTypes.STRING });
-};
-var FormattingSchema = function (z) {
-    return z
-        .discriminatedUnion("mode", [
-        z.object({
-            mode: z.literal(EFormatOrFormattingMode.BASE),
-            value: z.enum(EFormattingPresets).default(EFormattingPresets.AUTO),
-        }),
-        z.object({
-            mode: z.literal(EFormatOrFormattingMode.TEMPLATE),
-            value: z.string().default(""),
-        }),
-    ])
-        .default({ mode: EFormatOrFormattingMode.BASE, value: EFormattingPresets.AUTO });
-};
-var WidgetColumnIndicatorSchema = function (z) {
-    return WidgetIndicatorSchema(z).extend({
-        dbDataType: z.string().optional(),
-        format: FormatSchema(z).optional(),
-        formatting: FormattingSchema(z).optional(),
-        displayCondition: DisplayConditionSchema(z),
-        onClick: z.array(ActionsOnClickSchema(z)).optional(),
-    });
-};
-var WidgetIndicatorFormulaValueSchema = function (z) {
-    return z.object({
-        mode: z.literal(EWidgetIndicatorValueModes.FORMULA),
-        formula: FormulaSchema(z).optional(),
-    });
-};
-var WidgetIndicatorTemplateValueSchema = function (z) {
-    return z.object({
-        mode: z.literal(EWidgetIndicatorValueModes.TEMPLATE),
-        /** Имя шаблонной формулы, использующей колонку таблицы */
-        templateName: z.string().optional(),
-        /** Имя таблицы */
-        tableName: z.string().optional(),
-        /** Имя колонки */
-        columnName: z.string().optional(),
-    });
-};
-var ColumnIndicatorValueSchema = function (z) {
-    return z.union([MeasureValueSchema(z), DimensionValueSchema(z)]);
-};
-var MeasureValueSchema = function (z) {
-    return z.discriminatedUnion("mode", [
-        WidgetIndicatorFormulaValueSchema(z),
-        WidgetIndicatorTemplateValueSchema(z).extend({
-            innerTemplateName: z.enum(EMeasureInnerTemplateNames).optional(),
-        }),
-    ]);
-};
-var DimensionValueSchema = function (z) {
-    return z.discriminatedUnion("mode", [
-        WidgetIndicatorFormulaValueSchema(z),
-        WidgetIndicatorTemplateValueSchema(z).extend({
-            innerTemplateName: z.never().optional(),
-        }),
-    ]);
-};
-var WidgetIndicatorAggregationValueSchema = function (z) {
-    return z.object({
-        mode: z.literal(EWidgetIndicatorValueModes.AGGREGATION),
-        templateName: z.string(),
-        processKey: KeyNullableSchema(z),
-        eventName: NameNullableSchema(z),
-        eventNameFormula: FormulaNullableSchema(z),
-        anyEvent: z.literal(true).optional(),
-        caseCaseIdFormula: FormulaNullableSchema(z),
-        filters: z.array(ExtendedFormulaFilterValueSchema(z)).default([]),
-        tableName: z.string().optional(),
-        columnName: z.string().optional(),
-        eventTimeFormula: FormulaNullableSchema(z).optional(),
-        innerTemplateName: z.string().optional(),
-    });
-};
-var WidgetMeasureAggregationValueSchema = function (z) {
-    return WidgetIndicatorAggregationValueSchema(z).extend({ outerAggregation: z.enum(EOuterAggregation) });
-};
-var WidgetIndicatorTimeValueSchema = function (z) {
-    return z.object({
-        templateName: z.string(),
-        mode: z.union([
-            z.literal(EWidgetIndicatorValueModes.START_TIME),
-            z.literal(EWidgetIndicatorValueModes.END_TIME),
-        ]),
-        processKey: KeyNullableSchema(z),
-        eventName: NameNullableSchema(z),
-        eventTimeFormula: FormulaNullableSchema(z),
-        caseCaseIdFormula: FormulaNullableSchema(z),
-        eventNameFormula: FormulaNullableSchema(z),
-        filters: z.array(ExtendedFormulaFilterValueSchema(z)).default([]),
-    });
-};
-var WidgetDimensionSchema = function (z) {
-    return WidgetColumnIndicatorSchema(z).extend({
-        value: z
-            .discriminatedUnion("mode", [
-            DimensionValueSchema(z),
-            WidgetIndicatorAggregationValueSchema(z).extend({
+var WidgetIndicatorSchema = SchemaRegistry.define({
+    key: "WidgetIndicator",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return AutoIdentifiedArrayItemSchema.forVersion("17")(z).extend({
+                name: z.string(),
+            });
+        },
+    },
+});
+var FormatSchema = SchemaRegistry.define({
+    key: "Format",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z
+                .discriminatedUnion("mode", [
+                z.object({
+                    mode: z.literal(EFormatOrFormattingMode.BASE),
+                    value: z.enum(EFormatTypes).default(EFormatTypes.STRING).optional(),
+                }),
+                z.object({
+                    mode: z.literal(EFormatOrFormattingMode.TEMPLATE),
+                    value: z.string().default("").optional(),
+                }),
+            ])
+                .default({ mode: EFormatOrFormattingMode.BASE, value: EFormatTypes.STRING });
+        },
+    },
+});
+var FormattingSchema = SchemaRegistry.define({
+    key: "Formatting",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z
+                .discriminatedUnion("mode", [
+                z.object({
+                    mode: z.literal(EFormatOrFormattingMode.BASE),
+                    value: z.enum(EFormattingPresets).default(EFormattingPresets.AUTO),
+                }),
+                z.object({
+                    mode: z.literal(EFormatOrFormattingMode.TEMPLATE),
+                    value: z.string().default(""),
+                }),
+            ])
+                .default({ mode: EFormatOrFormattingMode.BASE, value: EFormattingPresets.AUTO });
+        },
+    },
+});
+var WidgetColumnIndicatorSchema = SchemaRegistry.define({
+    key: "WidgetColumnIndicator",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return WidgetIndicatorSchema.forVersion("17")(z).extend({
+                dbDataType: z.string().optional(),
+                format: FormatSchema.forVersion("17")(z).optional(),
+                formatting: FormattingSchema.forVersion("17")(z).optional(),
+                displayCondition: DisplayConditionSchema.forVersion("17")(z),
+                onClick: z.array(ActionsOnClickSchema.forVersion("17")(z)).default([]).optional(),
+            });
+        },
+    },
+});
+var WidgetIndicatorFormulaValueSchema = SchemaRegistry.define({
+    key: "WidgetIndicatorFormulaValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EWidgetIndicatorValueModes.FORMULA),
+                formula: FormulaSchema.forVersion("17")(z).optional(),
+            });
+        },
+    },
+});
+var WidgetIndicatorTemplateValueSchema = SchemaRegistry.define({
+    key: "WidgetIndicatorTemplateValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EWidgetIndicatorValueModes.TEMPLATE),
+                /** Имя шаблонной формулы, использующей колонку таблицы */
+                templateName: z.string().optional(),
+                /** Имя таблицы */
+                tableName: z.string().optional(),
+                /** Имя колонки */
+                columnName: z.string().optional(),
+            });
+        },
+    },
+});
+var ColumnIndicatorValueSchema = SchemaRegistry.define({
+    key: "ColumnIndicatorValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.union([MeasureValueSchema.forVersion("17")(z), DimensionValueSchema.forVersion("17")(z)]);
+        },
+    },
+});
+var MeasureValueSchema = SchemaRegistry.define({
+    key: "MeasureValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.discriminatedUnion("mode", [
+                WidgetIndicatorFormulaValueSchema.forVersion("17")(z),
+                WidgetIndicatorTemplateValueSchema.forVersion("17")(z).extend({
+                    innerTemplateName: z.enum(EMeasureInnerTemplateNames).optional(),
+                }),
+            ]);
+        },
+    },
+});
+var DimensionValueSchema = SchemaRegistry.define({
+    key: "DimensionValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.discriminatedUnion("mode", [
+                WidgetIndicatorFormulaValueSchema.forVersion("17")(z),
+                WidgetIndicatorTemplateValueSchema.forVersion("17")(z).extend({
+                    innerTemplateName: z.never().optional(),
+                }),
+            ]);
+        },
+    },
+});
+var WidgetIndicatorAggregationValueSchema = SchemaRegistry.define({
+    key: "WidgetIndicatorAggregationValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EWidgetIndicatorValueModes.AGGREGATION),
+                templateName: z.string(),
+                processKey: KeyNullableSchema.forVersion("17")(z),
+                eventName: NameNullableSchema.forVersion("17")(z),
+                eventNameFormula: FormulaNullableSchema.forVersion("17")(z),
+                anyEvent: z.literal(true).optional(),
+                caseCaseIdFormula: FormulaNullableSchema.forVersion("17")(z),
+                filters: z.array(ExtendedFormulaFilterValueSchema.forVersion("17")(z)).default([]),
+                tableName: z.string().optional(),
+                columnName: z.string().optional(),
+                eventTimeFormula: FormulaNullableSchema.forVersion("17")(z).optional(),
                 innerTemplateName: z.string().optional(),
-            }),
-            WidgetIndicatorTimeValueSchema(z),
-        ])
-            .optional(),
-        hideEmptyValues: z.boolean().default(false),
-    });
-};
-var WidgetDimensionInHierarchySchema = function (z) {
-    return WidgetDimensionSchema(z).omit({ displayCondition: true });
-};
-var WidgetDimensionHierarchySchema = function (z, dimensionSchema) {
-    return AutoIdentifiedArrayItemSchema(z).extend({
-        name: z.string(),
-        // Для иерархии является дискриминатором, для него нельзя задавать дефолтное значение.
-        hierarchyDimensions: z.array(dimensionSchema),
-        displayCondition: DisplayConditionSchema(z),
-    });
-};
-var WidgetIndicatorConversionValueSchema = function (z) {
-    return z.object({
-        mode: z.literal(EWidgetIndicatorValueModes.CONVERSION),
-        startEventNameFormula: FormulaNullableSchema(z),
-        startEventProcessKey: KeyNullableSchema(z),
-        startEventName: NameNullableSchema(z),
-        startEventFilters: z.array(ExtendedFormulaFilterValueSchema(z)).default([]),
-        startEventTimeFormula: FormulaNullableSchema(z),
-        endEventNameFormula: FormulaNullableSchema(z),
-        endEventProcessKey: KeyNullableSchema(z),
-        endEventName: NameNullableSchema(z),
-        endEventFilters: z.array(ExtendedFormulaFilterValueSchema(z)).default([]),
-        endCaseCaseIdFormula: FormulaNullableSchema(z),
-        endEventTimeFormula: FormulaNullableSchema(z),
-    });
-};
-var WidgetIndicatorDurationValueSchema = function (z) {
-    return WidgetIndicatorConversionValueSchema(z).extend({
-        mode: z.literal(EWidgetIndicatorValueModes.DURATION),
-        templateName: z.string(),
-        startEventAppearances: z.enum(EEventAppearances),
-        endEventAppearances: z.enum(EEventAppearances),
-    });
-};
-var WidgetMeasureSchema = function (z) {
-    return WidgetColumnIndicatorSchema(z).extend({
-        value: z
-            .discriminatedUnion("mode", [
-            MeasureValueSchema(z),
-            WidgetMeasureAggregationValueSchema(z),
-            WidgetIndicatorConversionValueSchema(z),
-            WidgetIndicatorDurationValueSchema(z),
-        ])
-            .optional(),
-    });
-};
-var MarkdownMeasureSchema = function (z) {
-    return WidgetMeasureSchema(z).extend({
-        displaySign: z.enum(EMarkdownDisplayMode).default(EMarkdownDisplayMode.NONE),
-    });
-};
-var WidgetSortingIndicatorSchema = function (z) {
-    return WidgetIndicatorSchema(z).extend({
-        direction: SortDirectionSchema(z),
-        value: WidgetSortingValueSchema(z),
-    });
-};
-var ProcessIndicatorValueSchema = function (z) {
-    return z.discriminatedUnion("mode", [
-        z.object({
-            mode: z.literal(EWidgetIndicatorValueModes.FORMULA),
-            formula: FormulaSchema(z),
-        }),
-        z.object({
-            mode: z.literal(EWidgetIndicatorValueModes.TEMPLATE),
-            /** Имя шаблонной формулы, использующей колонку таблицы */
-            templateName: z.string(),
-        }),
-    ]);
-};
-var ProcessIndicatorSchema = function (z) {
-    return WidgetIndicatorSchema(z).extend({
-        value: ProcessIndicatorValueSchema(z).optional(),
-        dbDataType: z.string().optional(),
-        format: FormatSchema(z).optional(),
-        formatting: FormattingSchema(z).optional(),
-        displayCondition: DisplayConditionSchema(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.union([z.enum(EFormatTypes), z.string()]).optional(),
-        filteringMethod: z.enum(Object.values(formulaFilterMethods)),
-        checkedValues: z.array(z.string().nullable()).optional(),
-        formValues: z
-            .object((_a = {},
-            _a[EFormulaFilterFieldKeys.date] = z.string().nullable(),
-            _a[EFormulaFilterFieldKeys.dateRange] = z.tuple([z.string(), z.string()]),
-            _a[EFormulaFilterFieldKeys.numberRange] = z.tuple([
-                z.number().nullable(),
-                z.number().nullable(),
-            ]),
-            _a[EFormulaFilterFieldKeys.string] = z.string(),
-            // todo: отказаться от использования z.string(), оставить только z.number() [BI-15912]
-            _a[EFormulaFilterFieldKeys.lastTimeValue] = z.number().or(z.string()),
-            _a[EFormulaFilterFieldKeys.lastTimeUnit] = z.enum(ELastTimeUnit),
-            _a[EFormulaFilterFieldKeys.durationUnit] = z.enum(EDurationUnit),
-            _a))
-            .partial()
-            .optional(),
-    });
-};
-var ExtendedFormulaFilterValueSchema = function (z) {
-    return z.union([FormulaFilterValueSchema(z), z.object({ formula: z.string() })]);
-};
-var DimensionProcessFilterSchema = function (z) {
-    return z.object({
-        value: z.union([
-            WidgetIndicatorAggregationValueSchema(z).extend({
+            });
+        },
+    },
+});
+var WidgetMeasureAggregationValueSchema = SchemaRegistry.define({
+    key: "WidgetMeasureAggregationValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return WidgetIndicatorAggregationValueSchema.forVersion("17")(z).extend({
                 outerAggregation: z.enum(EOuterAggregation),
-            }),
-            WidgetIndicatorAggregationValueSchema(z).extend({
-                innerTemplateName: z.string().optional(),
-            }),
-            WidgetIndicatorTimeValueSchema(z),
-            z.object({
-                mode: z.literal(EWidgetIndicatorValueModes.FORMULA),
-                formula: z.string().optional(),
-            }),
-        ]),
-        dbDataType: z.string(),
-        condition: z.object({
-            filteringMethod: z.enum(Object.values(formulaFilterMethods)),
-            timeUnit: z.enum(EDimensionProcessFilterTimeUnit).optional(),
-            values: z.array(z.string().nullable()),
-        }),
-    });
-};
-var SettingsFilterSchema = function (z) {
-    return z.union([ExtendedFormulaFilterValueSchema(z), DimensionProcessFilterSchema(z)]);
-};
+            });
+        },
+    },
+});
+var WidgetIndicatorTimeValueSchema = SchemaRegistry.define({
+    key: "WidgetIndicatorTimeValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                templateName: z.string(),
+                mode: z.union([
+                    z.literal(EWidgetIndicatorValueModes.START_TIME),
+                    z.literal(EWidgetIndicatorValueModes.END_TIME),
+                ]),
+                processKey: KeyNullableSchema.forVersion("17")(z),
+                eventName: NameNullableSchema.forVersion("17")(z),
+                eventTimeFormula: FormulaNullableSchema.forVersion("17")(z),
+                caseCaseIdFormula: FormulaNullableSchema.forVersion("17")(z),
+                eventNameFormula: FormulaNullableSchema.forVersion("17")(z),
+                filters: z.array(ExtendedFormulaFilterValueSchema.forVersion("17")(z)).default([]),
+            });
+        },
+    },
+});
+var WidgetDimensionSchema = SchemaRegistry.define({
+    key: "WidgetDimension",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return WidgetColumnIndicatorSchema.forVersion("17")(z).extend({
+                value: z
+                    .discriminatedUnion("mode", [
+                    DimensionValueSchema.forVersion("17")(z),
+                    WidgetIndicatorAggregationValueSchema.forVersion("17")(z).extend({
+                        innerTemplateName: z.string().optional(),
+                    }),
+                    WidgetIndicatorTimeValueSchema.forVersion("17")(z),
+                ])
+                    .optional(),
+                hideEmptyValues: z.boolean().default(false),
+            });
+        },
+    },
+});
+var WidgetDimensionInHierarchySchema = SchemaRegistry.define({
+    key: "WidgetDimensionInHierarchy",
+    latestVersion: "17",
+    history: {
+        "17": function (z) { return WidgetDimensionSchema.forVersion("17")(z).omit({ displayCondition: true }); },
+    },
+});
+var WidgetDimensionHierarchySchema = SchemaRegistry.define({
+    key: "WidgetDimensionHierarchy",
+    latestVersion: "17",
+    history: {
+        "17": function (z, dimensionSchema) {
+            return AutoIdentifiedArrayItemSchema.forVersion("17")(z).extend({
+                name: z.string(),
+                // Для иерархии является дискриминатором, для него нельзя задавать дефолтное значение.
+                hierarchyDimensions: z.array(dimensionSchema),
+                displayCondition: DisplayConditionSchema.forVersion("17")(z),
+            });
+        },
+    },
+});
+var WidgetIndicatorConversionValueSchema = SchemaRegistry.define({
+    key: "WidgetIndicatorConversionValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EWidgetIndicatorValueModes.CONVERSION),
+                startEventNameFormula: FormulaNullableSchema.forVersion("17")(z),
+                startEventProcessKey: KeyNullableSchema.forVersion("17")(z),
+                startEventName: NameNullableSchema.forVersion("17")(z),
+                startEventFilters: z
+                    .array(ExtendedFormulaFilterValueSchema.forVersion("17")(z))
+                    .default([]),
+                startEventTimeFormula: FormulaNullableSchema.forVersion("17")(z),
+                endEventNameFormula: FormulaNullableSchema.forVersion("17")(z),
+                endEventProcessKey: KeyNullableSchema.forVersion("17")(z),
+                endEventName: NameNullableSchema.forVersion("17")(z),
+                endEventFilters: z.array(ExtendedFormulaFilterValueSchema.forVersion("17")(z)).default([]),
+                endCaseCaseIdFormula: FormulaNullableSchema.forVersion("17")(z),
+                endEventTimeFormula: FormulaNullableSchema.forVersion("17")(z),
+            });
+        },
+    },
+});
+var WidgetIndicatorDurationValueSchema = SchemaRegistry.define({
+    key: "WidgetIndicatorDurationValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return WidgetIndicatorConversionValueSchema.forVersion("17")(z).extend({
+                mode: z.literal(EWidgetIndicatorValueModes.DURATION),
+                templateName: z.string(),
+                startEventAppearances: z.enum(EEventAppearances),
+                endEventAppearances: z.enum(EEventAppearances),
+            });
+        },
+    },
+});
+var WidgetMeasureSchema = SchemaRegistry.define({
+    key: "WidgetMeasure",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return WidgetColumnIndicatorSchema.forVersion("17")(z).extend({
+                value: z
+                    .discriminatedUnion("mode", [
+                    MeasureValueSchema.forVersion("17")(z),
+                    WidgetMeasureAggregationValueSchema.forVersion("17")(z),
+                    WidgetIndicatorConversionValueSchema.forVersion("17")(z),
+                    WidgetIndicatorDurationValueSchema.forVersion("17")(z),
+                ])
+                    .optional(),
+            });
+        },
+    },
+});
+var MarkdownMeasureSchema = SchemaRegistry.define({
+    key: "MarkdownMeasure",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return WidgetMeasureSchema.forVersion("17")(z).extend({
+                displaySign: z.enum(EMarkdownDisplayMode).default(EMarkdownDisplayMode.NONE),
+            });
+        },
+    },
+});
+var WidgetSortingIndicatorSchema = SchemaRegistry.define({
+    key: "WidgetSortingIndicator",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return WidgetIndicatorSchema.forVersion("17")(z).extend({
+                direction: SortDirectionSchema.forVersion("17")(z),
+                value: WidgetSortingValueSchema.forVersion("17")(z),
+            });
+        },
+    },
+});
+var ProcessIndicatorValueSchema = SchemaRegistry.define({
+    key: "ProcessIndicatorValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.discriminatedUnion("mode", [
+                z.object({
+                    mode: z.literal(EWidgetIndicatorValueModes.FORMULA),
+                    formula: FormulaSchema.forVersion("17")(z),
+                }),
+                z.object({
+                    mode: z.literal(EWidgetIndicatorValueModes.TEMPLATE),
+                    /** Имя шаблонной формулы, использующей колонку таблицы */
+                    templateName: z.string(),
+                }),
+            ]);
+        },
+    },
+});
+var ProcessIndicatorSchema = SchemaRegistry.define({
+    key: "ProcessIndicator",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return WidgetIndicatorSchema.forVersion("17")(z).extend({
+                value: ProcessIndicatorValueSchema.forVersion("17")(z).optional(),
+                dbDataType: z.string().optional(),
+                format: FormatSchema.forVersion("17")(z).optional(),
+                formatting: FormattingSchema.forVersion("17")(z).optional(),
+                displayCondition: DisplayConditionSchema.forVersion("17")(z),
+            });
+        },
+    },
+});
 
-var ActionOnClickParameterCommonSchema = function (z) {
-    return AutoIdentifiedArrayItemSchema(z).extend({
-        name: z.string(),
-    });
-};
-var ParameterFromColumnSchema = function (z) {
-    return z.object({
-        inputMethod: z.literal(EWidgetActionInputMethod.COLUMN),
-        tableName: z.string().nullable().default(null),
-        columnName: z.string().nullable().default(null),
-        dbDataType: z.string().optional(),
-    });
-};
-var ParameterFromVariableSchema = function (z) {
-    return z.object({
-        inputMethod: z.literal(EWidgetActionInputMethod.VARIABLE),
-        sourceVariable: z.string().nullable().default(null),
-    });
-};
-var ParameterFromFormulaSchema = function (z) {
-    return z.object({
-        inputMethod: z.literal(EWidgetActionInputMethod.FORMULA),
-        formula: FormulaSchema(z),
-        considerFilters: z.boolean().default(false),
-        dbDataType: z.string().optional(),
-    });
-};
-var ParameterFromEventSchema = function (z) {
-    return z.object({
-        inputMethod: z.literal(EWidgetActionInputMethod.EVENT),
-    });
-};
-var ParameterFromStartEventSchema = function (z) {
-    return z.object({
-        inputMethod: z.literal(EWidgetActionInputMethod.START_EVENT),
-    });
-};
-var ParameterFromEndEventSchema = function (z) {
-    return z.object({
-        inputMethod: z.literal(EWidgetActionInputMethod.FINISH_EVENT),
-    });
-};
-var ParameterFromAggregationSchema = function (z) {
-    return z.object({
-        inputMethod: z.literal(EWidgetActionInputMethod.AGGREGATION),
-        formula: FormulaSchema(z),
-        considerFilters: z.boolean().default(false),
-        dbDataType: z.string().optional(),
-    });
-};
-var ParameterFromManualInputSchema = function (z) {
-    return z.object({
-        inputMethod: z.literal(EWidgetActionInputMethod.MANUALLY),
-        description: z.string().default(""),
-        defaultValue: FormulaSchema(z),
-        dbDataType: z.string().optional(),
-        filterByRows: z.boolean().default(false),
-        validation: FormulaSchema(z),
-        acceptEmptyValue: z.boolean().default(false),
-    });
-};
-var ParameterFromStaticListSchema = function (z) {
-    return z.object({
-        inputMethod: z.literal(EWidgetActionInputMethod.STATIC_LIST),
-        options: z.string().default(""),
-        defaultValue: z
-            .union([z.string(), z.array(z.string())])
-            .nullable()
-            .default(null),
-        acceptEmptyValue: z.boolean().default(false),
-    });
-};
-var ParameterFromDynamicListSchema = function (z) {
-    return z.object({
-        inputMethod: z.literal(EWidgetActionInputMethod.DYNAMIC_LIST),
-        options: FormulaSchema(z),
-        defaultValue: FormulaSchema(z),
-        dbDataType: z.string().optional(),
-        displayOptions: FormulaSchema(z),
-        filters: z.array(ExtendedFormulaFilterValueSchema(z)).default([]),
-        filterByRows: z.boolean().default(false),
-        considerFilters: z.boolean().default(false),
-        insertAnyValues: z.boolean().default(false),
-        validation: FormulaSchema(z),
-        acceptEmptyValue: z.boolean().default(false),
-    });
-};
-var ParameterFromDataModelSchema = function (z) {
-    return z.object({
-        inputMethod: z.literal(EWidgetActionInputMethod.DATA_MODEL),
-        option: z.enum(EDataModelOption).default(EDataModelOption.TABLE_LIST),
-        /**
-         * Используется только при COLUMN_LIST. Не делаем union по option, чтобы сохранить
-         * одновременно default для option и работоспособность внешнего discriminated union.
-         */
-        parent: NameNullableSchema(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 ActionDrillDownSchema = function (z) {
-    return ActionCommonSchema(z).extend({
-        type: z.literal(EActionTypes.DRILL_DOWN),
-        variables: z.array(ActionOnClickParameterSchema(z)).default([]),
-    });
-};
-var ActionGoToURLSchema = function (z) {
-    return ActionCommonSchema(z).extend({
-        type: z.literal(EActionTypes.OPEN_URL),
-        url: z.string(),
-        newWindow: z.boolean().default(true),
-        variables: z.array(ActionOnClickParameterSchema(z)).default([]),
-    });
-};
-var ActivateConditionSchema = function (z) {
-    return z
-        .discriminatedUnion("mode", [
-        z.object({
-            mode: z.literal(EActivateConditionMode.FORMULA),
-            formula: FormulaSchema(z),
-        }),
-        z.object({
-            mode: z.literal(EActivateConditionMode.VARIABLE),
-            variableName: z.string().nullable().default(null),
-            variableValue: z.string().nullable().default(null),
-        }),
-    ])
-        .default({ mode: EActivateConditionMode.FORMULA, formula: "" });
-};
-var ActionRunScriptSchema = function (z) {
-    return ActionCommonSchema(z).extend({
-        type: z.literal(EActionTypes.EXECUTE_SCRIPT),
-        parameters: z.array(ActionOnClickParameterSchema(z)).default([]),
-        scriptKey: z.string(),
-        autoUpdate: z.enum(EAutoUpdateMode).default(EAutoUpdateMode.THIS_WIDGET),
-        hideInactiveButton: z.boolean().default(false),
-        activateCondition: ActivateConditionSchema(z),
-        hint: z.string().default(""),
-        variables: z.array(ActionOnClickParameterSchema(z)).default([]),
-        runButtonText: z.string().default(""),
-    });
-};
-var ActionUpdateVariableSchema = function (z) {
-    return ActionCommonSchema(z).extend({
-        type: z.literal(EActionTypes.UPDATE_VARIABLE),
-        variables: z.array(ActionOnClickParameterSchema(z)).default([]),
-    });
-};
-var ActionOpenInSchema = function (z) {
-    return z.discriminatedUnion("openIn", [
-        z.object({
-            openIn: z.literal(EViewOpenIn.DRAWER_WINDOW),
-            alignment: z.enum(EDrawerPlacement).default(EDrawerPlacement.RIGHT),
-            inheritFilter: z.boolean().default(true),
-        }),
-        z.object({
-            openIn: z.literal(EViewOpenIn.PLACEHOLDER),
-            placeholderName: z.string().optional(),
-        }),
-        z.object({
-            openIn: z.literal(EViewOpenIn.MODAL_WINDOW),
-            positionByClick: z.boolean().default(false),
-            inheritFilter: z.boolean().default(true),
-        }),
-        z.object({
-            openIn: z.literal(EViewOpenIn.WINDOW),
-            newWindow: z.boolean().default(true),
-            inheritFilter: z.boolean().default(true),
-        }),
-    ]);
-};
-var ActionOpenViewCommonSchema = function (z) {
-    return ActionCommonSchema(z).extend({
-        type: z.literal(EActionTypes.OPEN_VIEW),
-        variables: z.array(ActionOnClickParameterSchema(z)).default([]),
-    });
-};
-var ActionOpenViewSchema = function (z) {
-    return z.intersection(z.discriminatedUnion("mode", [
-        ActionOpenViewCommonSchema(z).extend({
-            mode: z.literal(EViewMode.GENERATED_BY_SCRIPT),
-            scriptKey: z.string().optional(),
-            parameters: z.array(ActionOnClickParameterSchema(z)).default([]),
-            displayName: z.string().default(""),
-        }),
-        ActionOpenViewCommonSchema(z).extend({
-            mode: z.literal(EViewMode.EXISTED_VIEW),
-            viewKey: z.string().optional(),
-            parameters: z.array(ActionOnClickParameterSchema(z)).default([]),
-        }),
-        ActionOpenViewCommonSchema(z).extend({
-            mode: z.literal(EViewMode.EMPTY),
-            placeholderName: z.string().optional(),
-            openIn: z.literal(EViewOpenIn.PLACEHOLDER),
-        }),
-    ]), ActionOpenInSchema(z));
-};
-var ActionsOnClickSchema = function (z) {
-    return z.union([
-        ActionGoToURLSchema(z),
-        ActionRunScriptSchema(z),
-        ActionUpdateVariableSchema(z),
-        ActionOpenViewSchema(z),
-        ActionDrillDownSchema(z),
-    ]);
-};
-var WidgetActionParameterCommonSchema = function (z) {
-    return AutoIdentifiedArrayItemSchema(z).extend({
-        name: z.string(),
-        displayName: z.string().default(""),
-        isHidden: z.boolean().default(false),
-    });
-};
-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)).default([]),
-        type: z.literal(EActionTypes.EXECUTE_SCRIPT),
-        scriptKey: z.string(),
-        autoUpdate: z.enum(EAutoUpdateMode).default(EAutoUpdateMode.THIS_WIDGET),
-        description: z.string().default(""),
-        hideInactiveButton: z.boolean().default(false),
-        hint: z.string().default(""),
-        activateCondition: ActivateConditionSchema(z),
-        variables: z.array(WidgetActionParameterSchema(z)).default([]),
-        runButtonText: z.string().default(""),
-    });
-};
-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 AutoIdentifiedArrayItemSchema(z).extend({
-        name: z.string(),
-        buttonType: z.enum(EActionButtonsTypes).default(EActionButtonsTypes.BASE),
-        type: z.literal(EActionTypes.EXECUTE_SCRIPT).default(EActionTypes.EXECUTE_SCRIPT),
-        parameters: z.array(ViewActionParameterSchema(z)).default([]),
-        scriptKey: KeyNullableSchema(z),
-        autoUpdate: z
-            .union([z.literal(EAutoUpdateMode.NONE), z.literal(EAutoUpdateMode.ALL_VIEWS)])
-            .default(EAutoUpdateMode.NONE),
-    });
-};
-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)).default([]),
-        buttonType: z.enum(EActionButtonsTypes).default(EActionButtonsTypes.BASE),
-        backgroundColor: ColorSchema(z),
-        borderColor: ColorSchema(z),
-        color: ColorSchema(z),
-        hint: z.string().default(""),
-    });
-};
+var FormulaFilterValueSchema = SchemaRegistry.define({
+    key: "FormulaFilterValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            var _a;
+            return z.object({
+                name: z.string().nullish(),
+                formula: FormulaSchema.forVersion("17")(z),
+                sliceIndex: z.number().optional(),
+                dbDataType: z.string(),
+                format: z.union([z.enum(EFormatTypes), z.string()]).optional(),
+                filteringMethod: z.enum(Object.values(formulaFilterMethods)),
+                checkedValues: z.array(z.string().nullable()).default([]).optional(),
+                formValues: z
+                    .object((_a = {},
+                    _a[EFormulaFilterFieldKeys.date] = z.string().nullable(),
+                    _a[EFormulaFilterFieldKeys.dateRange] = z.tuple([z.string(), z.string()]),
+                    _a[EFormulaFilterFieldKeys.numberRange] = z.tuple([
+                        z.number().nullable(),
+                        z.number().nullable(),
+                    ]),
+                    _a[EFormulaFilterFieldKeys.string] = z.string(),
+                    // todo: отказаться от использования z.string(), оставить только z.number() [BI-15912]
+                    _a[EFormulaFilterFieldKeys.lastTimeValue] = z.number().or(z.string()),
+                    _a[EFormulaFilterFieldKeys.lastTimeUnit] = z.enum(ELastTimeUnit),
+                    _a[EFormulaFilterFieldKeys.durationUnit] = z.enum(EDurationUnit),
+                    _a))
+                    .partial()
+                    .optional(),
+            });
+        },
+    },
+});
+var ExtendedFormulaFilterValueSchema = SchemaRegistry.define({
+    key: "ExtendedFormulaFilterValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.union([
+                FormulaFilterValueSchema.forVersion("17")(z),
+                z.object({ formula: FormulaSchema.forVersion("17")(z) }),
+            ]);
+        },
+    },
+});
+var DimensionProcessFilterSchema = SchemaRegistry.define({
+    key: "DimensionProcessFilter",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                value: z.union([
+                    WidgetIndicatorAggregationValueSchema.forVersion("17")(z).extend({
+                        outerAggregation: z.enum(EOuterAggregation),
+                    }),
+                    WidgetIndicatorAggregationValueSchema.forVersion("17")(z).extend({
+                        innerTemplateName: z.string().optional(),
+                    }),
+                    WidgetIndicatorTimeValueSchema.forVersion("17")(z),
+                    z.object({
+                        mode: z.literal(EWidgetIndicatorValueModes.FORMULA),
+                        formula: FormulaSchema.forVersion("17")(z).optional(),
+                    }),
+                ]),
+                dbDataType: z.string(),
+                condition: z.object({
+                    filteringMethod: z.enum(Object.values(formulaFilterMethods)),
+                    timeUnit: z.enum(EDimensionProcessFilterTimeUnit).optional(),
+                    values: z.array(z.string().nullable()),
+                }),
+            });
+        },
+    },
+});
+var SettingsFilterSchema = SchemaRegistry.define({
+    key: "SettingsFilter",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.union([
+                ExtendedFormulaFilterValueSchema.forVersion("17")(z),
+                DimensionProcessFilterSchema.forVersion("17")(z),
+            ]);
+        },
+    },
+});
+
+var ActionOnClickParameterCommonSchema = SchemaRegistry.define({
+    key: "ActionOnClickParameterCommon",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return AutoIdentifiedArrayItemSchema.forVersion("17")(z).extend({
+                name: z.string(),
+            });
+        },
+    },
+});
+var ParameterFromColumnSchema = SchemaRegistry.define({
+    key: "ParameterFromColumn",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.COLUMN),
+                tableName: z.string().nullable().default(null),
+                columnName: z.string().nullable().default(null),
+                dbDataType: z.string().optional(),
+            });
+        },
+    },
+});
+var ParameterFromVariableSchema = SchemaRegistry.define({
+    key: "ParameterFromVariable",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.VARIABLE),
+                sourceVariable: z.string().nullable().default(null),
+            });
+        },
+    },
+});
+var ParameterFromFormulaSchema = SchemaRegistry.define({
+    key: "ParameterFromFormula",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.FORMULA),
+                formula: FormulaSchema.forVersion("17")(z),
+                considerFilters: z.boolean().default(false),
+                dbDataType: z.string().optional(),
+            });
+        },
+    },
+});
+var ParameterFromEventSchema = SchemaRegistry.define({
+    key: "ParameterFromEvent",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.EVENT),
+            });
+        },
+    },
+});
+var ParameterFromStartEventSchema = SchemaRegistry.define({
+    key: "ParameterFromStartEvent",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.START_EVENT),
+            });
+        },
+    },
+});
+var ParameterFromEndEventSchema = SchemaRegistry.define({
+    key: "ParameterFromEndEvent",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.FINISH_EVENT),
+            });
+        },
+    },
+});
+var ParameterFromAggregationSchema = SchemaRegistry.define({
+    key: "ParameterFromAggregation",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.AGGREGATION),
+                formula: FormulaSchema.forVersion("17")(z),
+                considerFilters: z.boolean().default(false),
+                dbDataType: z.string().optional(),
+            });
+        },
+    },
+});
+var ParameterFromManualInputSchema = SchemaRegistry.define({
+    key: "ParameterFromManualInput",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.MANUALLY),
+                description: z.string().default(""),
+                defaultValue: FormulaSchema.forVersion("17")(z),
+                dbDataType: z.string().optional(),
+                filterByRows: z.boolean().default(false),
+                validation: FormulaSchema.forVersion("17")(z),
+                acceptEmptyValue: z.boolean().default(false),
+            });
+        },
+    },
+});
+var ParameterFromStaticListSchema = SchemaRegistry.define({
+    key: "ParameterFromStaticList",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.STATIC_LIST),
+                options: z.string().default(""),
+                defaultValue: z
+                    .union([z.string(), z.array(z.string())])
+                    .nullable()
+                    .default(null),
+                acceptEmptyValue: z.boolean().default(false),
+            });
+        },
+    },
+});
+var ParameterFromDynamicListSchema = SchemaRegistry.define({
+    key: "ParameterFromDynamicList",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.DYNAMIC_LIST),
+                options: FormulaSchema.forVersion("17")(z),
+                defaultValue: FormulaSchema.forVersion("17")(z),
+                dbDataType: z.string().optional(),
+                displayOptions: FormulaSchema.forVersion("17")(z),
+                filters: z.array(ExtendedFormulaFilterValueSchema.forVersion("17")(z)).default([]),
+                filterByRows: z.boolean().default(false),
+                considerFilters: z.boolean().default(false),
+                insertAnyValues: z.boolean().default(false),
+                validation: FormulaSchema.forVersion("17")(z),
+                acceptEmptyValue: z.boolean().default(false),
+            });
+        },
+    },
+});
+var ParameterFromDataModelSchema = SchemaRegistry.define({
+    key: "ParameterFromDataModel",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.DATA_MODEL),
+                option: z.enum(EDataModelOption).default(EDataModelOption.TABLE_LIST),
+                /**
+                 * Используется только при COLUMN_LIST. Не делаем union по option, чтобы сохранить
+                 * одновременно default для option и работоспособность внешнего discriminated union.
+                 */
+                parent: NameNullableSchema.forVersion("17")(z),
+            });
+        },
+    },
+});
+var ActionOnClickParameterSchema = SchemaRegistry.define({
+    key: "ActionOnClickParameter",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.intersection(ActionOnClickParameterCommonSchema.forVersion("17")(z), z.discriminatedUnion("inputMethod", [
+                ParameterFromColumnSchema.forVersion("17")(z),
+                ParameterFromVariableSchema.forVersion("17")(z),
+                ParameterFromFormulaSchema.forVersion("17")(z),
+                ParameterFromEventSchema.forVersion("17")(z),
+                ParameterFromStartEventSchema.forVersion("17")(z),
+                ParameterFromEndEventSchema.forVersion("17")(z),
+                ParameterFromAggregationSchema.forVersion("17")(z),
+                ParameterFromManualInputSchema.forVersion("17")(z),
+                ParameterFromStaticListSchema.forVersion("17")(z),
+                ParameterFromDynamicListSchema.forVersion("17")(z),
+                ParameterFromDataModelSchema.forVersion("17")(z),
+            ]));
+        },
+    },
+});
+var ActionCommonSchema = SchemaRegistry.define({
+    key: "ActionCommon",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return AutoIdentifiedArrayItemSchema.forVersion("17")(z).extend({
+                name: z.string(),
+            });
+        },
+    },
+});
+var ActionDrillDownSchema = SchemaRegistry.define({
+    key: "ActionDrillDown",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return ActionCommonSchema.forVersion("17")(z).extend({
+                type: z.literal(EActionTypes.DRILL_DOWN),
+                variables: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+            });
+        },
+    },
+});
+var ActionGoToURLSchema = SchemaRegistry.define({
+    key: "ActionGoToURL",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return ActionCommonSchema.forVersion("17")(z).extend({
+                type: z.literal(EActionTypes.OPEN_URL),
+                url: z.string(),
+                newWindow: z.boolean().default(true),
+                variables: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+            });
+        },
+    },
+});
+var ActivateConditionSchema = SchemaRegistry.define({
+    key: "ActivateCondition",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z
+                .discriminatedUnion("mode", [
+                z.object({
+                    mode: z.literal(EActivateConditionMode.FORMULA),
+                    formula: FormulaSchema.forVersion("17")(z),
+                }),
+                z.object({
+                    mode: z.literal(EActivateConditionMode.VARIABLE),
+                    variableName: z.string().nullable().default(null),
+                    variableValue: z.string().nullable().default(null),
+                }),
+            ])
+                .default({ mode: EActivateConditionMode.FORMULA, formula: "" });
+        },
+    },
+});
+var ActionRunScriptSchema = SchemaRegistry.define({
+    key: "ActionRunScript",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return ActionCommonSchema.forVersion("17")(z).extend({
+                type: z.literal(EActionTypes.EXECUTE_SCRIPT),
+                parameters: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+                scriptKey: z.string(),
+                autoUpdate: z.enum(EAutoUpdateMode).default(EAutoUpdateMode.THIS_WIDGET),
+                hideInactiveButton: z.boolean().default(false),
+                activateCondition: ActivateConditionSchema.forVersion("17")(z),
+                hint: z.string().default(""),
+                variables: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+                runButtonText: z.string().default(""),
+            });
+        },
+    },
+});
+var ActionUpdateVariableSchema = SchemaRegistry.define({
+    key: "ActionUpdateVariable",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return ActionCommonSchema.forVersion("17")(z).extend({
+                type: z.literal(EActionTypes.UPDATE_VARIABLE),
+                variables: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+            });
+        },
+    },
+});
+var ActionOpenInSchema = SchemaRegistry.define({
+    key: "ActionOpenIn",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.discriminatedUnion("openIn", [
+                z.object({
+                    openIn: z.literal(EViewOpenIn.DRAWER_WINDOW),
+                    alignment: z.enum(EDrawerPlacement).default(EDrawerPlacement.RIGHT),
+                    inheritFilter: z.boolean().default(true),
+                }),
+                z.object({
+                    openIn: z.literal(EViewOpenIn.PLACEHOLDER),
+                    placeholderName: z.string().optional(),
+                }),
+                z.object({
+                    openIn: z.literal(EViewOpenIn.MODAL_WINDOW),
+                    positionByClick: z.boolean().default(false),
+                    inheritFilter: z.boolean().default(true),
+                }),
+                z.object({
+                    openIn: z.literal(EViewOpenIn.WINDOW),
+                    newWindow: z.boolean().default(true),
+                    inheritFilter: z.boolean().default(true),
+                }),
+            ]);
+        },
+    },
+});
+var ActionOpenViewCommonSchema = SchemaRegistry.define({
+    key: "ActionOpenViewCommon",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return ActionCommonSchema.forVersion("17")(z).extend({
+                type: z.literal(EActionTypes.OPEN_VIEW),
+                variables: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+            });
+        },
+    },
+});
+var ActionOpenViewSchema = SchemaRegistry.define({
+    key: "ActionOpenView",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.intersection(z.discriminatedUnion("mode", [
+                ActionOpenViewCommonSchema.forVersion("17")(z).extend({
+                    mode: z.literal(EViewMode.GENERATED_BY_SCRIPT),
+                    scriptKey: z.string().optional(),
+                    parameters: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+                    displayName: z.string().default(""),
+                }),
+                ActionOpenViewCommonSchema.forVersion("17")(z).extend({
+                    mode: z.literal(EViewMode.EXISTED_VIEW),
+                    viewKey: z.string().optional(),
+                    parameters: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+                }),
+                ActionOpenViewCommonSchema.forVersion("17")(z).extend({
+                    mode: z.literal(EViewMode.EMPTY),
+                    placeholderName: z.string().optional(),
+                    openIn: z.literal(EViewOpenIn.PLACEHOLDER),
+                }),
+            ]), ActionOpenInSchema.forVersion("17")(z));
+        },
+    },
+});
+var ActionsOnClickSchema = SchemaRegistry.define({
+    key: "ActionsOnClick",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.union([
+                ActionGoToURLSchema.forVersion("17")(z),
+                ActionRunScriptSchema.forVersion("17")(z),
+                ActionUpdateVariableSchema.forVersion("17")(z),
+                ActionOpenViewSchema.forVersion("17")(z),
+                ActionDrillDownSchema.forVersion("17")(z),
+            ]);
+        },
+    },
+});
+var WidgetActionParameterCommonSchema = SchemaRegistry.define({
+    key: "WidgetActionParameterCommon",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return AutoIdentifiedArrayItemSchema.forVersion("17")(z).extend({
+                name: z.string(),
+                displayName: z.string().default(""),
+                isHidden: z.boolean().default(false),
+            });
+        },
+    },
+});
+var WidgetActionParameterSchema = SchemaRegistry.define({
+    key: "WidgetActionParameter",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.intersection(WidgetActionParameterCommonSchema.forVersion("17")(z), z.discriminatedUnion("inputMethod", [
+                ParameterFromColumnSchema.forVersion("17")(z),
+                ParameterFromVariableSchema.forVersion("17")(z),
+                ParameterFromFormulaSchema.forVersion("17")(z),
+                ParameterFromManualInputSchema.forVersion("17")(z),
+                ParameterFromStaticListSchema.forVersion("17")(z),
+                ParameterFromDynamicListSchema.forVersion("17")(z),
+                ParameterFromAggregationSchema.forVersion("17")(z),
+                ParameterFromDataModelSchema.forVersion("17")(z),
+            ]));
+        },
+    },
+});
+var WidgetActionSchema = SchemaRegistry.define({
+    key: "WidgetAction",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return ActionCommonSchema.forVersion("17")(z).extend({
+                parameters: z.array(WidgetActionParameterSchema.forVersion("17")(z)).default([]),
+                type: z.literal(EActionTypes.EXECUTE_SCRIPT),
+                scriptKey: z.string(),
+                autoUpdate: z.enum(EAutoUpdateMode).default(EAutoUpdateMode.THIS_WIDGET),
+                description: z.string().default(""),
+                hideInactiveButton: z.boolean().default(false),
+                hint: z.string().default(""),
+                activateCondition: ActivateConditionSchema.forVersion("17")(z),
+                variables: z.array(WidgetActionParameterSchema.forVersion("17")(z)).default([]),
+                runButtonText: z.string().default(""),
+            });
+        },
+    },
+});
+var ViewActionParameterSchema = SchemaRegistry.define({
+    key: "ViewActionParameter",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.intersection(AutoIdentifiedArrayItemSchema.forVersion("17")(z).extend({ name: z.string() }), z.discriminatedUnion("inputMethod", [
+                ParameterFromAggregationSchema.forVersion("17")(z),
+                ParameterFromVariableSchema.forVersion("17")(z),
+            ]));
+        },
+    },
+});
+var ViewActionSchema = SchemaRegistry.define({
+    key: "ViewAction",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return AutoIdentifiedArrayItemSchema.forVersion("17")(z).extend({
+                name: z.string(),
+                buttonType: z.enum(EActionButtonsTypes).default(EActionButtonsTypes.BASE),
+                type: z.literal(EActionTypes.EXECUTE_SCRIPT).default(EActionTypes.EXECUTE_SCRIPT),
+                parameters: z.array(ViewActionParameterSchema.forVersion("17")(z)).default([]),
+                scriptKey: KeyNullableSchema.forVersion("17")(z),
+                autoUpdate: z
+                    .union([z.literal(EAutoUpdateMode.NONE), z.literal(EAutoUpdateMode.ALL_VIEWS)])
+                    .default(EAutoUpdateMode.NONE),
+            });
+        },
+    },
+});
+var ActionSchema = SchemaRegistry.define({
+    key: "Action",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.union([
+                ActionsOnClickSchema.forVersion("17")(z),
+                WidgetActionSchema.forVersion("17")(z),
+                ViewActionSchema.forVersion("17")(z),
+            ]);
+        },
+    },
+});
+var ActionButtonSchema = SchemaRegistry.define({
+    key: "ActionButton",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return AutoIdentifiedArrayItemSchema.forVersion("17")(z).extend({
+                name: z.string(),
+                onClick: z.array(WidgetActionSchema.forVersion("17")(z)).default([]),
+                buttonType: z.enum(EActionButtonsTypes).default(EActionButtonsTypes.BASE),
+                backgroundColor: ColorSchema.forVersion("17")(z),
+                borderColor: ColorSchema.forVersion("17")(z),
+                color: ColorSchema.forVersion("17")(z),
+                hint: z.string().default(""),
+            });
+        },
+    },
+});
 
 var ESimpleDataType;
 (function (ESimpleDataType) {
@@ -1086,25 +1682,6 @@ var isFormulaFilterValue = function (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;
-    };
-}
-
 var EClickHouseBaseTypes;
 (function (EClickHouseBaseTypes) {
     // DATE
@@ -2270,7 +2847,7 @@ var ESortDirection;
  * Если к разрезу иерархии применяется INCLUDE-фильтр с несколькими значениями - выбираем данный разрез
  */
 function selectDimensionFromHierarchy(hierarchy, filters) {
-    var hierarchyDimensions = hierarchy.hierarchyDimensions; hierarchy.displayCondition;
+    var hierarchyDimensions = hierarchy.hierarchyDimensions;
     var _loop_1 = function (i) {
         var dimension = hierarchyDimensions[i];
         // todo: widgets - возможно, стоит использовать Map фильтров для быстрого поиска
@@ -2583,6 +3160,39 @@ var replaceFiltersBySelection = function (filters, selection) {
     }, []);
 };
 
+var colors = [
+    "#222F3E",
+    "#00D2D3",
+    "#5F27CD",
+    "#FECA57",
+    "#078936",
+    "#E51320",
+    "#96AABF",
+    "#1C55E7",
+    "#341F97",
+    "#FFDD59",
+    "#D82C46",
+    "#0BE881",
+    "#0ABDE3",
+    "#FF9F43",
+    "#EC41D4",
+    "#117F8E",
+    "#B9B9B9",
+    "#505BF1",
+    "#64FFB6",
+    "#485460",
+    "#FFD32A",
+    "#C74E1A",
+    "#6E70A6",
+    "#3C40C6",
+    "#48DBFB",
+    "#486179",
+    "#FF9FF3",
+    "#1DD1A1",
+    "#BCC8D4",
+    "#BA46AA",
+];
+
 var EColorMode;
 (function (EColorMode) {
     /** Окрашивание отключено */
@@ -2602,6 +3212,7 @@ var EColorMode;
     /** Задать цвет конкретным значениям общего разреза. Режим используется только для настроек правила отображения */
     EColorMode["BY_DIMENSION"] = "BY_DIMENSION";
 })(EColorMode || (EColorMode = {}));
+
 var getRuleColor = function (ruleFormula, globalContext) {
     var _a, _b;
     var link = parseIndicatorLink(ruleFormula);
@@ -2623,38 +3234,6 @@ var isValidColor = function (color, globalContext) {
     }
     return true;
 };
-var colors = [
-    "#222F3E",
-    "#00D2D3",
-    "#5F27CD",
-    "#FECA57",
-    "#078936",
-    "#E51320",
-    "#96AABF",
-    "#1C55E7",
-    "#341F97",
-    "#FFDD59",
-    "#D82C46",
-    "#0BE881",
-    "#0ABDE3",
-    "#FF9F43",
-    "#EC41D4",
-    "#117F8E",
-    "#B9B9B9",
-    "#505BF1",
-    "#64FFB6",
-    "#485460",
-    "#FFD32A",
-    "#C74E1A",
-    "#6E70A6",
-    "#3C40C6",
-    "#48DBFB",
-    "#486179",
-    "#FF9FF3",
-    "#1DD1A1",
-    "#BCC8D4",
-    "#BA46AA",
-];
 /**
  * Получить цвет по индексу элемента
  * @param index - индекс элемента, которому требуется цвет
@@ -2669,22 +3248,222 @@ var getColorByIndex = function (index) {
     return color;
 };
 
-var WidgetPresetSettingsSchema = function (z) {
-    return BaseWidgetSettingsSchema(z)
-        .pick({
-        filterMode: true,
-        ignoreFilters: true,
-        stateName: true,
-        titleColor: true,
-        titleSize: true,
-        titleWeight: true,
-        paddings: true,
-    })
-        .extend({
-        textSize: z.number().default(12),
+var ColorBaseSchema = SchemaRegistry.define({
+    key: "ColorBase",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EColorMode.BASE),
+                value: z.string(),
+            });
+        },
+    },
+});
+var ColorRuleSchema = SchemaRegistry.define({
+    key: "ColorRule",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EColorMode.RULE),
+                formula: FormulaSchema.forVersion("17")(z),
+            });
+        },
+    },
+});
+var ColorAutoSchema = SchemaRegistry.define({
+    key: "ColorAuto",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EColorMode.AUTO),
+            });
+        },
+    },
+});
+var ColorDisabledSchema = SchemaRegistry.define({
+    key: "ColorDisabled",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EColorMode.DISABLED),
+            });
+        },
+    },
+});
+var ColorGradientSchema = SchemaRegistry.define({
+    key: "ColorGradient",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EColorMode.GRADIENT),
+                startValue: z.string(),
+                endValue: z.string(),
+                classCount: z.number().min(3).max(10).nullish(),
+            });
+        },
+    },
+});
+var ColorFormulaSchema = SchemaRegistry.define({
+    key: "ColorFormula",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EColorMode.FORMULA),
+                formula: FormulaSchema.forVersion("17")(z),
+            });
+        },
+    },
+});
+var ColorValuesSchema = SchemaRegistry.define({
+    key: "ColorValues",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EColorMode.VALUES),
+                items: z
+                    .array(z.object({
+                    value: z.string(),
+                    color: z.union([
+                        ColorBaseSchema.forVersion("17")(z),
+                        ColorRuleSchema.forVersion("17")(z),
+                    ]),
+                }))
+                    .default([]),
+            });
+        },
+    },
+});
+var ColorByDimensionSchema = SchemaRegistry.define({
+    key: "ColorByDimension",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EColorMode.BY_DIMENSION),
+                /** Имя разреза из области видимости правила отображения */
+                dimensionName: z.string(),
+                items: z
+                    .array(z.object({
+                    value: z.string(),
+                    color: z.union([
+                        ColorBaseSchema.forVersion("17")(z),
+                        ColorRuleSchema.forVersion("17")(z),
+                    ]),
+                }))
+                    .default([]),
+            });
+        },
+    },
+});
+var ColoredValueSchema = SchemaRegistry.define({
+    key: "ColoredValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                value: z.string(),
+                color: z.union([ColorBaseSchema.forVersion("17")(z), ColorRuleSchema.forVersion("17")(z)]),
+            });
+        },
+    },
+});
+var ColorSchema = SchemaRegistry.define({
+    key: "Color",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z
+                .discriminatedUnion("mode", [
+                ColorAutoSchema.forVersion("17")(z),
+                ColorDisabledSchema.forVersion("17")(z),
+                ColorBaseSchema.forVersion("17")(z),
+                ColorRuleSchema.forVersion("17")(z),
+                ColorGradientSchema.forVersion("17")(z),
+                ColorFormulaSchema.forVersion("17")(z),
+                ColorValuesSchema.forVersion("17")(z),
+                ColorByDimensionSchema.forVersion("17")(z),
+            ])
+                .default({ mode: EColorMode.AUTO });
+        },
+    },
+});
+
+var hexToRgb = function (hex) {
+    if (hex.length === 0) {
+        return;
+    }
+    var rgbTuple = [0, 0, 0];
+    var matchArray = hex
+        .replace(/^#?([a-f\d])([a-f\d])([a-f\d])$/i, function (m, r, g, b) { return "#".concat(r).concat(r).concat(g).concat(g).concat(b).concat(b); })
+        .substring(1)
+        .match(/.{2}/g);
+    matchArray === null || matchArray === void 0 ? void 0 : matchArray.forEach(function (value, index) {
+        if (index > 2) {
+            return undefined;
+        }
+        rgbTuple[index] = parseInt(value, 16);
     });
+    return rgbTuple;
 };
 
+var rgbToHex = function (rgb) {
+    return "#".concat(rgb.map(function (x) { return x.toString(16).padStart(2, "0"); }).join(""));
+};
+
+var lerp = function (a, b, t) { return a + (b - a) * t; };
+/**
+ * Вычисляет промежуточный hex цвет между двумя цветами путем линейной интерполяции
+ * в RGB пространстве
+ *
+ * @param startHex цвет начала
+ * @param endHex цвет конца
+ * @param position позиция на градиенте от 0 до 1
+ */
+var interpolateHexColor = function (startHex, endHex, position) {
+    var clampedPosition = clamp(position, 0, 1);
+    var startRgb = hexToRgb(startHex);
+    var endRgb = hexToRgb(endHex);
+    if (!startRgb || !endRgb) {
+        throw new Error("\u041D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0435 \u0446\u0432\u0435\u0442\u0430: start: ".concat(startHex, ", end: ").concat(endHex));
+    }
+    var interpolated = [
+        Math.round(lerp(startRgb[0], endRgb[0], clampedPosition)),
+        Math.round(lerp(startRgb[1], endRgb[1], clampedPosition)),
+        Math.round(lerp(startRgb[2], endRgb[2], clampedPosition)),
+    ];
+    return rgbToHex(interpolated);
+};
+
+/** @deprecated временно используется для миграции */
+var WidgetPresetSettingsSchema = SchemaRegistry.define({
+    key: "WidgetPresetSettings",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return BaseWidgetSettingsSchema.forVersion("17")(z)
+                .pick({
+                filterMode: true,
+                ignoreFilters: true,
+                stateName: true,
+                titleColor: true,
+                titleSize: true,
+                titleWeight: true,
+                paddings: true,
+            })
+                .extend({
+                textSize: z.number().default(12),
+            });
+        },
+    },
+});
+
 /**
  * Привязывает мета-информацию о теме к Zod-схеме
  *
@@ -2708,79 +3487,4 @@ var themed = function (scheme, selectThemeValue) {
     return scheme.meta((_a = {}, _a[ESettingsSchemaMetaKey.themeValue] = selectThemeValue, _a));
 };
 
-var ColorBaseSchema = function (z) {
-    return z.object({
-        mode: z.literal(EColorMode.BASE),
-        value: z.string(),
-    });
-};
-var ColorRuleSchema = function (z) {
-    return z.object({
-        mode: z.literal(EColorMode.RULE),
-        formula: FormulaSchema(z),
-    });
-};
-var ColorAutoSchema = function (z) {
-    return z.object({
-        mode: z.literal(EColorMode.AUTO),
-    });
-};
-var ColorDisabledSchema = function (z) {
-    return z.object({
-        mode: z.literal(EColorMode.DISABLED),
-    });
-};
-var ColorGradientSchema = function (z) {
-    return z.object({
-        mode: z.literal(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(EColorMode.FORMULA),
-        formula: FormulaSchema(z),
-    });
-};
-var ColorValuesSchema = function (z) {
-    return z.object({
-        mode: z.literal(EColorMode.VALUES),
-        items: z
-            .array(z.object({ value: z.string(), color: z.union([ColorBaseSchema(z), ColorRuleSchema(z)]) }))
-            .default([]),
-    });
-};
-var ColorByDimensionSchema = function (z) {
-    return z.object({
-        mode: z.literal(EColorMode.BY_DIMENSION),
-        /** Имя разреза из области видимости правила отображения */
-        dimensionName: z.string(),
-        items: z
-            .array(z.object({ value: z.string(), color: z.union([ColorBaseSchema(z), ColorRuleSchema(z)]) }))
-            .default([]),
-    });
-};
-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),
-    ])
-        .default({ mode: EColorMode.AUTO });
-};
-
-export { ActionButtonSchema, ActionDrillDownSchema, ActionGoToURLSchema, ActionOnClickParameterSchema, ActionOpenInSchema, ActionOpenViewSchema, ActionRunScriptSchema, ActionSchema, ActionUpdateVariableSchema, ActionsOnClickSchema, AutoIdentifiedArrayItemSchema, BaseWidgetSettingsSchema, ColorAutoSchema, ColorBaseSchema, ColorByDimensionSchema, ColorDisabledSchema, ColorFormulaSchema, ColorGradientSchema, ColorRuleSchema, ColorSchema, ColorValuesSchema, ColoredValueSchema, ColumnIndicatorValueSchema, DimensionProcessFilterSchema, DimensionValueSchema, DisplayConditionSchema, EActionButtonsTypes, EActionTypes, EActivateConditionMode, EAutoUpdateMode, ECalculatorFilterMethods, EClickHouseBaseTypes, EColorMode, EControlType, ECustomSelectTemplates, EDataModelOption, EDimensionAggregationTemplateName, EDimensionProcessFilterTimeUnit, EDimensionTemplateNames, EDisplayConditionMode, EDrawerPlacement, EDurationTemplateName, EDurationUnit, EEventAppearances, EEventMeasureTemplateNames, EFontWeight, EFormatOrFormattingMode, EFormulaFilterFieldKeys, EHeightMode, EIndicatorType, ELastTimeUnit, EMarkdownDisplayMode, EMeasureAggregationTemplateName, EMeasureInnerTemplateNames, EMeasureTemplateNames, EOuterAggregation, EProcessFilterNames, ESelectOptionTypes, ESettingsSchemaMetaKey, ESimpleDataType, ESimpleInputType, ESortDirection, ESortingValueModes, ESystemRecordKey, ETransitionMeasureTemplateNames, EUnitMode, EViewMode, EViewOpenIn, EWidgetActionInputMethod, EWidgetFilterMode, EWidgetIndicatorType, EWidgetIndicatorValueModes, ExtendedFormulaFilterValueSchema, FormatSchema, FormattingSchema, FormulaFilterValueSchema, FormulaNullableSchema, FormulaSchema, KeyNullableSchema, MarkdownMeasureSchema, MeasureValueSchema, NameNullableSchema, OuterAggregation, ParameterFromAggregationSchema, ParameterFromColumnSchema, ParameterFromDataModelSchema, ParameterFromDynamicListSchema, ParameterFromEndEventSchema, ParameterFromEventSchema, ParameterFromFormulaSchema, ParameterFromManualInputSchema, ParameterFromStartEventSchema, ParameterFromStaticListSchema, ParameterFromVariableSchema, ProcessIndicatorSchema, ProcessIndicatorValueSchema, RangeSchema, SettingsFilterSchema, SortDirectionSchema, SortOrderSchema, ViewActionParameterSchema, ViewActionSchema, WidgetActionParameterSchema, WidgetActionSchema, WidgetColumnIndicatorSchema, WidgetDimensionHierarchySchema, WidgetDimensionInHierarchySchema, WidgetDimensionSchema, WidgetIndicatorAggregationValueSchema, WidgetIndicatorConversionValueSchema, WidgetIndicatorDurationValueSchema, WidgetIndicatorFormulaValueSchema, WidgetIndicatorSchema, WidgetIndicatorTemplateValueSchema, WidgetIndicatorTimeValueSchema, WidgetMeasureAggregationValueSchema, WidgetMeasureSchema, WidgetPresetSettingsSchema, WidgetSortingIndicatorSchema, WidgetSortingValueSchema, apiVersion, apiVersions, applyIndexToArrayFormula, availableFormatsBySimpleType, bindContentWithIndicator, bindContentsWithIndicators, checkDisplayCondition, clearMultiLineComments, clearSingleLineComments, colors, conversionTemplate, convertFiltersToFormula, convertToFormulasChain, countExecutionsTemplate, createEscaper, createAggregationTemplate as createMeasureAggregationTemplate, curlyBracketsContentPattern, dashboardLinkRegExp, defaultActionsConfig, dimensionAggregationTemplates, dimensionTemplateFormulas, displayConditionTemplate, doubleQuoteContentPattern, durationTemplates, escapeCurlyBracketLinkName, escapeDoubleQuoteLinkName, eventMeasureTemplateFormulas, fillTemplateSql, formulaFilterMethods, generateColumnFormula, getColorByIndex, getDefaultSortOrders, getDimensionFormula, getDisplayConditionFormula, getEventMeasureFormula, getMeasureFormula, getProcessDimensionValueFormula, getRuleColor, getTransitionMeasureFormula, inheritDisplayConditionFromHierarchy, isDimensionProcessFilter, isDimensionsHierarchy, isFormulaFilterValue, isValidColor, mapDimensionsToInputs, mapEventMeasuresToInputs, mapFormulaFilterToCalculatorInput, mapFormulaFiltersToInputs, mapMeasuresToInputs, mapSettingsFiltersToInputs, mapSortingToInputs, mapTransitionMeasuresToInputs, measureInnerTemplateFormulas, measureTemplateFormulas, parseClickHouseType, parseIndicatorLink, prepareConversionParams, prepareDimensionAggregationParams, prepareDurationParams, prepareFormulaForSql, prepareMeasureAggregationParams, prepareSortOrders, prepareTimeParams, prepareValuesForSql, replaceDisplayCondition, replaceFiltersBySelection, replaceHierarchiesWithDimensions, selectDimensionFromHierarchy, themed, timeTemplates, transitionMeasureTemplateFormulas, unescapeSpecialCharacters, updateDefaultModeSelection, updateSingleModeSelection, workspaceLinkRegExp };
+export { ActionButtonSchema, ActionDrillDownSchema, ActionGoToURLSchema, ActionOnClickParameterSchema, ActionOpenInSchema, ActionOpenViewSchema, ActionRunScriptSchema, ActionSchema, ActionUpdateVariableSchema, ActionsOnClickSchema, AutoIdentifiedArrayItemSchema, BaseWidgetSettingsSchema, ColorAutoSchema, ColorBaseSchema, ColorByDimensionSchema, ColorDisabledSchema, ColorFormulaSchema, ColorGradientSchema, ColorRuleSchema, ColorSchema, ColorValuesSchema, ColoredValueSchema, ColumnIndicatorValueSchema, DimensionProcessFilterSchema, DimensionValueSchema, DisplayConditionSchema, EActionButtonsTypes, EActionTypes, EActivateConditionMode, EAutoUpdateMode, ECalculatorFilterMethods, EClickHouseBaseTypes, EColorMode, EControlType, ECustomSelectTemplates, EDataModelOption, EDimensionAggregationTemplateName, EDimensionProcessFilterTimeUnit, EDimensionTemplateNames, EDisplayConditionMode, EDrawerPlacement, EDurationTemplateName, EDurationUnit, EEventAppearances, EEventMeasureTemplateNames, EFontWeight, EFormatOrFormattingMode, EFormulaFilterFieldKeys, EHeightMode, EIndicatorType, ELastTimeUnit, EMarkdownDisplayMode, EMeasureAggregationTemplateName, EMeasureInnerTemplateNames, EMeasureTemplateNames, EOuterAggregation, EProcessFilterNames, ESelectOptionTypes, ESettingsSchemaMetaKey, ESimpleDataType, ESimpleInputType, ESortDirection, ESortingValueModes, ESystemRecordKey, ETransitionMeasureTemplateNames, EUnitMode, EViewMode, EViewOpenIn, EWidgetActionInputMethod, EWidgetFilterMode, EWidgetIndicatorType, EWidgetIndicatorValueModes, ExtendedFormulaFilterValueSchema, FormatSchema, FormattingSchema, FormulaFilterValueSchema, FormulaNullableSchema, FormulaSchema, KeyNullableSchema, MarkdownMeasureSchema, MeasureValueSchema, NameNullableSchema, OuterAggregation, ParameterFromAggregationSchema, ParameterFromColumnSchema, ParameterFromDataModelSchema, ParameterFromDynamicListSchema, ParameterFromEndEventSchema, ParameterFromEventSchema, ParameterFromFormulaSchema, ParameterFromManualInputSchema, ParameterFromStartEventSchema, ParameterFromStaticListSchema, ParameterFromVariableSchema, ProcessIndicatorSchema, ProcessIndicatorValueSchema, RangeSchema, SchemaRegistryReader, SettingsFilterSchema, SortDirectionSchema, SortOrderSchema, VersionedSchemaFactory, ViewActionParameterSchema, ViewActionSchema, WidgetActionParameterSchema, WidgetActionSchema, WidgetColumnIndicatorSchema, WidgetDimensionHierarchySchema, WidgetDimensionInHierarchySchema, WidgetDimensionSchema, WidgetIndicatorAggregationValueSchema, WidgetIndicatorConversionValueSchema, WidgetIndicatorDurationValueSchema, WidgetIndicatorFormulaValueSchema, WidgetIndicatorSchema, WidgetIndicatorTemplateValueSchema, WidgetIndicatorTimeValueSchema, WidgetMeasureAggregationValueSchema, WidgetMeasureSchema, WidgetPresetSettingsSchema, WidgetSortingIndicatorSchema, WidgetSortingValueSchema, apiVersion, apiVersions, applyIndexToArrayFormula, availableFormatsBySimpleType, bindContentWithIndicator, bindContentsWithIndicators, checkDisplayCondition, clearMultiLineComments, clearSingleLineComments, colors, conversionTemplate, convertFiltersToFormula, convertToFormulasChain, countExecutionsTemplate, createEscaper, createAggregationTemplate as createMeasureAggregationTemplate, curlyBracketsContentPattern, dashboardLinkRegExp, defaultActionsConfig, dimensionAggregationTemplates, dimensionTemplateFormulas, displayConditionTemplate, doubleQuoteContentPattern, durationTemplates, escapeCurlyBracketLinkName, escapeDoubleQuoteLinkName, eventMeasureTemplateFormulas, fillTemplateSql, formulaFilterMethods, generateColumnFormula, getColorByIndex, getDefaultSortOrders, getDimensionFormula, getDisplayConditionFormula, getEventMeasureFormula, getMeasureFormula, getProcessDimensionValueFormula, getRuleColor, getTransitionMeasureFormula, hexToRgb, inheritDisplayConditionFromHierarchy, interpolateHexColor, isDimensionProcessFilter, isDimensionsHierarchy, isFormulaFilterValue, isValidColor, mapDimensionsToInputs, mapEventMeasuresToInputs, mapFormulaFilterToCalculatorInput, mapFormulaFiltersToInputs, mapMeasuresToInputs, mapSettingsFiltersToInputs, mapSortingToInputs, mapTransitionMeasuresToInputs, measureInnerTemplateFormulas, measureTemplateFormulas, parseClickHouseType, parseIndicatorLink, prepareConversionParams, prepareDimensionAggregationParams, prepareDurationParams, prepareFormulaForSql, prepareMeasureAggregationParams, prepareSortOrders, prepareTimeParams, prepareValuesForSql, replaceDisplayCondition, replaceFiltersBySelection, replaceHierarchiesWithDimensions, selectDimensionFromHierarchy, themed, timeTemplates, transitionMeasureTemplateFormulas, unescapeSpecialCharacters, updateDefaultModeSelection, updateSingleModeSelection, workspaceLinkRegExp };