@unispechq/unispec-core 0.3.0 → 0.3.2

package/dist/src/diff/impact-strategies-refactored.d.ts

@@ -0,0 +1,69 @@
+import type { ChangeImpact } from "./enhanced-diff.js";
+import type { UniSpecChange } from "./types.js";
+/**
+ * Strategy interface for analyzing change impact.
+ */
+export interface ImpactAnalysisStrategy {
+    analyze(change: UniSpecChange): ChangeImpact;
+}
+/**
+ * Base class for impact analysis strategies with common functionality.
+ */
+declare abstract class BaseImpactStrategy implements ImpactAnalysisStrategy {
+    protected createDefaultImpact(): ChangeImpact;
+    protected setBreakingChange(impact: ChangeImpact, clientImpact?: "low" | "medium" | "high", serverImpact?: "low" | "medium" | "high", migrationComplexity?: "simple" | "moderate" | "complex"): ChangeImpact;
+    protected setNonBreakingChange(impact: ChangeImpact, clientImpact?: "none" | "low" | "medium" | "high", serverImpact?: "none" | "low" | "medium" | "high", migrationComplexity?: "none" | "simple" | "moderate" | "complex"): ChangeImpact;
+    abstract analyze(change: UniSpecChange): ChangeImpact;
+}
+/**
+ * REST route impact analysis strategy.
+ */
+export declare class RestRouteImpactStrategy extends BaseImpactStrategy {
+    analyze(change: UniSpecChange): ChangeImpact;
+    private isRouteRemoval;
+    private isRouteAddition;
+    private isMethodChange;
+    private isPathChange;
+    private isRequiredParameterChange;
+    private isResponseRemoval;
+    private isOptionalParameterAddition;
+}
+/**
+ * GraphQL operation impact analysis strategy.
+ */
+export declare class GraphQLOperationImpactStrategy extends BaseImpactStrategy {
+    analyze(change: UniSpecChange): ChangeImpact;
+    private isOperationRemoval;
+    private isOperationAddition;
+    private isReturnTypeChange;
+    private isOptionalArgumentAddition;
+    private isRequiredArgumentChange;
+}
+/**
+ * WebSocket impact analysis strategy.
+ */
+export declare class WebSocketImpactStrategy extends BaseImpactStrategy {
+    analyze(change: UniSpecChange): ChangeImpact;
+    private isChannelRemoval;
+    private isChannelAddition;
+    private isMessageRemoval;
+    private isMessageAddition;
+    private isMessageSchemaChange;
+}
+/**
+ * Default impact analysis strategy for unknown changes.
+ */
+export declare class DefaultImpactStrategy extends BaseImpactStrategy {
+    analyze(_change: UniSpecChange): ChangeImpact;
+}
+/**
+ * Factory for creating impact analysis strategies.
+ */
+declare const ImpactAnalysisStrategyFactory: {
+    strategies: Map<string, ImpactAnalysisStrategy>;
+    getStrategy(protocol?: string): ImpactAnalysisStrategy;
+    registerStrategy(protocol: string, strategy: ImpactAnalysisStrategy): void;
+    getAvailableStrategies(): string[];
+    clearStrategies(): void;
+};
+export { ImpactAnalysisStrategyFactory };

package/dist/src/diff/impact-strategies-refactored.js

