timonel 3.0.0 → 3.1.0

package/dist/lib/policy/configurationLoader.js

@@ -0,0 +1,251 @@
+import { createLogger } from '../utils/logger.js';
+import { PluginConfigurationError } from './errors.js';
+const DEFAULT_LOADER_OPTIONS = {
+    defaultEnvironment: 'development',
+    validateSchemas: true,
+    allowUnknownProperties: false,
+    configurationFiles: [],
+    environmentPrefix: 'TIMONEL_POLICY',
+};
+const CONFIGURATION_PRIORITIES = {
+    default: 0,
+    file: 10,
+    environment: 20,
+    inline: 30,
+};
+export class ConfigurationLoader {
+    constructor(options = {}) {
+        this.configurations = new Map();
+        this.environmentConfigs = new Map();
+        this.options = { ...DEFAULT_LOADER_OPTIONS, ...options };
+        this.logger = createLogger('policy-config-loader');
+        this.logger.debug('ConfigurationLoader initialized', {
+            options: this.options,
+            operation: 'config_loader_init',
+        });
+    }
+    async loadPluginConfiguration(plugin, environment, inlineConfig) {
+        const targetEnvironment = environment || this.options.defaultEnvironment;
+        this.logger.debug('Loading plugin configuration', {
+            pluginName: plugin.name,
+            environment: targetEnvironment,
+            hasInlineConfig: inlineConfig !== undefined,
+            operation: 'load_plugin_config',
+        });
+        const entries = await this.collectConfigurationEntries(plugin, targetEnvironment, inlineConfig);
+        const mergedConfig = this.mergeConfigurations(entries);
+        const validationResult = this.validatePluginConfiguration(plugin, mergedConfig);
+        const result = {
+            pluginName: plugin.name,
+            config: mergedConfig,
+            entries,
+            validated: validationResult.validated,
+            ...(validationResult.validationErrors && {
+                validationErrors: validationResult.validationErrors,
+            }),
+        };
+        this.logger.info('Plugin configuration loaded', {
+            pluginName: plugin.name,
+            environment: targetEnvironment,
+            entryCount: entries.length,
+            validated: validationResult.validated,
+            hasErrors: validationResult.validationErrors !== undefined,
+            operation: 'plugin_config_loaded',
+        });
+        return result;
+    }
+    async collectConfigurationEntries(plugin, targetEnvironment, inlineConfig) {
+        const entries = [];
+        if (plugin.metadata?.defaultConfig) {
+            entries.push({
+                value: plugin.metadata.defaultConfig,
+                source: 'default',
+                priority: CONFIGURATION_PRIORITIES.default,
+                ...(plugin.configSchema && { schema: plugin.configSchema }),
+            });
+        }
+        const fileConfig = await this.loadFileConfiguration(plugin.name, targetEnvironment);
+        if (fileConfig) {
+            entries.push({
+                value: fileConfig,
+                source: 'file',
+                environment: targetEnvironment,
+                priority: CONFIGURATION_PRIORITIES.file,
+                ...(plugin.configSchema && { schema: plugin.configSchema }),
+            });
+        }
+        const envConfig = this.loadEnvironmentVariableConfiguration(plugin.name);
+        if (envConfig) {
+            entries.push({
+                value: envConfig,
+                source: 'environment',
+                priority: CONFIGURATION_PRIORITIES.environment,
+                ...(plugin.configSchema && { schema: plugin.configSchema }),
+            });
+        }
+        if (inlineConfig) {
+            entries.push({
+                value: inlineConfig,
+                source: 'inline',
+                priority: CONFIGURATION_PRIORITIES.inline,
+                ...(plugin.configSchema && { schema: plugin.configSchema }),
+            });
+        }
+        return entries;
+    }
+    validatePluginConfiguration(plugin, mergedConfig) {
+        let validated = false;
+        let validationErrors;
+        if (this.options.validateSchemas && plugin.configSchema) {
+            try {
+                this.validateConfiguration(mergedConfig, plugin.configSchema, plugin.name);
+                validated = true;
+            }
+            catch (error) {
+                validationErrors = [error instanceof Error ? error.message : String(error)];
+                this.logger.warn('Plugin configuration validation failed', {
+                    pluginName: plugin.name,
+                    errors: validationErrors,
+                    operation: 'config_validation_failed',
+                });
+            }
+        }
+        return { validated, ...(validationErrors && { validationErrors }) };
+    }
+    async loadEnvironmentConfiguration(environment) {
+        if (this.environmentConfigs.has(environment)) {
+            return this.environmentConfigs.get(environment);
+        }
+        this.logger.debug('Loading environment configuration', {
+            environment,
+            operation: 'load_env_config',
+        });
+        const envConfig = await this.loadEnvironmentFromFiles(environment);
+        if (envConfig) {
+            this.environmentConfigs.set(environment, envConfig);
+            this.logger.info('Environment configuration loaded', {
+                environment,
+                pluginCount: Object.keys(envConfig.plugins).length,
+                hasGlobal: envConfig.global !== undefined,
+                operation: 'env_config_loaded',
+            });
+        }
+        return envConfig;
+    }
+    validateConfiguration(config, schema, pluginName) {
+        try {
+            this.validateAgainstSchema(config, schema, []);
+        }
+        catch (error) {
+            throw new PluginConfigurationError(`Configuration validation failed for plugin '${pluginName}': ${error instanceof Error ? error.message : String(error)}`, pluginName, undefined, { config, schema, validationError: error });
+        }
+    }
+    addConfigurationEntry(pluginName, entry) {
+        if (!this.configurations.has(pluginName)) {
+            this.configurations.set(pluginName, []);
+        }
+        const entries = this.configurations.get(pluginName);
+        entries.push(entry);
+        entries.sort((a, b) => b.priority - a.priority);
+        this.logger.debug('Configuration entry added', {
+            pluginName,
+            source: entry.source,
+            priority: entry.priority,
+            operation: 'config_entry_added',
+        });
+    }
+    getConfigurationEntries(pluginName) {
+        return this.configurations.get(pluginName) || [];
+    }
+    clearCache() {
+        this.configurations.clear();
+        this.environmentConfigs.clear();
+        this.logger.debug('Configuration cache cleared', {
+            operation: 'config_cache_cleared',
+        });
+    }
+    async loadFileConfiguration(_pluginName, _environment) {
+        return undefined;
+    }
+    loadEnvironmentVariableConfiguration(pluginName) {
+        if (!pluginName) {
+            return undefined;
+        }
+        const prefix = `${this.options.environmentPrefix}_${pluginName.toUpperCase().replace(/[^A-Z0-9]/g, '_')}`;
+        const config = Object.create(null);
+        let hasConfig = false;
+        for (const [key, value] of Object.entries(process.env)) {
+            if (key.startsWith(prefix + '_')) {
+                const configKey = key.substring(prefix.length + 1).toLowerCase();
+                config[configKey] = this.parseEnvironmentValue(value);
+                hasConfig = true;
+            }
+        }
+        return hasConfig ? config : undefined;
+    }
+    async loadEnvironmentFromFiles(_environment) {
+        return undefined;
+    }
+    mergeConfigurations(entries) {
+        const sortedEntries = [...entries].sort((a, b) => a.priority - b.priority);
+        let merged = {};
+        for (const entry of sortedEntries) {
+            if (entry.value && typeof entry.value === 'object' && !Array.isArray(entry.value)) {
+                merged = { ...merged, ...entry.value };
+            }
+        }
+        return merged;
+    }
+    parseEnvironmentValue(value) {
+        if (!value)
+            return undefined;
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    validateAgainstSchema(config, schema, path) {
+        this.validateBasicType(config, schema, path);
+        this.validateObjectProperties(config, schema, path);
+    }
+    validateBasicType(config, schema, path) {
+        if (schema.type) {
+            const actualType = Array.isArray(config) ? 'array' : typeof config;
+            if (actualType !== schema.type) {
+                throw new Error(`Expected ${schema.type} at ${path.join('.')}, got ${actualType}`);
+            }
+        }
+    }
+    validateObjectProperties(config, schema, path) {
+        if (schema.type === 'object' &&
+            schema.properties &&
+            typeof config === 'object' &&
+            config !== null) {
+            const configObj = config;
+            this.validateRequiredProperties(configObj, schema, path);
+            this.validateEachProperty(configObj, schema, path);
+        }
+    }
+    validateRequiredProperties(configObj, schema, path) {
+        if (schema.required) {
+            for (const requiredProp of schema.required) {
+                if (!(requiredProp in configObj)) {
+                    throw new Error(`Missing required property '${requiredProp}' at ${path.join('.')}`);
+                }
+            }
+        }
+    }
+    validateEachProperty(configObj, schema, path) {
+        for (const [propName, propValue] of Object.entries(configObj)) {
+            const propSchema = schema.properties?.[propName];
+            if (propSchema) {
+                this.validateAgainstSchema(propValue, propSchema, [...path, propName]);
+            }
+            else if (!this.options.allowUnknownProperties && !schema.additionalProperties) {
+                throw new Error(`Unknown property '${propName}' at ${path.join('.')}`);
+            }
+        }
+    }
+}

package/dist/lib/policy/errorContextGenerator.d.ts

@@ -0,0 +1,63 @@
+import type { PolicyViolation, PolicyWarning, ValidationContext } from './types.js';
+export interface ErrorContext {
+    readonly timestamp: string;
+    readonly environment: {
+        readonly nodeVersion: string;
+        readonly platform: string;
+        readonly arch: string;
+        readonly timonelVersion?: string;
+    };
+    readonly validationContext: {
+        readonly chartName?: string;
+        readonly chartVersion?: string;
+        readonly kubernetesVersion?: string;
+        readonly environment?: string;
+    };
+    readonly plugin: {
+        readonly name: string;
+        readonly version?: string;
+        readonly executionTime?: number;
+    };
+    readonly error: {
+        readonly message: string;
+        readonly severity: 'error' | 'warning' | 'info';
+        readonly resourcePath?: string;
+        readonly field?: string;
+        readonly suggestion?: string;
+        readonly stackTrace?: string;
+        readonly originalContext?: Record<string, unknown>;
+    };
+    readonly debuggingHints: string[];
+    readonly relatedViolations?: Array<{
+        readonly plugin: string;
+        readonly message: string;
+        readonly similarity: number;
+    }>;
+}
+export declare class ErrorContextGenerator {
+    generateContext(violation: PolicyViolation | PolicyWarning, validationContext?: ValidationContext, allViolations?: (PolicyViolation | PolicyWarning)[], executionTime?: number): ErrorContext;
+    generateErrorReport(violation: PolicyViolation | PolicyWarning, validationContext?: ValidationContext, allViolations?: (PolicyViolation | PolicyWarning)[], executionTime?: number): string;
+    private addReportHeader;
+    private addBasicInformation;
+    private addResourceInformation;
+    private addSuggestion;
+    private addEnvironmentInfo;
+    private addValidationContextInfo;
+    private addDebuggingHints;
+    private addRelatedViolations;
+    private addOriginalContext;
+    private getEnvironmentInfo;
+    private getTimonelVersion;
+    private getValidationContextInfo;
+    private generateDebuggingHints;
+    private addSeverityHints;
+    private addResourcePathHints;
+    private addFieldHints;
+    private addPluginHints;
+    private addEnvironmentHints;
+    private addKubernetesVersionHints;
+    private findRelatedViolations;
+    private calculateSimilarity;
+    private calculateStringSimilarity;
+    private calculateLevenshteinDistance;
+}

package/dist/lib/policy/errorContextGenerator.js

@@ -0,0 +1,302 @@
+export class ErrorContextGenerator {
+    generateContext(violation, validationContext, allViolations, executionTime) {
+        return {
+            timestamp: new Date().toISOString(),
+            environment: this.getEnvironmentInfo(),
+            validationContext: this.getValidationContextInfo(validationContext),
+            plugin: {
+                name: violation.plugin,
+                ...(executionTime !== undefined && { executionTime }),
+            },
+            error: {
+                message: violation.message,
+                severity: violation.severity,
+                ...(violation.resourcePath && { resourcePath: violation.resourcePath }),
+                ...(violation.field && { field: violation.field }),
+                ...(violation.suggestion && { suggestion: violation.suggestion }),
+                ...(violation.context && { originalContext: violation.context }),
+            },
+            debuggingHints: this.generateDebuggingHints(violation, validationContext),
+            relatedViolations: this.findRelatedViolations(violation, allViolations),
+        };
+    }
+    generateErrorReport(violation, validationContext, allViolations, executionTime) {
+        const context = this.generateContext(violation, validationContext, allViolations, executionTime);
+        const lines = [];
+        this.addReportHeader(lines, violation);
+        this.addBasicInformation(lines, context);
+        this.addResourceInformation(lines, context);
+        this.addSuggestion(lines, context);
+        this.addEnvironmentInfo(lines, context);
+        this.addValidationContextInfo(lines, context);
+        this.addDebuggingHints(lines, context);
+        this.addRelatedViolations(lines, context);
+        this.addOriginalContext(lines, context);
+        return lines.join('\n');
+    }
+    addReportHeader(lines, violation) {
+        lines.push('='.repeat(80));
+        lines.push(`Policy Violation Report - ${violation.severity.toUpperCase()}`);
+        lines.push('='.repeat(80));
+        lines.push('');
+    }
+    addBasicInformation(lines, context) {
+        lines.push('Basic Information:');
+        lines.push(`  Plugin:    ${context.plugin.name}`);
+        lines.push(`  Severity:  ${context.error.severity}`);
+        lines.push(`  Message:   ${context.error.message}`);
+        lines.push(`  Timestamp: ${context.timestamp}`);
+        if (context.plugin.executionTime !== undefined) {
+            lines.push(`  Exec Time: ${context.plugin.executionTime}ms`);
+        }
+        lines.push('');
+    }
+    addResourceInformation(lines, context) {
+        if (context.error.resourcePath || context.error.field) {
+            lines.push('Resource Information:');
+            if (context.error.resourcePath) {
+                lines.push(`  Path:  ${context.error.resourcePath}`);
+            }
+            if (context.error.field) {
+                lines.push(`  Field: ${context.error.field}`);
+            }
+            lines.push('');
+        }
+    }
+    addSuggestion(lines, context) {
+        if (context.error.suggestion) {
+            lines.push('Suggested Fix:');
+            lines.push(`  ${context.error.suggestion}`);
+            lines.push('');
+        }
+    }
+    addEnvironmentInfo(lines, context) {
+        lines.push('Environment:');
+        lines.push(`  Node.js:   ${context.environment.nodeVersion}`);
+        lines.push(`  Platform:  ${context.environment.platform} (${context.environment.arch})`);
+        if (context.environment.timonelVersion) {
+            lines.push(`  Timonel:   ${context.environment.timonelVersion}`);
+        }
+        lines.push('');
+    }
+    addValidationContextInfo(lines, context) {
+        const hasValidationContext = context.validationContext.chartName ||
+            context.validationContext.kubernetesVersion ||
+            context.validationContext.environment;
+        if (hasValidationContext) {
+            lines.push('Validation Context:');
+            if (context.validationContext.chartName) {
+                const version = context.validationContext.chartVersion || 'unknown';
+                lines.push(`  Chart:      ${context.validationContext.chartName}@${version}`);
+            }
+            if (context.validationContext.kubernetesVersion) {
+                lines.push(`  Kubernetes: ${context.validationContext.kubernetesVersion}`);
+            }
+            if (context.validationContext.environment) {
+                lines.push(`  Environment: ${context.validationContext.environment}`);
+            }
+            lines.push('');
+        }
+    }
+    addDebuggingHints(lines, context) {
+        if (context.debuggingHints.length > 0) {
+            lines.push('Debugging Hints:');
+            context.debuggingHints.forEach((hint) => {
+                lines.push(`  • ${hint}`);
+            });
+            lines.push('');
+        }
+    }
+    addRelatedViolations(lines, context) {
+        if (context.relatedViolations && context.relatedViolations.length > 0) {
+            lines.push('Related Violations:');
+            for (const related of context.relatedViolations) {
+                lines.push(`  • [${related.plugin}] ${related.message} (${Math.round(related.similarity * 100)}% similar)`);
+            }
+            lines.push('');
+        }
+    }
+    addOriginalContext(lines, context) {
+        if (context.error.originalContext && Object.keys(context.error.originalContext).length > 0) {
+            lines.push('Additional Context:');
+            lines.push(JSON.stringify(context.error.originalContext, null, 2)
+                .split('\n')
+                .map((line) => `  ${line}`)
+                .join('\n'));
+            lines.push('');
+        }
+    }
+    getEnvironmentInfo() {
+        const timonelVersion = this.getTimonelVersion();
+        return {
+            nodeVersion: process.version,
+            platform: process.platform,
+            arch: process.arch,
+            ...(timonelVersion && { timonelVersion }),
+        };
+    }
+    getTimonelVersion() {
+        return '3.0.0';
+    }
+    getValidationContextInfo(validationContext) {
+        return {
+            ...(validationContext?.chart?.name && { chartName: validationContext.chart.name }),
+            ...(validationContext?.chart?.version && { chartVersion: validationContext.chart.version }),
+            ...(validationContext?.kubernetesVersion && {
+                kubernetesVersion: validationContext.kubernetesVersion,
+            }),
+            ...(validationContext?.environment && { environment: validationContext.environment }),
+        };
+    }
+    generateDebuggingHints(violation, validationContext) {
+        const hints = [];
+        this.addSeverityHints(hints, violation);
+        this.addResourcePathHints(hints, violation);
+        this.addFieldHints(hints, violation);
+        this.addPluginHints(hints, violation);
+        this.addEnvironmentHints(hints, validationContext);
+        this.addKubernetesVersionHints(hints, validationContext);
+        return hints;
+    }
+    addSeverityHints(hints, violation) {
+        if (violation.severity === 'error') {
+            hints.push('This error will prevent chart generation. Fix this violation to proceed.');
+        }
+        else if (violation.severity === 'warning') {
+            hints.push("This warning indicates a potential issue but won't block chart generation.");
+        }
+    }
+    addResourcePathHints(hints, violation) {
+        if (!violation.resourcePath)
+            return;
+        if (violation.resourcePath.includes('spec.containers')) {
+            hints.push('This violation is related to container specifications. Check container configuration.');
+        }
+        else if (violation.resourcePath.includes('metadata')) {
+            hints.push('This violation is related to resource metadata. Verify labels, annotations, and names.');
+        }
+        else if (violation.resourcePath.includes('spec.template')) {
+            hints.push('This violation is in a pod template. Check deployment or statefulset configuration.');
+        }
+    }
+    addFieldHints(hints, violation) {
+        if (!violation.field)
+            return;
+        if (violation.field.includes('securityContext')) {
+            hints.push('Security context violations often relate to privilege escalation or root access.');
+        }
+        else if (violation.field.includes('resources')) {
+            hints.push('Resource violations typically involve CPU/memory limits or requests.');
+        }
+        else if (violation.field.includes('image')) {
+            hints.push('Image violations may relate to image tags, registries, or security policies.');
+        }
+    }
+    addPluginHints(hints, violation) {
+        if (violation.plugin.includes('security')) {
+            hints.push('Security violations should be addressed promptly to maintain cluster security.');
+            hints.push("Consider reviewing your organization's security policies and best practices.");
+        }
+        else if (violation.plugin.includes('resource')) {
+            hints.push('Resource violations can impact cluster performance and cost.');
+        }
+        else if (violation.plugin.includes('network')) {
+            hints.push('Network violations may affect service connectivity and security.');
+        }
+    }
+    addEnvironmentHints(hints, validationContext) {
+        if (validationContext?.environment === 'production') {
+            hints.push('This is a production environment - ensure all violations are resolved before deployment.');
+        }
+        else if (validationContext?.environment === 'development') {
+            hints.push('Development environment detected - some violations may be acceptable for testing.');
+        }
+    }
+    addKubernetesVersionHints(hints, validationContext) {
+        if (validationContext?.kubernetesVersion) {
+            const version = validationContext.kubernetesVersion;
+            if (version.startsWith('1.2')) {
+                hints.push('Kubernetes 1.2x detected - ensure compatibility with newer API versions.');
+            }
+        }
+    }
+    findRelatedViolations(violation, allViolations) {
+        if (!allViolations || allViolations.length <= 1) {
+            return [];
+        }
+        const related = [];
+        for (const other of allViolations) {
+            if (other === violation)
+                continue;
+            const similarity = this.calculateSimilarity(violation, other);
+            if (similarity > 0.3) {
+                related.push({
+                    plugin: other.plugin,
+                    message: other.message,
+                    similarity,
+                });
+            }
+        }
+        return related.sort((a, b) => b.similarity - a.similarity).slice(0, 3);
+    }
+    calculateSimilarity(violation1, violation2) {
+        let score = 0;
+        let factors = 0;
+        if (violation1.plugin === violation2.plugin) {
+            score += 0.4;
+        }
+        factors += 0.4;
+        if (violation1.severity === violation2.severity) {
+            score += 0.2;
+        }
+        factors += 0.2;
+        if (violation1.resourcePath && violation2.resourcePath) {
+            const pathSimilarity = this.calculateStringSimilarity(violation1.resourcePath, violation2.resourcePath);
+            score += pathSimilarity * 0.2;
+        }
+        factors += 0.2;
+        if (violation1.field && violation2.field) {
+            const fieldSimilarity = this.calculateStringSimilarity(violation1.field, violation2.field);
+            score += fieldSimilarity * 0.1;
+        }
+        factors += 0.1;
+        const messageSimilarity = this.calculateStringSimilarity(violation1.message, violation2.message);
+        score += messageSimilarity * 0.1;
+        factors += 0.1;
+        return factors > 0 ? score / factors : 0;
+    }
+    calculateStringSimilarity(str1, str2) {
+        if (str1 === str2)
+            return 1;
+        if (str1.length === 0 || str2.length === 0)
+            return 0;
+        const longer = str1.length > str2.length ? str1 : str2;
+        const shorter = str1.length > str2.length ? str2 : str1;
+        if (longer.length === 0)
+            return 1;
+        const editDistance = this.calculateLevenshteinDistance(longer, shorter);
+        return (longer.length - editDistance) / longer.length;
+    }
+    calculateLevenshteinDistance(str1, str2) {
+        const matrix = Array(str2.length + 1)
+            .fill(null)
+            .map(() => Array(str1.length + 1).fill(0));
+        for (let i = 0; i <= str2.length; i++) {
+            matrix[i][0] = i;
+        }
+        for (let j = 0; j <= str1.length; j++) {
+            matrix[0][j] = j;
+        }
+        for (let i = 1; i <= str2.length; i++) {
+            for (let j = 1; j <= str1.length; j++) {
+                if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+                    matrix[i][j] = matrix[i - 1][j - 1];
+                }
+                else {
+                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+                }
+            }
+        }
+        return matrix[str2.length][str1.length];
+    }
+}

