ts-openapi-codegen 2.0.0 → 2.1.0-beta.1

package/dist/cli/analyzeDiff/diffEngine.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeForDiff = exports.collectDiffEntries = exports.diffToEntries = exports.withDiffType = exports.classifyDiffType = exports.buildDiffEntry = exports.classifySeverity = exports.hasPolymorphicSegment = void 0;
+const deep_diff_1 = require("deep-diff");
+const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
+const jsonPath_1 = require("../../common/utils/jsonPath");
+const normalizeObject_1 = require("../../common/utils/normalizeObject");
+const miracles_1 = require("./miracles");
+/**
+ * Проверяет, содержит ли путь сегменты, указывающие на полиморфную схему (oneOf/anyOf).
+ * @param segments сегменты json-path
+ * @returns true если встречены полиморфные сегменты
+ */
+const hasPolymorphicSegment = (segments) => {
+    return segments.includes('oneOf') || segments.includes('anyOf');
+};
+exports.hasPolymorphicSegment = hasPolymorphicSegment;
+/**
+ * Классифицирует серьёзность изменения по действию (added/removed/changed).
+ * @param action действие изменения
+ * @returns уровень серьёзности
+ */
+const classifySeverity = (action) => {
+    if (action === 'removed') {
+        return 'breaking';
+    }
+    if (action === 'changed') {
+        return 'warning';
+    }
+    return 'info';
+};
+exports.classifySeverity = classifySeverity;
+/**
+ * Строит единичную запись отличия из набора сегментов пути и значений.
+ * Добавляет заметку при полиморфных изменениях.
+ * @param action действие изменения
+ * @param segments сегменты пути
+ * @param from предыдущее значение
+ * @param to новое значение
+ * @returns готовая запись DiffEntry
+ */
+const buildDiffEntry = (action, segments, from, to) => {
+    const path = (0, jsonPath_1.toJsonPath)(segments);
+    if ((0, exports.hasPolymorphicSegment)(segments)) {
+        return {
+            action: 'changed',
+            path,
+            from,
+            to,
+            severity: 'warning',
+            note: 'Manual review required: polymorphic schema change',
+            type: 'POLYMORPHIC_CHANGE',
+        };
+    }
+    return {
+        action,
+        path,
+        from,
+        to,
+        severity: (0, exports.classifySeverity)(action),
+    };
+};
+exports.buildDiffEntry = buildDiffEntry;
+/**
+ * Возвращает имя корневой схемы из сегментов пути, если путь указывает на components.schemas или definitions.
+ * @param segments сегменты json-path
+ * @returns имя схемы или null
+ */
+const getSchemaRootName = (segments) => {
+    const s = segments.map(String);
+    if (s[0] === 'components' && s[1] === 'schemas')
+        return s[2] ?? null;
+    if (s[0] === 'definitions')
+        return s[1] ?? null;
+    return null;
+};
+/**
+ * Извлекает имя свойства из сегментов пути (ищет 'properties' и следующий сегмент).
+ * @param segments сегменты json-path
+ * @returns имя свойства или null
+ */
+const getPropertyNameFromSegments = (segments) => {
+    const s = segments.map(String);
+    const propsIndex = s.indexOf('properties');
+    if (propsIndex === -1)
+        return null;
+    return s[propsIndex + 1] ?? null;
+};
+/**
+ * Пытается классифицировать тип изменения по структуре json-path и самой записи.
+ * Возвращает семантические коды типа изменения (METHOD_REMOVED, PROPERTY_ADDED и т.д.).
+ * @param entry запись diff
+ * @returns код типа изменения или undefined
+ */
+const classifyDiffType = (entry) => {
+    const segments = (0, jsonPath_1.parseJsonPath)(entry.path);
+    const s = segments.map(String);
+    if (s[0] === 'paths') {
+        const hasMethod = s.length >= 3;
+        const isMethodRoot = s.length === 3;
+        if (hasMethod && isMethodRoot) {
+            if (entry.action === 'removed')
+                return 'METHOD_REMOVED';
+            if (entry.action === 'added')
+                return 'METHOD_ADDED';
+            return 'METHOD_CHANGED';
+        }
+        return 'PATH_CHANGED';
+    }
+    const schemaName = getSchemaRootName(s);
+    if (schemaName) {
+        const isSchemaRoot = s.length <= 3;
+        if (isSchemaRoot) {
+            if (entry.action === 'removed')
+                return 'SCHEMA_REMOVED';
+            if (entry.action === 'added')
+                return 'SCHEMA_ADDED';
+            return 'SCHEMA_CHANGED';
+        }
+        const propertyName = getPropertyNameFromSegments(s);
+        if (propertyName) {
+            const fromType = (0, miracles_1.getTypeSignature)((entry.from ?? {}));
+            const toType = (0, miracles_1.getTypeSignature)((entry.to ?? {}));
+            if (entry.action === 'changed' && fromType && toType && fromType !== toType) {
+                return 'TYPE_CHANGED';
+            }
+            if (entry.action === 'removed')
+                return 'PROPERTY_REMOVED';
+            if (entry.action === 'added')
+                return 'PROPERTY_ADDED';
+            return 'PROPERTY_CHANGED';
+        }
+        return 'SCHEMA_CHANGED';
+    }
+    return undefined;
+};
+exports.classifyDiffType = classifyDiffType;
+/**
+ * Добавляет поле type к каждой записи diff, вычисленное через classifyDiffType, если отсутствует.
+ * @param entries массив записей diff
+ * @returns массив записей с полем type
+ */
+const withDiffType = (entries) => {
+    return entries.map(entry => ({
+        ...entry,
+        type: entry.type ?? (0, exports.classifyDiffType)(entry),
+    }));
+};
+exports.withDiffType = withDiffType;
+/**
+ * Преобразует единичный объект отличия из deep-diff в один или несколько DiffEntry.
+ * Обрабатывает массивные/индексные отличия (kind 'A') рекурсивно.
+ * @param difference объект отличия от deep-diff
+ * @returns массив DiffEntry
+ */
+const diffToEntries = (difference) => {
+    if (difference.kind === 'A') {
+        const segments = [...(difference.path ?? []), difference.index];
+        const item = difference.item;
+        if (item.kind === 'A') {
+            return (0, exports.diffToEntries)({ ...item, path: segments });
+        }
+        if (item.kind === 'N') {
+            return [(0, exports.buildDiffEntry)('added', segments, undefined, item.rhs)];
+        }
+        if (item.kind === 'D') {
+            return [(0, exports.buildDiffEntry)('removed', segments, item.lhs, undefined)];
+        }
+        if (item.kind === 'E') {
+            return [(0, exports.buildDiffEntry)('changed', segments, item.lhs, item.rhs)];
+        }
+        return [];
+    }
+    const segments = difference.path ?? [];
+    if (difference.kind === 'N') {
+        return [(0, exports.buildDiffEntry)('added', segments, undefined, difference.rhs)];
+    }
+    if (difference.kind === 'D') {
+        return [(0, exports.buildDiffEntry)('removed', segments, difference.lhs, undefined)];
+    }
+    if (difference.kind === 'E') {
+        return [(0, exports.buildDiffEntry)('changed', segments, difference.lhs, difference.rhs)];
+    }
+    return [];
+};
+exports.diffToEntries = diffToEntries;
+/**
+ * Собирает все записи отличий между двумя JSON-структурами: старой и новой.
+ * Выполняет глубокое сравнение и маппинг на DiffEntry.
+ * @param oldValue старая версия спецификации
+ * @param newValue новая версия спецификации
+ * @returns массив DiffEntry
+ */
+const collectDiffEntries = (oldValue, newValue) => {
+    if ((0, fast_deep_equal_1.default)(oldValue, newValue)) {
+        return [];
+    }
+    const differences = (0, deep_diff_1.diff)(oldValue, newValue) ?? [];
+    return differences.flatMap(exports.diffToEntries);
+};
+exports.collectDiffEntries = collectDiffEntries;
+const normalizeForDiff = (value) => {
+    // обёртка вокруг normalizeObject, если нужно
+    return (0, normalizeObject_1.normalizeObject)(value);
+};
+exports.normalizeForDiff = normalizeForDiff;

