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

package/dist/index.js

@@ -32,6 +32,7 @@ var apiVersions = [
     "16.2", // Для версии системы 250709
     "17", // 2508
     "18", // 2601
+    "19", // 2602
 ];
 /**
  * Актуальная версия settings, с которой работает система.
@@ -102,46 +103,6 @@ exports.EActionButtonsTypes = void 0;
     EActionButtonsTypes["SECONDARY"] = "primary-outlined";
 })(exports.EActionButtonsTypes || (exports.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(exports.EFontWeight).default(exports.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(exports.EWidgetFilterMode).default(exports.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.
 
@@ -158,6 +119,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) {
@@ -211,6 +186,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;
@@ -220,6 +205,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(exports.EFontWeight).default(exports.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(exports.EWidgetFilterMode).default(exports.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 }); },
+        };
+    },
+});
+
 exports.EWidgetIndicatorType = void 0;
 (function (EWidgetIndicatorType) {
     EWidgetIndicatorType["MEASURE"] = "MEASURE";
@@ -359,35 +555,53 @@ exports.EHeightMode = void 0;
     EHeightMode["PERCENT"] = "PERCENT";
 })(exports.EHeightMode || (exports.EHeightMode = {}));
 
-var SortDirectionSchema = function (z) {
-    return z.union([z.literal(exports.ESortDirection.ascend), z.literal(exports.ESortDirection.descend)]);
-};
-var 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(exports.ESortingValueModes.FORMULA),
-            formula: FormulaSchema(z),
-            dbDataType: z.string().optional(),
-        }),
-        z.object({
-            mode: z.literal(exports.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(exports.ESortDirection.ascend), z.literal(exports.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(exports.ESortingValueModes.FORMULA),
+                    formula: FormulaSchema.forVersion("17")(z),
+                    dbDataType: z.string().optional(),
+                }),
+                z.object({
+                    mode: z.literal(exports.ESortingValueModes.IN_WIDGET),
+                    group: z.string(),
+                    index: z.number(),
+                }),
+            ]);
+        },
+    },
+});
 
 /** Ключи мета-данных внутри схем настроек */
 exports.ESettingsSchemaMetaKey = void 0;