package/dist/lib/policy/errors.d.ts

@@ -0,0 +1,40 @@
+export declare class PolicyEngineError extends Error {
+    readonly code?: string | undefined;
+    readonly context?: Record<string, unknown> | undefined;
+    constructor(message: string, code?: string | undefined, context?: Record<string, unknown> | undefined);
+}
+export declare class PluginError extends PolicyEngineError {
+    readonly pluginName: string;
+    constructor(message: string, pluginName: string, context?: Record<string, unknown>);
+}
+export declare class ValidationTimeoutError extends PolicyEngineError {
+    constructor(pluginName: string, timeout: number);
+}
+export declare class PluginRegistrationError extends PolicyEngineError {
+    readonly pluginName?: string | undefined;
+    constructor(message: string, pluginName?: string | undefined, context?: Record<string, unknown>);
+}
+export declare class PluginConfigurationError extends PolicyEngineError {
+    readonly pluginName: string;
+    readonly configPath?: string | undefined;
+    constructor(message: string, pluginName: string, configPath?: string | undefined, context?: Record<string, unknown>);
+}
+export declare class ValidationOrchestrationError extends PolicyEngineError {
+    readonly failedPlugins?: string[] | undefined;
+    constructor(message: string, failedPlugins?: string[] | undefined, context?: Record<string, unknown>);
+}
+export declare class PluginRetryExhaustedError extends PolicyEngineError {
+    readonly pluginName: string;
+    readonly attempts: number;
+    readonly lastError: Error;
+    constructor(message: string, pluginName: string, attempts: number, lastError: Error, context?: Record<string, unknown>);
+}
+export declare class GracefulDegradationError extends PolicyEngineError {
+    readonly degradedPlugins: string[];
+    readonly originalErrors: Error[];
+    constructor(message: string, degradedPlugins: string[], originalErrors: Error[], context?: Record<string, unknown>);
+}
+export declare class PolicyValidationError extends PolicyEngineError {
+    readonly field?: string | undefined;
+    constructor(message: string, field?: string | undefined, context?: Record<string, unknown>);
+}