package/dist/cli/analyzeDiff/ignoreRules.d.ts

@@ -0,0 +1,33 @@
+import type { DiffEntry, IgnoreRule } from './types';
+/**
+ * Проверяет, активно ли правило игнорирования по полю `until`.
+ * @param rule правило игнорирования
+ * @returns true если правило активно или не содержит валидной даты
+ */
+export declare const isRuleActive: (rule: IgnoreRule) => boolean;
+/**
+ * Проверяет, соответствует ли запись diff правилу игнорирования.
+ * Совмещает полное совпадение пути, префикс и регулярные выражения.
+ * @param entry запись отличия
+ * @param rule правило игнорирования
+ * @returns true если правило применимо к записи
+ */
+export declare const matchesIgnoreRule: (entry: DiffEntry, rule: IgnoreRule) => boolean;
+/**
+ * Применяет набор правил игнорирования к массиву записей и возвращает отфильтрованные записи и число игнорированных.
+ * @param entries список записей diff
+ * @param rules список правил игнорирования
+ * @returns объект с полем filtered и числом ignored
+ */
+export declare const applyIgnoreRules: (entries: DiffEntry[], rules: IgnoreRule[]) => {
+    filtered: DiffEntry[];
+    ignored: number;
+};
+/**
+ * Извлекает правила игнорирования из загруженной конфигурации openapi.
+ * @param configData загруженные данные конфигурации
+ * @returns список правил ignore
+ */
+export declare const getIgnoreRulesFromConfig: (configData: Record<string, any> | Record<string, any>[] | null) => IgnoreRule[];
+export declare const loadIgnoreRules: (openapiConfigPath?: string) => IgnoreRule[];
+//# sourceMappingURL=ignoreRules.d.ts.map