@@ -399,35 +613,59 @@ exports.ESettingsSchemaMetaKey = void 0;
 })(exports.ESettingsSchemaMetaKey || (exports.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(exports.EDisplayConditionMode.DISABLED),
-        }),
-        z.object({
-            mode: z.literal(exports.EDisplayConditionMode.FORMULA),
-            formula: FormulaSchema(z),
-        }),
-        z.object({
-            mode: z.literal(exports.EDisplayConditionMode.VARIABLE),
-            variableName: NameNullableSchema(z),
-            variableValue: z.string().nullable().default(null),
-        }),
-    ])
-        .default({ mode: exports.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(exports.EDisplayConditionMode.DISABLED),
+                }),
+                z.object({
+                    mode: z.literal(exports.EDisplayConditionMode.FORMULA),
+                    formula: FormulaSchema.forVersion("17")(z),
+                }),
+                z.object({
+                    mode: z.literal(exports.EDisplayConditionMode.VARIABLE),
+                    variableName: NameNullableSchema.forVersion("17")(z),
+                    variableValue: z.string().nullable().default(null),
+                }),
+            ])
+                .default({ mode: exports.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 при расширении лучше положить на более общий уровень.
@@ -438,571 +676,929 @@ var EEntity;
 })(EEntity || (EEntity = {}));
 var formulaMeta = Object.freeze((_a$7 = {}, _a$7[exports.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(exports.EFormatOrFormattingMode.BASE),
-            value: z.enum(biFormatting.EFormatTypes).default(biFormatting.EFormatTypes.STRING).optional(),
-        }),
-        z.object({
-            mode: z.literal(exports.EFormatOrFormattingMode.TEMPLATE),
-            value: z.string().default("").optional(),
-        }),
-    ])
-        .default({ mode: exports.EFormatOrFormattingMode.BASE, value: biFormatting.EFormatTypes.STRING });
-};
-var FormattingSchema = function (z) {
-    return z
-        .discriminatedUnion("mode", [
-        z.object({
-            mode: z.literal(exports.EFormatOrFormattingMode.BASE),
-            value: z.enum(biFormatting.EFormattingPresets).default(biFormatting.EFormattingPresets.AUTO),
-        }),
-        z.object({
-            mode: z.literal(exports.EFormatOrFormattingMode.TEMPLATE),
-            value: z.string().default(""),
-        }),
-    ])
-        .default({ mode: exports.EFormatOrFormattingMode.BASE, value: biFormatting.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(exports.EWidgetIndicatorValueModes.FORMULA),
-        formula: FormulaSchema(z).optional(),
-    });
-};
-var WidgetIndicatorTemplateValueSchema = function (z) {
-    return z.object({
-        mode: z.literal(exports.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(exports.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(exports.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(exports.EOuterAggregation) });
-};
-var WidgetIndicatorTimeValueSchema = function (z) {
-    return z.object({
-        templateName: z.string(),
-        mode: z.union([
-            z.literal(exports.EWidgetIndicatorValueModes.START_TIME),
-            z.literal(exports.EWidgetIndicatorValueModes.END_TIME),
-        ]),
-        processKey: 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(exports.EFormatOrFormattingMode.BASE),
+                    value: z.enum(biFormatting.EFormatTypes).default(biFormatting.EFormatTypes.STRING).optional(),
+                }),
+                z.object({
+                    mode: z.literal(exports.EFormatOrFormattingMode.TEMPLATE),
+                    value: z.string().default("").optional(),
+                }),
+            ])
+                .default({ mode: exports.EFormatOrFormattingMode.BASE, value: biFormatting.EFormatTypes.STRING });
+        },
+    },
+});
+var FormattingSchema = SchemaRegistry.define({
+    key: "Formatting",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z
+                .discriminatedUnion("mode", [
+                z.object({
+                    mode: z.literal(exports.EFormatOrFormattingMode.BASE),
+                    value: z.enum(biFormatting.EFormattingPresets).default(biFormatting.EFormattingPresets.AUTO),
+                }),
+                z.object({
+                    mode: z.literal(exports.EFormatOrFormattingMode.TEMPLATE),
+                    value: z.string().default(""),
+                }),
+            ])
+                .default({ mode: exports.EFormatOrFormattingMode.BASE, value: biFormatting.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(exports.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(exports.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(exports.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(exports.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(exports.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(exports.EWidgetIndicatorValueModes.DURATION),
-        templateName: z.string(),
-        startEventAppearances: z.enum(exports.EEventAppearances),
-        endEventAppearances: z.enum(exports.EEventAppearances),
-    });
-};
-var WidgetMeasureSchema = function (z) {
-    return WidgetColumnIndicatorSchema(z).extend({
-        value: z
-            .discriminatedUnion("mode", [
-            MeasureValueSchema(z),
-            WidgetMeasureAggregationValueSchema(z),
-            WidgetIndicatorConversionValueSchema(z),
-            WidgetIndicatorDurationValueSchema(z),
-        ])
-            .optional(),
-    });
-};
-var MarkdownMeasureSchema = function (z) {
-    return WidgetMeasureSchema(z).extend({
-        displaySign: z.enum(exports.EMarkdownDisplayMode).default(exports.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(exports.EWidgetIndicatorValueModes.FORMULA),
-            formula: FormulaSchema(z),
-        }),
-        z.object({
-            mode: z.literal(exports.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(biFormatting.EFormatTypes), z.string()]).optional(),
-        filteringMethod: z.enum(Object.values(formulaFilterMethods)),
-        checkedValues: z.array(z.string().nullable()).optional(),
-        formValues: z
-            .object((_a = {},
-            _a[exports.EFormulaFilterFieldKeys.date] = z.string().nullable(),
-            _a[exports.EFormulaFilterFieldKeys.dateRange] = z.tuple([z.string(), z.string()]),
-            _a[exports.EFormulaFilterFieldKeys.numberRange] = z.tuple([
-                z.number().nullable(),
-                z.number().nullable(),
-            ]),
-            _a[exports.EFormulaFilterFieldKeys.string] = z.string(),
-            // todo: отказаться от использования z.string(), оставить только z.number() [BI-15912]
-            _a[exports.EFormulaFilterFieldKeys.lastTimeValue] = z.number().or(z.string()),
-            _a[exports.EFormulaFilterFieldKeys.lastTimeUnit] = z.enum(exports.ELastTimeUnit),
-            _a[exports.EFormulaFilterFieldKeys.durationUnit] = z.enum(exports.EDurationUnit),
-            _a))
-            .partial()
-            .optional(),
-    });
-};
-var ExtendedFormulaFilterValueSchema = function (z) {
-    return z.union([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(exports.EOuterAggregation),
-            }),
-            WidgetIndicatorAggregationValueSchema(z).extend({
-                innerTemplateName: z.string().optional(),
-            }),
-            WidgetIndicatorTimeValueSchema(z),
-            z.object({
-                mode: z.literal(exports.EWidgetIndicatorValueModes.FORMULA),
-                formula: z.string().optional(),
-            }),
-        ]),
-        dbDataType: z.string(),
-        condition: z.object({
-            filteringMethod: z.enum(Object.values(formulaFilterMethods)),
-            timeUnit: z.enum(exports.EDimensionProcessFilterTimeUnit).optional(),
-            values: z.array(z.string().nullable()),
-        }),
-    });
-};
-var SettingsFilterSchema = function (z) {
-    return z.union([ExtendedFormulaFilterValueSchema(z), DimensionProcessFilterSchema(z)]);
-};
+            });
+        },
+    },
+});
+var WidgetIndicatorTimeValueSchema = SchemaRegistry.define({
+    key: "WidgetIndicatorTimeValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                templateName: z.string(),
+                mode: z.union([
+                    z.literal(exports.EWidgetIndicatorValueModes.START_TIME),
+                    z.literal(exports.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(exports.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(exports.EWidgetIndicatorValueModes.DURATION),
+                templateName: z.string(),
+                startEventAppearances: z.enum(exports.EEventAppearances),
+                endEventAppearances: z.enum(exports.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(exports.EMarkdownDisplayMode).default(exports.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(exports.EWidgetIndicatorValueModes.FORMULA),
+                    formula: FormulaSchema.forVersion("17")(z),
+                }),
+                z.object({
+                    mode: z.literal(exports.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(exports.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(exports.EWidgetActionInputMethod.VARIABLE),
-        sourceVariable: z.string().nullable().default(null),
-    });
-};
-var ParameterFromFormulaSchema = function (z) {
-    return z.object({
-        inputMethod: z.literal(exports.EWidgetActionInputMethod.FORMULA),
-        formula: FormulaSchema(z),
-        considerFilters: z.boolean().default(false),
-        dbDataType: z.string().optional(),
-    });
-};
-var ParameterFromEventSchema = function (z) {
-    return z.object({
-        inputMethod: z.literal(exports.EWidgetActionInputMethod.EVENT),
-    });
-};
-var ParameterFromStartEventSchema = function (z) {
-    return z.object({
-        inputMethod: z.literal(exports.EWidgetActionInputMethod.START_EVENT),
-    });
-};
-var ParameterFromEndEventSchema = function (z) {
-    return z.object({
-        inputMethod: z.literal(exports.EWidgetActionInputMethod.FINISH_EVENT),
-    });
-};
-var ParameterFromAggregationSchema = function (z) {
-    return z.object({
-        inputMethod: z.literal(exports.EWidgetActionInputMethod.AGGREGATION),
-        formula: FormulaSchema(z),
-        considerFilters: z.boolean().default(false),
-        dbDataType: z.string().optional(),
-    });
-};
-var ParameterFromManualInputSchema = function (z) {
-    return z.object({
-        inputMethod: z.literal(exports.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(exports.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(exports.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(exports.EWidgetActionInputMethod.DATA_MODEL),
-        option: z.enum(exports.EDataModelOption).default(exports.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(exports.EActionTypes.DRILL_DOWN),
-        variables: z.array(ActionOnClickParameterSchema(z)).default([]),
-    });
-};
-var ActionGoToURLSchema = function (z) {
-    return ActionCommonSchema(z).extend({
-        type: z.literal(exports.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(exports.EActivateConditionMode.FORMULA),
-            formula: FormulaSchema(z),
-        }),
-        z.object({
-            mode: z.literal(exports.EActivateConditionMode.VARIABLE),
-            variableName: z.string().nullable().default(null),
-            variableValue: z.string().nullable().default(null),
-        }),
-    ])
-        .default({ mode: exports.EActivateConditionMode.FORMULA, formula: "" });
-};
-var ActionRunScriptSchema = function (z) {
-    return ActionCommonSchema(z).extend({
-        type: z.literal(exports.EActionTypes.EXECUTE_SCRIPT),
-        parameters: z.array(ActionOnClickParameterSchema(z)).default([]),
-        scriptKey: z.string(),
-        autoUpdate: z.enum(exports.EAutoUpdateMode).default(exports.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(exports.EActionTypes.UPDATE_VARIABLE),
-        variables: z.array(ActionOnClickParameterSchema(z)).default([]),
-    });
-};
-var ActionOpenInSchema = function (z) {
-    return z.discriminatedUnion("openIn", [
-        z.object({
-            openIn: z.literal(exports.EViewOpenIn.DRAWER_WINDOW),
-            alignment: z.enum(exports.EDrawerPlacement).default(exports.EDrawerPlacement.RIGHT),
-            inheritFilter: z.boolean().default(true),
-        }),
-        z.object({
-            openIn: z.literal(exports.EViewOpenIn.PLACEHOLDER),
-            placeholderName: z.string().optional(),
-        }),
-        z.object({
-            openIn: z.literal(exports.EViewOpenIn.MODAL_WINDOW),
-            positionByClick: z.boolean().default(false),
-            inheritFilter: z.boolean().default(true),
-        }),
-        z.object({
-            openIn: z.literal(exports.EViewOpenIn.WINDOW),
-            newWindow: z.boolean().default(true),
-            inheritFilter: z.boolean().default(true),
-        }),
-    ]);
-};
-var ActionOpenViewCommonSchema = function (z) {
-    return ActionCommonSchema(z).extend({
-        type: z.literal(exports.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(exports.EViewMode.GENERATED_BY_SCRIPT),
-            scriptKey: z.string().optional(),
-            parameters: z.array(ActionOnClickParameterSchema(z)).default([]),
-            displayName: z.string().default(""),
-        }),
-        ActionOpenViewCommonSchema(z).extend({
-            mode: z.literal(exports.EViewMode.EXISTED_VIEW),
-            viewKey: z.string().optional(),
-            parameters: z.array(ActionOnClickParameterSchema(z)).default([]),
-        }),
-        ActionOpenViewCommonSchema(z).extend({
-            mode: z.literal(exports.EViewMode.EMPTY),
-            placeholderName: z.string().optional(),
-            openIn: z.literal(exports.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(exports.EActionTypes.EXECUTE_SCRIPT),
-        scriptKey: z.string(),
-        autoUpdate: z.enum(exports.EAutoUpdateMode).default(exports.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(exports.EActionButtonsTypes).default(exports.EActionButtonsTypes.BASE),
-        type: z.literal(exports.EActionTypes.EXECUTE_SCRIPT).default(exports.EActionTypes.EXECUTE_SCRIPT),
-        parameters: z.array(ViewActionParameterSchema(z)).default([]),
-        scriptKey: KeyNullableSchema(z),
-        autoUpdate: z
-            .union([z.literal(exports.EAutoUpdateMode.NONE), z.literal(exports.EAutoUpdateMode.ALL_VIEWS)])
-            .default(exports.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(exports.EActionButtonsTypes).default(exports.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(biFormatting.EFormatTypes), z.string()]).optional(),
+                filteringMethod: z.enum(Object.values(formulaFilterMethods)),
+                checkedValues: z.array(z.string().nullable()).default([]).optional(),
+                formValues: z
+                    .object((_a = {},
+                    _a[exports.EFormulaFilterFieldKeys.date] = z.string().nullable(),
+                    _a[exports.EFormulaFilterFieldKeys.dateRange] = z.tuple([z.string(), z.string()]),
+                    _a[exports.EFormulaFilterFieldKeys.numberRange] = z.tuple([
+                        z.number().nullable(),
+                        z.number().nullable(),
+                    ]),
+                    _a[exports.EFormulaFilterFieldKeys.string] = z.string(),
+                    // todo: отказаться от использования z.string(), оставить только z.number() [BI-15912]
+                    _a[exports.EFormulaFilterFieldKeys.lastTimeValue] = z.number().or(z.string()),
+                    _a[exports.EFormulaFilterFieldKeys.lastTimeUnit] = z.enum(exports.ELastTimeUnit),
+                    _a[exports.EFormulaFilterFieldKeys.durationUnit] = z.enum(exports.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(exports.EOuterAggregation),
+                    }),
+                    WidgetIndicatorAggregationValueSchema.forVersion("17")(z).extend({
+                        innerTemplateName: z.string().optional(),
+                    }),
+                    WidgetIndicatorTimeValueSchema.forVersion("17")(z),
+                    z.object({
+                        mode: z.literal(exports.EWidgetIndicatorValueModes.FORMULA),
+                        formula: FormulaSchema.forVersion("17")(z).optional(),
+                    }),
+                ]),
+                dbDataType: z.string(),
+                condition: z.object({
+                    filteringMethod: z.enum(Object.values(formulaFilterMethods)),
+                    timeUnit: z.enum(exports.EDimensionProcessFilterTimeUnit).optional(),
+                    values: z.array(z.string().nullable()),
+                }),
+            });
+        },
+    },
+});
+var SettingsFilterSchema = 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(exports.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(exports.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(exports.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(exports.EWidgetActionInputMethod.EVENT),
+            });
+        },
+    },
+});
+var ParameterFromStartEventSchema = SchemaRegistry.define({
+    key: "ParameterFromStartEvent",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(exports.EWidgetActionInputMethod.START_EVENT),
+            });
+        },
+    },
+});
+var ParameterFromEndEventSchema = SchemaRegistry.define({
+    key: "ParameterFromEndEvent",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(exports.EWidgetActionInputMethod.FINISH_EVENT),
+            });
+        },
+    },
+});
+var ParameterFromAggregationSchema = SchemaRegistry.define({
+    key: "ParameterFromAggregation",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(exports.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(exports.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(exports.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(exports.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(exports.EWidgetActionInputMethod.DATA_MODEL),
+                option: z.enum(exports.EDataModelOption).default(exports.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(exports.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(exports.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(exports.EActivateConditionMode.FORMULA),
+                    formula: FormulaSchema.forVersion("17")(z),
+                }),
+                z.object({
+                    mode: z.literal(exports.EActivateConditionMode.VARIABLE),
+                    variableName: z.string().nullable().default(null),
+                    variableValue: z.string().nullable().default(null),
+                }),
+            ])
+                .default({ mode: exports.EActivateConditionMode.FORMULA, formula: "" });
+        },
+    },
+});
+var ActionRunScriptSchema = SchemaRegistry.define({
+    key: "ActionRunScript",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return ActionCommonSchema.forVersion("17")(z).extend({
+                type: z.literal(exports.EActionTypes.EXECUTE_SCRIPT),
+                parameters: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+                scriptKey: z.string(),
+                autoUpdate: z.enum(exports.EAutoUpdateMode).default(exports.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(exports.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(exports.EViewOpenIn.DRAWER_WINDOW),
+                    alignment: z.enum(exports.EDrawerPlacement).default(exports.EDrawerPlacement.RIGHT),
+                    inheritFilter: z.boolean().default(true),
+                }),
+                z.object({
+                    openIn: z.literal(exports.EViewOpenIn.PLACEHOLDER),
+                    placeholderName: z.string().optional(),
+                }),
+                z.object({
+                    openIn: z.literal(exports.EViewOpenIn.MODAL_WINDOW),
+                    positionByClick: z.boolean().default(false),
+                    inheritFilter: z.boolean().default(true),
+                }),
+                z.object({
+                    openIn: z.literal(exports.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(exports.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(exports.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(exports.EViewMode.EXISTED_VIEW),
+                    viewKey: z.string().optional(),
+                    parameters: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+                }),
+                ActionOpenViewCommonSchema.forVersion("17")(z).extend({
+                    mode: z.literal(exports.EViewMode.EMPTY),
+                    placeholderName: z.string().optional(),
+                    openIn: z.literal(exports.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(exports.EActionTypes.EXECUTE_SCRIPT),
+                scriptKey: z.string(),
+                autoUpdate: z.enum(exports.EAutoUpdateMode).default(exports.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(exports.EActionButtonsTypes).default(exports.EActionButtonsTypes.BASE),
+                type: z.literal(exports.EActionTypes.EXECUTE_SCRIPT).default(exports.EActionTypes.EXECUTE_SCRIPT),
+                parameters: z.array(ViewActionParameterSchema.forVersion("17")(z)).default([]),
+                scriptKey: KeyNullableSchema.forVersion("17")(z),
+                autoUpdate: z
+                    .union([z.literal(exports.EAutoUpdateMode.NONE), z.literal(exports.EAutoUpdateMode.ALL_VIEWS)])
+                    .default(exports.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(exports.EActionButtonsTypes).default(exports.EActionButtonsTypes.BASE),
+                backgroundColor: ColorSchema.forVersion("17")(z),
+                borderColor: ColorSchema.forVersion("17")(z),
+                color: ColorSchema.forVersion("17")(z),
+                hint: z.string().default(""),
+            });
+        },
+    },
+});
 
 exports.ESimpleDataType = void 0;
 (function (ESimpleDataType) {
@@ -1087,25 +1683,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;
-    };
-}
-
 exports.EClickHouseBaseTypes = void 0;
 (function (EClickHouseBaseTypes) {
     // DATE
@@ -2271,7 +2848,7 @@ exports.ESortDirection = void 0;
  * Если к разрезу иерархии применяется 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 фильтров для быстрого поиска
@@ -2584,6 +3161,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",
+];
+
 exports.EColorMode = void 0;
 (function (EColorMode) {
     /** Окрашивание отключено */
@@ -2603,6 +3213,7 @@ exports.EColorMode = void 0;
     /** Задать цвет конкретным значениям общего разреза. Режим используется только для настроек правила отображения */
     EColorMode["BY_DIMENSION"] = "BY_DIMENSION";
 })(exports.EColorMode || (exports.EColorMode = {}));
+
 var getRuleColor = function (ruleFormula, globalContext) {
     var _a, _b;
     var link = parseIndicatorLink(ruleFormula);
@@ -2624,38 +3235,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 - индекс элемента, которому требуется цвет
@@ -2670,22 +3249,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(exports.EColorMode.BASE),
+                value: z.string(),
+            });
+        },
+    },
+});
+var ColorRuleSchema = SchemaRegistry.define({
+    key: "ColorRule",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(exports.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(exports.EColorMode.AUTO),
+            });
+        },
+    },
+});
+var ColorDisabledSchema = SchemaRegistry.define({
+    key: "ColorDisabled",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(exports.EColorMode.DISABLED),
+            });
+        },
+    },
+});
+var ColorGradientSchema = SchemaRegistry.define({
+    key: "ColorGradient",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(exports.EColorMode.GRADIENT),
+                startValue: z.string(),
+                endValue: z.string(),
+                classCount: z.number().min(3).max(10).nullish(),
+            });
+        },
+    },
+});
+var ColorFormulaSchema = SchemaRegistry.define({
+    key: "ColorFormula",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(exports.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(exports.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(exports.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: exports.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-схеме
  *
@@ -2709,81 +3488,6 @@ var themed = function (scheme, selectThemeValue) {
     return scheme.meta((_a = {}, _a[exports.ESettingsSchemaMetaKey.themeValue] = selectThemeValue, _a));
 };
 
-var ColorBaseSchema = function (z) {
-    return z.object({
-        mode: z.literal(exports.EColorMode.BASE),
-        value: z.string(),
-    });
-};
-var ColorRuleSchema = function (z) {
-    return z.object({
-        mode: z.literal(exports.EColorMode.RULE),
-        formula: FormulaSchema(z),
-    });
-};
-var ColorAutoSchema = function (z) {
-    return z.object({
-        mode: z.literal(exports.EColorMode.AUTO),
-    });
-};
-var ColorDisabledSchema = function (z) {
-    return z.object({
-        mode: z.literal(exports.EColorMode.DISABLED),
-    });
-};
-var ColorGradientSchema = function (z) {
-    return z.object({
-        mode: z.literal(exports.EColorMode.GRADIENT),
-        startValue: z.string(),
-        endValue: z.string(),
-        classCount: z.number().min(3).max(10).nullish(),
-    });
-};
-var ColorFormulaSchema = function (z) {
-    return z.object({
-        mode: z.literal(exports.EColorMode.FORMULA),
-        formula: FormulaSchema(z),
-    });
-};
-var ColorValuesSchema = function (z) {
-    return z.object({
-        mode: z.literal(exports.EColorMode.VALUES),
-        items: z
-            .array(z.object({ value: z.string(), color: z.union([ColorBaseSchema(z), ColorRuleSchema(z)]) }))
-            .default([]),
-    });
-};
-var ColorByDimensionSchema = function (z) {
-    return z.object({
-        mode: z.literal(exports.EColorMode.BY_DIMENSION),
-        /** Имя разреза из области видимости правила отображения */
-        dimensionName: z.string(),
-        items: z
-            .array(z.object({ value: z.string(), color: z.union([ColorBaseSchema(z), ColorRuleSchema(z)]) }))
-            .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: exports.EColorMode.AUTO });
-};
-
 Object.defineProperty(exports, "ELanguages", {
     enumerable: true,
     get: function () { return localization.ELanguages; }
@@ -2854,9 +3558,11 @@ exports.ParameterFromVariableSchema = ParameterFromVariableSchema;
 exports.ProcessIndicatorSchema = ProcessIndicatorSchema;
 exports.ProcessIndicatorValueSchema = ProcessIndicatorValueSchema;
 exports.RangeSchema = RangeSchema;
+exports.SchemaRegistryReader = SchemaRegistryReader;
 exports.SettingsFilterSchema = SettingsFilterSchema;
 exports.SortDirectionSchema = SortDirectionSchema;
 exports.SortOrderSchema = SortOrderSchema;
+exports.VersionedSchemaFactory = VersionedSchemaFactory;
 exports.ViewActionParameterSchema = ViewActionParameterSchema;
 exports.ViewActionSchema = ViewActionSchema;
 exports.WidgetActionParameterSchema = WidgetActionParameterSchema;
@@ -2916,7 +3622,9 @@ exports.getMeasureFormula = getMeasureFormula;
 exports.getProcessDimensionValueFormula = getProcessDimensionValueFormula;
 exports.getRuleColor = getRuleColor;
 exports.getTransitionMeasureFormula = getTransitionMeasureFormula;
+exports.hexToRgb = hexToRgb;
 exports.inheritDisplayConditionFromHierarchy = inheritDisplayConditionFromHierarchy;
+exports.interpolateHexColor = interpolateHexColor;
 exports.isDimensionProcessFilter = isDimensionProcessFilter;
 exports.isDimensionsHierarchy = isDimensionsHierarchy;
 exports.isFormulaFilterValue = isFormulaFilterValue;