@@ -0,0 +1,223 @@
+/**
+ * Base class for impact analysis strategies with common functionality.
+ */
+class BaseImpactStrategy {
+    createDefaultImpact() {
+        return {
+            backwardCompatibility: "unknown",
+            clientImpact: "none",
+            serverImpact: "none",
+            migrationComplexity: "none",
+        };
+    }
+    setBreakingChange(impact, clientImpact = "high", serverImpact = "medium", migrationComplexity = "moderate") {
+        impact.backwardCompatibility = "incompatible";
+        impact.clientImpact = clientImpact;
+        impact.serverImpact = serverImpact;
+        impact.migrationComplexity = migrationComplexity;
+        return impact;
+    }
+    setNonBreakingChange(impact, clientImpact = "none", serverImpact = "low", migrationComplexity = "none") {
+        impact.backwardCompatibility = "compatible";
+        impact.clientImpact = clientImpact;
+        impact.serverImpact = serverImpact;
+        impact.migrationComplexity = migrationComplexity;
+        return impact;
+    }
+}
+/**
+ * REST route impact analysis strategy.
+ */
+export class RestRouteImpactStrategy extends BaseImpactStrategy {
+    analyze(change) {
+        const impact = this.createDefaultImpact();
+        // Route removal is always breaking
+        if (this.isRouteRemoval(change)) {
+            return this.setBreakingChange(impact, "high", "medium", "complex");
+        }
+        // Route addition is non-breaking
+        if (this.isRouteAddition(change)) {
+            return this.setNonBreakingChange(impact, "none", "low", "none");
+        }
+        // Method change is breaking
+        if (this.isMethodChange(change)) {
+            return this.setBreakingChange(impact, "high", "medium", "moderate");
+        }
+        // Path change is breaking
+        if (this.isPathChange(change)) {
+            return this.setBreakingChange(impact, "high", "medium", "moderate");
+        }
+        // Required parameter change is breaking
+        if (this.isRequiredParameterChange(change)) {
+            return this.setBreakingChange(impact, "medium", "low", "simple");
+        }
+        // Response status code removal is breaking
+        if (this.isResponseRemoval(change)) {
+            return this.setBreakingChange(impact, "medium", "low", "simple");
+        }
+        // Adding optional parameter is non-breaking
+        if (this.isOptionalParameterAddition(change)) {
+            return this.setNonBreakingChange(impact, "none", "low", "none");
+        }
+        return impact;
+    }
+    isRouteRemoval(change) {
+        return (change.description === "Item removed" &&
+            !!change.kind?.includes("route.removed"));
+    }
+    isRouteAddition(change) {
+        return (change.description === "Item added" &&
+            !!change.kind?.includes("route.added"));
+    }
+    isMethodChange(change) {
+        return (change.path.includes("/method") && change.description === "Value changed");
+    }
+    isPathChange(change) {
+        return (change.path.includes("/path") && change.description === "Value changed");
+    }
+    isRequiredParameterChange(change) {
+        return (change.path.includes("/required") &&
+            change.description === "Value changed");
+    }
+    isResponseRemoval(change) {
+        return (change.path.includes("/responses/") &&
+            change.description === "Item removed");
+    }
+    isOptionalParameterAddition(change) {
+        return (change.path.includes("/queryParams/") &&
+            change.description === "Item added");
+    }
+}
+/**
+ * GraphQL operation impact analysis strategy.
+ */
+export class GraphQLOperationImpactStrategy extends BaseImpactStrategy {
+    analyze(change) {
+        const impact = this.createDefaultImpact();
+        // Operation removal is breaking
+        if (this.isOperationRemoval(change)) {
+            return this.setBreakingChange(impact, "high", "medium", "complex");
+        }
+        // Operation addition is non-breaking
+        if (this.isOperationAddition(change)) {
+            return this.setNonBreakingChange(impact, "none", "low", "none");
+        }
+        // Return type change is breaking
+        if (this.isReturnTypeChange(change)) {
+            return this.setBreakingChange(impact, "high", "medium", "moderate");
+        }
+        // Adding optional argument is non-breaking
+        if (this.isOptionalArgumentAddition(change)) {
+            return this.setNonBreakingChange(impact, "none", "low", "none");
+        }
+        // Making argument required is breaking
+        if (this.isRequiredArgumentChange(change)) {
+            return this.setBreakingChange(impact, "medium", "low", "simple");
+        }
+        return impact;
+    }
+    isOperationRemoval(change) {
+        return (change.description === "Item removed" &&
+            !!change.kind?.includes("operation.removed"));
+    }
+    isOperationAddition(change) {
+        return (change.description === "Item added" &&
+            !!change.kind?.includes("operation.added"));
+    }
+    isReturnTypeChange(change) {
+        return (change.path.includes("/returnType") &&
+            change.description === "Value changed");
+    }
+    isOptionalArgumentAddition(change) {
+        return (change.path.includes("/args/") && change.description === "Item added");
+    }
+    isRequiredArgumentChange(change) {
+        return (change.path.includes("/args/") &&
+            change.path.includes("/required") &&
+            change.description === "Value changed");
+    }
+}
+/**
+ * WebSocket impact analysis strategy.
+ */
+export class WebSocketImpactStrategy extends BaseImpactStrategy {
+    analyze(change) {
+        const impact = this.createDefaultImpact();
+        // Channel removal is breaking
+        if (this.isChannelRemoval(change)) {
+            return this.setBreakingChange(impact, "high", "medium", "complex");
+        }
+        // Channel addition is non-breaking
+        if (this.isChannelAddition(change)) {
+            return this.setNonBreakingChange(impact, "none", "low", "none");
+        }
+        // Message removal is breaking
+        if (this.isMessageRemoval(change)) {
+            return this.setBreakingChange(impact, "medium", "low", "moderate");
+        }
+        // Message addition is non-breaking
+        if (this.isMessageAddition(change)) {
+            return this.setNonBreakingChange(impact, "none", "low", "none");
+        }
+        // Message schema change is breaking
+        if (this.isMessageSchemaChange(change)) {
+            return this.setBreakingChange(impact, "medium", "low", "moderate");
+        }
+        return impact;
+    }
+    isChannelRemoval(change) {
+        return (change.description === "Item removed" &&
+            !!change.kind?.includes("channel.removed"));
+    }
+    isChannelAddition(change) {
+        return (change.description === "Item added" &&
+            !!change.kind?.includes("channel.added"));
+    }
+    isMessageRemoval(change) {
+        return (change.description === "Item removed" &&
+            !!change.kind?.includes("message.removed"));
+    }
+    isMessageAddition(change) {
+        return (change.description === "Item added" &&
+            !!change.kind?.includes("message.added"));
+    }
+    isMessageSchemaChange(change) {
+        return (change.path.includes("/schemaRef") &&
+            change.description === "Value changed");
+    }
+}
+/**
+ * Default impact analysis strategy for unknown changes.
+ */
+export class DefaultImpactStrategy extends BaseImpactStrategy {
+    analyze(_change) {
+        return this.createDefaultImpact();
+    }
+}
+/**
+ * Factory for creating impact analysis strategies.
+ */
+const ImpactAnalysisStrategyFactory = {
+    strategies: new Map([
+        ["rest", new RestRouteImpactStrategy()],
+        ["graphql", new GraphQLOperationImpactStrategy()],
+        ["websocket", new WebSocketImpactStrategy()],
+    ]),
+    getStrategy(protocol) {
+        if (!protocol) {
+            return new DefaultImpactStrategy();
+        }
+        const strategy = this.strategies.get(protocol);
+        return strategy || new DefaultImpactStrategy();
+    },
+    registerStrategy(protocol, strategy) {
+        this.strategies.set(protocol, strategy);
+    },
+    getAvailableStrategies() {
+        return Array.from(this.strategies.keys());
+    },
+    clearStrategies() {
+        this.strategies.clear();
+    },
+};
+export { ImpactAnalysisStrategyFactory };