package/dist/cli/analyzeDiff/ignoreRules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ignoreRules.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/ignoreRules.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErD;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,UAAU,KAAG,OAK/C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,SAAS,EAAE,MAAM,UAAU,KAAG,OAkBtE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,SAAS,EAAE,EAAE,OAAO,UAAU,EAAE,KAAG;IAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAapH,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GACjC,YAAY,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,IAAI,KAC/D,UAAU,EAOZ,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,oBAAoB,MAAM,KAAG,UAAU,EAGtE,CAAC"}

package/dist/cli/analyzeDiff/ignoreRules.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadIgnoreRules = exports.getIgnoreRulesFromConfig = exports.applyIgnoreRules = exports.matchesIgnoreRule = exports.isRuleActive = void 0;
+const Consts_1 = require("../../common/Consts");
+const LoggerMessages_1 = require("../../common/LoggerMessages");
+const loadConfigIfExists_1 = require("../../common/utils/loadConfigIfExists");
+/**
+ * Проверяет, активно ли правило игнорирования по полю `until`.
+ * @param rule правило игнорирования
+ * @returns true если правило активно или не содержит валидной даты
+ */
+const isRuleActive = (rule) => {
+    if (!rule.until)
+        return true;
+    const timestamp = Date.parse(rule.until);
+    if (Number.isNaN(timestamp))
+        return true;
+    return Date.now() <= timestamp;
+};
+exports.isRuleActive = isRuleActive;
+/**
+ * Проверяет, соответствует ли запись diff правилу игнорирования.
+ * Совмещает полное совпадение пути, префикс и регулярные выражения.
+ * @param entry запись отличия
+ * @param rule правило игнорирования
+ * @returns true если правило применимо к записи
+ */
+const matchesIgnoreRule = (entry, rule) => {
+    if (!(0, exports.isRuleActive)(rule))
+        return false;
+    if (rule.path) {
+        if (entry.path === rule.path)
+            return true;
+        if (entry.path.startsWith(`${rule.path}.`))
+            return true;
+        if (entry.path.startsWith(`${rule.path}[`))
+            return true;
+        if (entry.path.startsWith(`${rule.path}/`))
+            return true;
+    }
+    if (rule.pattern) {
+        try {
+            const regex = new RegExp(rule.pattern);
+            return regex.test(entry.path);
+        }
+        catch (err) {
+            Consts_1.APP_LOGGER.warn(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.INVALID_IGNORE_PATTERN(rule.pattern, String(err)));
+            return false;
+        }
+    }
+    return false;
+};
+exports.matchesIgnoreRule = matchesIgnoreRule;
+/**
+ * Применяет набор правил игнорирования к массиву записей и возвращает отфильтрованные записи и число игнорированных.
+ * @param entries список записей diff
+ * @param rules список правил игнорирования
+ * @returns объект с полем filtered и числом ignored
+ */
+const applyIgnoreRules = (entries, rules) => {
+    if (!rules.length) {
+        return { filtered: entries, ignored: 0 };
+    }
+    let ignored = 0;
+    const filtered = entries.filter(entry => {
+        const shouldIgnore = rules.some(rule => (0, exports.matchesIgnoreRule)(entry, rule));
+        if (shouldIgnore)
+            ignored += 1;
+        return !shouldIgnore;
+    });
+    return { filtered, ignored };
+};
+exports.applyIgnoreRules = applyIgnoreRules;
+/**
+ * Извлекает правила игнорирования из загруженной конфигурации openapi.
+ * @param configData загруженные данные конфигурации
+ * @returns список правил ignore
+ */
+const getIgnoreRulesFromConfig = (configData) => {
+    if (!configData)
+        return [];
+    if (Array.isArray(configData)) {
+        const withAnalyze = configData.find(item => item?.analyze?.ignore);
+        return withAnalyze?.analyze?.ignore ?? [];
+    }
+    return configData.analyze?.ignore ?? [];
+};
+exports.getIgnoreRulesFromConfig = getIgnoreRulesFromConfig;
+const loadIgnoreRules = (openapiConfigPath) => {
+    const configData = (0, loadConfigIfExists_1.loadConfigIfExists)(openapiConfigPath);
+    return (0, exports.getIgnoreRulesFromConfig)(configData);
+};
+exports.loadIgnoreRules = loadIgnoreRules;