package/dist/src/diff/impact-strategies.d.ts

@@ -0,0 +1,41 @@
+import type { ChangeImpact } from "./enhanced-diff.js";
+import type { UniSpecChange } from "./types.js";
+/**
+ * Strategy interface for analyzing change impact.
+ */
+export interface ImpactAnalysisStrategy {
+    analyze(change: UniSpecChange): ChangeImpact;
+}
+/**
+ * REST route impact analysis strategy.
+ */
+export declare class RestRouteImpactStrategy implements ImpactAnalysisStrategy {
+    analyze(change: UniSpecChange): ChangeImpact;
+}
+/**
+ * GraphQL operation impact analysis strategy.
+ */
+export declare class GraphQLOperationImpactStrategy implements ImpactAnalysisStrategy {
+    analyze(change: UniSpecChange): ChangeImpact;
+}
+/**
+ * WebSocket impact analysis strategy.
+ */
+export declare class WebSocketImpactStrategy implements ImpactAnalysisStrategy {
+    analyze(change: UniSpecChange): ChangeImpact;
+}
+/**
+ * Default impact analysis strategy for unknown changes.
+ */
+export declare class DefaultImpactStrategy implements ImpactAnalysisStrategy {
+    analyze(_change: UniSpecChange): ChangeImpact;
+}
+/**
+ * Factory for creating impact analysis strategies.
+ */
+declare const ImpactAnalysisStrategyFactory: {
+    strategies: Map<string, ImpactAnalysisStrategy>;
+    getStrategy(protocol?: string): ImpactAnalysisStrategy;
+    registerStrategy(protocol: string, strategy: ImpactAnalysisStrategy): void;
+};
+export { ImpactAnalysisStrategyFactory };

package/dist/src/diff/impact-strategies.js

@@ -0,0 +1,212 @@
+/**
+ * REST route impact analysis strategy.
+ */
+export class RestRouteImpactStrategy {
+    analyze(change) {
+        const impact = {
+            backwardCompatibility: "unknown",
+            clientImpact: "none",
+            serverImpact: "none",
+            migrationComplexity: "none",
+        };
+        // Route removal is always breaking
+        if (change.description === "Item removed" &&
+            change.kind?.includes("route.removed")) {
+            impact.backwardCompatibility = "incompatible";
+            impact.clientImpact = "high";
+            impact.serverImpact = "medium";
+            impact.migrationComplexity = "complex";
+        }
+        // Route addition is non-breaking
+        if (change.description === "Item added" &&
+            change.kind?.includes("route.added")) {
+            impact.backwardCompatibility = "compatible";
+            impact.clientImpact = "none";
+            impact.serverImpact = "low";
+            impact.migrationComplexity = "none";
+        }
+        // Method change is breaking
+        if (change.path.includes("/method") &&
+            change.description === "Value changed") {
+            impact.backwardCompatibility = "incompatible";
+            impact.clientImpact = "high";
+            impact.serverImpact = "medium";
+            impact.migrationComplexity = "moderate";
+        }
+        // Path change is breaking
+        if (change.path.includes("/path") &&
+            change.description === "Value changed") {
+            impact.backwardCompatibility = "incompatible";
+            impact.clientImpact = "high";
+            impact.serverImpact = "medium";
+            impact.migrationComplexity = "moderate";
+        }
+        // Required parameter change is breaking
+        if (change.path.includes("/required") &&
+            change.description === "Value changed") {
+            impact.backwardCompatibility = "incompatible";
+            impact.clientImpact = "medium";
+            impact.serverImpact = "low";
+            impact.migrationComplexity = "simple";
+        }
+        // Response status code removal is breaking
+        if (change.path.includes("/responses/") &&
+            change.description === "Item removed") {
+            impact.backwardCompatibility = "incompatible";
+            impact.clientImpact = "medium";
+            impact.serverImpact = "low";
+            impact.migrationComplexity = "simple";
+        }
+        // Adding optional parameter is non-breaking
+        if (change.path.includes("/queryParams/") &&
+            change.description === "Item added") {
+            impact.backwardCompatibility = "compatible";
+            impact.clientImpact = "none";
+            impact.serverImpact = "low";
+            impact.migrationComplexity = "none";
+        }
+        return impact;
+    }
+}
+/**
+ * GraphQL operation impact analysis strategy.
+ */
+export class GraphQLOperationImpactStrategy {
+    analyze(change) {
+        const impact = {
+            backwardCompatibility: "unknown",
+            clientImpact: "none",
+            serverImpact: "none",
+            migrationComplexity: "none",
+        };
+        // Operation removal is breaking
+        if (change.description === "Item removed" &&
+            change.kind?.includes("operation.removed")) {
+            impact.backwardCompatibility = "incompatible";
+            impact.clientImpact = "high";
+            impact.serverImpact = "medium";
+            impact.migrationComplexity = "complex";
+        }
+        // Operation addition is non-breaking
+        if (change.description === "Item added" &&
+            change.kind?.includes("operation.added")) {
+            impact.backwardCompatibility = "compatible";
+            impact.clientImpact = "none";
+            impact.serverImpact = "low";
+            impact.migrationComplexity = "none";
+        }
+        // Return type change is breaking
+        if (change.path.includes("/returnType") &&
+            change.description === "Value changed") {
+            impact.backwardCompatibility = "incompatible";
+            impact.clientImpact = "high";
+            impact.serverImpact = "medium";
+            impact.migrationComplexity = "moderate";
+        }
+        // Adding optional argument is non-breaking
+        if (change.path.includes("/args/") && change.description === "Item added") {
+            impact.backwardCompatibility = "compatible";
+            impact.clientImpact = "none";
+            impact.serverImpact = "low";
+            impact.migrationComplexity = "none";
+        }
+        // Making argument required is breaking
+        if (change.path.includes("/args/") &&
+            change.path.includes("/required") &&
+            change.description === "Value changed") {
+            impact.backwardCompatibility = "incompatible";
+            impact.clientImpact = "medium";
+            impact.serverImpact = "low";
+            impact.migrationComplexity = "simple";
+        }
+        return impact;
+    }
+}
+/**
+ * WebSocket impact analysis strategy.
+ */
+export class WebSocketImpactStrategy {
+    analyze(change) {
+        const impact = {
+            backwardCompatibility: "unknown",
+            clientImpact: "none",
+            serverImpact: "none",
+            migrationComplexity: "none",
+        };
+        // Channel removal is breaking
+        if (change.description === "Item removed" &&
+            change.kind?.includes("channel.removed")) {
+            impact.backwardCompatibility = "incompatible";
+            impact.clientImpact = "high";
+            impact.serverImpact = "medium";
+            impact.migrationComplexity = "complex";
+        }
+        // Channel addition is non-breaking
+        if (change.description === "Item added" &&
+            change.kind?.includes("channel.added")) {
+            impact.backwardCompatibility = "compatible";
+            impact.clientImpact = "none";
+            impact.serverImpact = "low";
+            impact.migrationComplexity = "none";
+        }
+        // Message removal is breaking
+        if (change.description === "Item removed" &&
+            change.kind?.includes("message.removed")) {
+            impact.backwardCompatibility = "incompatible";
+            impact.clientImpact = "medium";
+            impact.serverImpact = "low";
+            impact.migrationComplexity = "moderate";
+        }
+        // Message addition is non-breaking
+        if (change.description === "Item added" &&
+            change.kind?.includes("message.added")) {
+            impact.backwardCompatibility = "compatible";
+            impact.clientImpact = "none";
+            impact.serverImpact = "low";
+            impact.migrationComplexity = "none";
+        }
+        // Message schema change is breaking
+        if (change.path.includes("/schemaRef") &&
+            change.description === "Value changed") {
+            impact.backwardCompatibility = "incompatible";
+            impact.clientImpact = "medium";
+            impact.serverImpact = "low";
+            impact.migrationComplexity = "moderate";
+        }
+        return impact;
+    }
+}
+/**
+ * Default impact analysis strategy for unknown changes.
+ */
+export class DefaultImpactStrategy {
+    analyze(_change) {
+        return {
+            backwardCompatibility: "unknown",
+            clientImpact: "none",
+            serverImpact: "none",
+            migrationComplexity: "none",
+        };
+    }
+}
+/**
+ * Factory for creating impact analysis strategies.
+ */
+const ImpactAnalysisStrategyFactory = {
+    strategies: new Map([
+        ["rest", new RestRouteImpactStrategy()],
+        ["graphql", new GraphQLOperationImpactStrategy()],
+        ["websocket", new WebSocketImpactStrategy()],
+    ]),
+    getStrategy(protocol) {
+        if (!protocol) {
+            return new DefaultImpactStrategy();
+        }
+        const strategy = this.strategies.get(protocol);
+        return strategy || new DefaultImpactStrategy();
+    },
+    registerStrategy(protocol, strategy) {
+        this.strategies.set(protocol, strategy);
+    },
+};
+export { ImpactAnalysisStrategyFactory };