package/dist/cli/analyzeDiff/ignoreSemanticChanges.d.ts

@@ -0,0 +1,10 @@
+import { SemanticDiffReport } from '../../core/semanticDiff/analyzeOpenApiDiff';
+import { IgnoreRule } from './types';
+/**
+ * Applies legacy analyze.ignore rules to semantic changes and returns ignored count.
+ */
+export declare function filterSemanticChangesByIgnoreRules(report: SemanticDiffReport, ignoreRules: IgnoreRule[]): {
+    report: SemanticDiffReport;
+    ignored: number;
+};
+//# sourceMappingURL=ignoreSemanticChanges.d.ts.map

package/dist/cli/analyzeDiff/ignoreSemanticChanges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ignoreSemanticChanges.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/ignoreSemanticChanges.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,4CAA4C,CAAC;AAEhF,OAAO,EAAa,UAAU,EAAE,MAAM,SAAS,CAAC;AAqDhD;;GAEG;AACH,wBAAgB,kCAAkC,CAAC,MAAM,EAAE,kBAAkB,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG;IAAE,MAAM,EAAE,kBAAkB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAmCzJ"}

package/dist/cli/analyzeDiff/ignoreSemanticChanges.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterSemanticChangesByIgnoreRules = filterSemanticChangesByIgnoreRules;
+const ignoreRules_1 = require("./ignoreRules");
+/**
+ * Rebuilds summary counters from current semantic changes.
+ */
+function rebuildSummary(report) {
+    return report.changes.reduce((acc, change) => {
+        if (change.severity === 'breaking') {
+            acc.breaking += 1;
+        }
+        else if (change.severity === 'non-breaking') {
+            acc.nonBreaking += 1;
+        }
+        else {
+            acc.informational += 1;
+        }
+        return acc;
+    }, { breaking: 0, nonBreaking: 0, informational: 0 });
+}
+/**
+ * Rebuilds recommendation based on recalculated summary.
+ */
+function rebuildRecommendation(summary) {
+    let semver = 'patch';
+    let confidence = 'high';
+    let reason = 'No breaking or feature-level changes detected.';
+    let reasons = ['NO_API_SURFACE_CHANGES'];
+    if (summary.breaking > 0) {
+        semver = 'major';
+        confidence = summary.breaking >= 3 ? 'high' : 'medium';
+        reason = 'Breaking changes detected.';
+        reasons = ['HAS_BREAKING_CHANGES'];
+    }
+    else if (summary.nonBreaking > 0) {
+        semver = 'minor';
+        confidence = summary.nonBreaking >= 3 ? 'high' : 'medium';
+        reason = 'Backward-compatible feature changes detected.';
+        reasons = ['HAS_BACKWARD_COMPATIBLE_CHANGES'];
+    }
+    else if (summary.informational > 0) {
+        semver = 'patch';
+        confidence = 'medium';
+        reason = 'Only informational changes detected.';
+        reasons = ['HAS_INFORMATIONAL_ONLY_CHANGES'];
+    }
+    return { semver, confidence, reason, reasons };
+}
+/**
+ * Applies legacy analyze.ignore rules to semantic changes and returns ignored count.
+ */
+function filterSemanticChangesByIgnoreRules(report, ignoreRules) {
+    if (!ignoreRules.length) {
+        return { report, ignored: 0 };
+    }
+    let ignored = 0;
+    const filteredChanges = report.changes.filter(change => {
+        const diffEntry = {
+            action: 'changed',
+            path: change.path,
+            severity: 'info',
+        };
+        const ignoredByRule = ignoreRules.some(rule => (0, ignoreRules_1.matchesIgnoreRule)(diffEntry, rule));
+        if (ignoredByRule) {
+            ignored += 1;
+            return false;
+        }
+        return true;
+    });
+    if (ignored === 0) {
+        return { report, ignored: 0 };
+    }
+    const summary = rebuildSummary({ ...report, changes: filteredChanges });
+    return {
+        report: {
+            ...report,
+            changes: filteredChanges,
+            summary,
+            recommendation: rebuildRecommendation(summary),
+        },
+        ignored,
+    };
+}

package/dist/cli/analyzeDiff/logLegacyReport.d.ts

@@ -0,0 +1,6 @@
+import { DiffReport } from './types';
+/**
+ * Пишет legacy summary в лог.
+ */
+export declare function logLegacyReport(report: DiffReport, reportPath: string): void;
+//# sourceMappingURL=logLegacyReport.d.ts.map

package/dist/cli/analyzeDiff/logLegacyReport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logLegacyReport.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/logLegacyReport.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CA0B5E"}

package/dist/cli/analyzeDiff/logLegacyReport.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logLegacyReport = logLegacyReport;
+const Consts_1 = require("../../common/Consts");
+const LoggerMessages_1 = require("../../common/LoggerMessages");
+/**
+ * Пишет legacy summary в лог.
+ */
+function logLegacyReport(report, reportPath) {
+    Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.SEPARATOR);
+    Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.SUMMARY(report, reportPath));
+    Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.LEGACY_BASE(report.metadata.base));
+    Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.LEGACY_TARGET(report.metadata.target));
+    if (report.stats.stabilityScore !== undefined) {
+        Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.LEGACY_STABILITY_SCORE(report.stats.stabilityScore));
+    }
+    Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.LEGACY_CHANGES(report.stats));
+    if (report.diff.breaking.length > 0) {
+        Consts_1.APP_LOGGER.error(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.LEGACY_BREAKING(report.diff.breaking.length));
+    }
+    if (report.diff.warnings.length > 0) {
+        Consts_1.APP_LOGGER.warn(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.LEGACY_WARNINGS(report.diff.warnings.length));
+    }
+    const ignored = report.stats.ignored ?? 0;
+    if (ignored > 0) {
+        Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.LEGACY_IGNORED(ignored));
+    }
+    Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.REPORT_CREATED(reportPath));
+}

package/dist/cli/analyzeDiff/miracles.d.ts