package/dist/src/diff/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./change-reports.js";
+export * from "./core.js";
+export * from "./enhanced-diff.js";
+export * from "./impact-strategies-refactored.js";
+export * from "./metrics-calculator.js";
+export * from "./risk-calculator.js";
+export * from "./suggestion-generator.js";
+export * from "./types.js";

package/dist/src/diff/index.js

@@ -0,0 +1,11 @@
+// Export types
+export * from "./change-reports.js";
+// Export core functionality
+export * from "./core.js";
+// Export enhanced functionality
+export * from "./enhanced-diff.js";
+export * from "./impact-strategies-refactored.js";
+export * from "./metrics-calculator.js";
+export * from "./risk-calculator.js";
+export * from "./suggestion-generator.js";
+export * from "./types.js";

package/dist/src/diff/metrics-calculator.d.ts

@@ -0,0 +1,23 @@
+import type { EnhancedUniSpecChange } from "./enhanced-diff.js";
+/**
+ * Service for calculating compatibility metrics from enhanced changes.
+ */
+export declare class MetricsCalculatorService {
+    /**
+     * Calculate compatibility metrics from enhanced changes.
+     */
+    calculateMetrics(changes: EnhancedUniSpecChange[]): {
+        overallCompatibility: number;
+        breakingChangesCount: number;
+        nonBreakingChangesCount: number;
+        clientCompatibilityScore: number;
+        serverCompatibilityScore: number;
+        migrationEffort: "moderate" | "minimal" | "significant" | "major";
+    };
+    private filterBreakingChanges;
+    private filterNonBreakingChanges;
+    private calculateBreakingScore;
+    private calculateClientCompatibilityScore;
+    private calculateServerCompatibilityScore;
+    private determineMigrationEffort;
+}