@@ -0,0 +1,89 @@
+import type { DiffEntry, JsonValue, MiracleEntry } from './types';
+type PropertyChange = {
+    schemaPath: string;
+    schemaName: string;
+    propertyName: string;
+    entry: DiffEntry;
+    payload: Record<string, unknown>;
+    typeSignature?: string;
+    description?: string;
+    scalarType?: string;
+};
+/**
+ * Нормализует строковое имя (удаляет спецсимволы, приводит к camelCase и lower-case).
+ * @param value исходная строка
+ * @returns нормализованное имя
+ */
+export declare const normalizeName: (value: string) => string;
+/**
+ * Получает сигнатуру типа из описания свойства схемы (учитывает $ref, type, oneOf/anyOf/allOf).
+ * @param payload объект описания свойства
+ * @returns строковая сигнатура типа или undefined
+ */
+export declare const getTypeSignature: (payload: Record<string, unknown>) => string | undefined;
+/**
+ * Приводит разные обозначения скалярных типов к общим (number/string/boolean).
+ * @param value строковая сигнатура типа
+ * @returns нормализованный скалярный тип или undefined
+ */
+export declare const normalizeScalarType: (value?: string) => string | undefined;
+/**
+ * Извлекает и тримит описание свойства, если оно присутствует.
+ * @param payload объект описания свойства
+ * @returns описание или undefined
+ */
+export declare const getDescription: (payload: Record<string, unknown>) => string | undefined;
+/**
+ * Пытается извлечь подробную информацию об изменении свойства схемы из записи diff.
+ * Возвращает null если запись не представляет изменение свойства.
+ * @param entry запись diff
+ * @returns объект PropertyChange или null
+ */
+export declare const extractPropertyChange: (entry: DiffEntry) => PropertyChange | null;
+/**
+ * Определяет, указывает ли путь записи на свойство в схеме (содержит 'properties').
+ * @param entry запись diff
+ * @returns true если путь относится к свойству схемы
+ */
+export declare const isSchemaPropertyPath: (entry: DiffEntry) => boolean;
+/**
+ * Оценивает, могут ли два изменения (удаление и добавление) являться кандидатами на совпадение (rename).
+ * Сравнивает путь схемы и, при наличии, сигнатуры типов.
+ * @param removed информация об удалённом свойстве
+ * @param added информация о добавленном свойстве
+ * @returns true если кандидаты совместимы
+ */
+export declare const isSimilarityCandidate: (removed: PropertyChange, added: PropertyChange) => boolean;
+/**
+ * Вычисляет бонус к confidence на основе схожести описаний свойств.
+ * @param removed описание для удалённого свойства
+ * @param added описание для добавленного свойства
+ * @returns числовой бонус (0..0.05)
+ */
+export declare const descriptionSimilarityBonus: (removed?: string, added?: string) => number;
+/**
+ * Комбинирует факторы в итоговую confidence (0..1) для RENAME эвристики.
+ * @param nameRatio нормализованное расстояние имён
+ * @param sameType флаг совпадения сигнатур типов
+ * @param onlyCandidate флаг единственного кандидата
+ * @param descBonus бонус от схожести описаний
+ * @returns итоговое confidence
+ */
+export declare const computeConfidence: (nameRatio: number, sameType: boolean, onlyCandidate: boolean, descBonus: number) => number;
+/**
+ * Собирает карту путей свойств → нормализованный скалярный тип из спецификации.
+ * @param spec спецификация OpenAPI
+ * @returns Map с json-path как ключом и скалярным типом как значением
+ */
+export declare const collectPropertyScalarTypes: (spec: JsonValue) => Map<string, string>;
+/**
+ * Формирует список эвристических находок (miracles): переименования и коэрцирования типов.
+ * Сравнивает удалённые/добавленные свойства и изменения типов, добавляет записи с confidence.
+ * @param entries все собранные записи diff
+ * @param oldSpec нормализованная старая спецификация
+ * @param newSpec нормализованная новая спецификация
+ * @returns массив MiracleEntry
+ */
+export declare const buildMiracles: (entries: DiffEntry[], oldSpec: JsonValue, newSpec: JsonValue) => MiracleEntry[];
+export {};
+//# sourceMappingURL=miracles.d.ts.map

package/dist/cli/analyzeDiff/miracles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"miracles.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/miracles.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAElE,KAAK,cAAc,GAAG;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,SAAS,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,KAAG,MAM7C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,MAAM,GAAG,SAiB5E,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,MAAM,KAAG,MAAM,GAAG,SAS7D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,MAAM,GAAG,SAK1E,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAO,SAAS,KAAG,cAAc,GAAG,IAyBzE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,SAAS,KAAG,OAGvD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAAI,SAAS,cAAc,EAAE,OAAO,cAAc,KAAG,OAQtF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,GAAI,UAAU,MAAM,EAAE,QAAQ,MAAM,KAAG,MAQ7E,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,GAAI,WAAW,MAAM,EAAE,UAAU,OAAO,EAAE,eAAe,OAAO,EAAE,WAAW,MAAM,KAAG,MAQnH,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,GAAI,MAAM,SAAS,KAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CA6B9E,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,SAAS,EAAE,EAAE,SAAS,SAAS,EAAE,SAAS,SAAS,KAAG,YAAY,EAsGxG,CAAC"}