package/dist/src/diff/metrics-calculator.js

@@ -0,0 +1,65 @@
+/**
+ * Service for calculating compatibility metrics from enhanced changes.
+ */
+export class MetricsCalculatorService {
+    /**
+     * Calculate compatibility metrics from enhanced changes.
+     */
+    calculateMetrics(changes) {
+        const breakingChanges = this.filterBreakingChanges(changes);
+        const nonBreakingChanges = this.filterNonBreakingChanges(changes);
+        const totalChanges = changes.length;
+        const breakingScore = this.calculateBreakingScore(breakingChanges.length, totalChanges);
+        const overallCompatibility = Math.max(0, 100 - breakingScore);
+        const clientScore = this.calculateClientCompatibilityScore(changes);
+        const serverScore = this.calculateServerCompatibilityScore(changes);
+        const migrationEffort = this.determineMigrationEffort(breakingChanges, nonBreakingChanges);
+        return {
+            overallCompatibility: Math.round(overallCompatibility),
+            breakingChangesCount: breakingChanges.length,
+            nonBreakingChangesCount: nonBreakingChanges.length,
+            clientCompatibilityScore: Math.round(clientScore),
+            serverCompatibilityScore: Math.round(serverScore),
+            migrationEffort,
+        };
+    }
+    filterBreakingChanges(changes) {
+        return changes.filter((c) => c.impact.backwardCompatibility === "incompatible");
+    }
+    filterNonBreakingChanges(changes) {
+        return changes.filter((c) => c.impact.backwardCompatibility === "compatible");
+    }
+    calculateBreakingScore(breakingCount, totalChanges) {
+        return totalChanges > 0 ? (breakingCount / totalChanges) * 100 : 0;
+    }
+    calculateClientCompatibilityScore(changes) {
+        const totalChanges = changes.length;
+        if (totalChanges === 0)
+            return 100;
+        const highClientImpact = changes.filter((c) => c.impact.clientImpact === "high").length;
+        const mediumClientImpact = changes.filter((c) => c.impact.clientImpact === "medium").length;
+        return (100 - (highClientImpact * 50 + mediumClientImpact * 25) / totalChanges);
+    }
+    calculateServerCompatibilityScore(changes) {
+        const totalChanges = changes.length;
+        if (totalChanges === 0)
+            return 100;
+        const highServerImpact = changes.filter((c) => c.impact.serverImpact === "high").length;
+        const mediumServerImpact = changes.filter((c) => c.impact.serverImpact === "medium").length;
+        return (100 - (highServerImpact * 30 + mediumServerImpact * 15) / totalChanges);
+    }
+    determineMigrationEffort(breakingChanges, _nonBreakingChanges) {
+        const complexMigrations = breakingChanges.filter((c) => c.impact.migrationComplexity === "complex").length;
+        const moderateMigrations = breakingChanges.filter((c) => c.impact.migrationComplexity === "moderate").length;
+        if (complexMigrations > 0) {
+            return "major";
+        }
+        else if (moderateMigrations > 2) {
+            return "significant";
+        }
+        else if (moderateMigrations > 0 || breakingChanges.length > 3) {
+            return "moderate";
+        }
+        return "minimal";
+    }
+}

package/dist/src/diff/risk-calculator.d.ts

@@ -0,0 +1,23 @@
+import type { ChangeImpact } from "./enhanced-diff.js";
+export type RiskLevel = "low" | "medium" | "high" | "critical";
+/**
+ * Calculator for determining risk levels based on change impact.
+ */
+export declare const RiskLevelCalculator: {
+    /**
+     * Calculate risk level based on impact.
+     */
+    calculate(impact: ChangeImpact): RiskLevel;
+    /**
+     * Get risk level weight for sorting.
+     */
+    getWeight(riskLevel: RiskLevel): number;
+    /**
+     * Check if risk level requires immediate attention.
+     */
+    requiresImmediateAttention(riskLevel: RiskLevel): boolean;
+    /**
+     * Get risk level description.
+     */
+    getDescription(riskLevel: RiskLevel): string;
+};