@syntropysoft/praetorian/dist/application/validation/ValidationEngine.d.ts

Praetorian CLI – A universal multi-environment configuration validator for DevSecOps teams. Validate, compare, and secure YAML/ENV files with ease.

/**
 * @file src/application/validation/ValidationEngine.ts
 * @description Pure functional validation engine for Praetorian
 */
import { PraetorianRule } from '../../shared/types/rules';
import { ValidationError, ValidationWarning } from '../../shared/types';
/**
 * @interface ValidationInput
 * @description Input for the validation engine
 */
export interface ValidationInput {
    /** Configuration data to validate */
    data: any;
    /** Rules to apply */
    rules: PraetorianRule[];
    /** Context information */
    context?: {
        filePath?: string;
        environment?: string;
        [key: string]: any;
    };
}
/**
 * @interface ValidationOutput
 * @description Output from the validation engine
 */
export interface ValidationOutput {
    /** Overall validation result */
    valid: boolean;
    /** Errors found */
    errors: ValidationError[];
    /** Warnings found */
    warnings: ValidationWarning[];
    /** Metadata about the validation */
    metadata: {
        rulesApplied: number;
        rulesPassed: number;
        rulesFailed: number;
        duration: number;
    };
}
/**
 * @interface RuleValidationResult
 * @description Result of validating a single rule
 */
export interface RuleValidationResult {
    ruleId: string;
    passed: boolean;
    errors: ValidationError[];
    warnings: ValidationWarning[];
}
/**
 * Pure functional validation engine
 * @param input - Validation input
 * @returns Validation output
 */
export declare const validate: (input: ValidationInput) => ValidationOutput;
/**
 * Validates a single rule against data
 * @param rule - Rule to apply
 * @param data - Data to validate
 * @param context - Validation context
 * @returns Rule validation result
 */
export declare const validateRule: (rule: PraetorianRule, data: any, context?: any) => RuleValidationResult;
/**
 * Applies a rule based on its type
 * @param rule - Rule to apply
 * @param data - Data to validate
 * @param context - Validation context
 * @returns Rule application result
 */
export declare const applyRuleByType: (rule: PraetorianRule, data: any, context?: any) => {
    errors: ValidationError[];
    warnings: ValidationWarning[];
};
/**
 * Validates structure rules
 * @param rule - Structure rule
 * @param data - Data to validate
 * @returns Validation result
 */
export declare const validateStructureRule: (rule: any, // StructureRule
data: any) => {
    errors: ValidationError[];
    warnings: ValidationWarning[];
};
/**
 * Validates format rules
 * @param rule - Format rule
 * @param data - Data to validate
 * @returns Validation result
 */
export declare const validateFormatRule: (rule: any, // FormatRule
data: any) => {
    errors: ValidationError[];
    warnings: ValidationWarning[];
};
/**
 * Validates security rules
 * @param rule - Security rule
 * @param data - Data to validate
 * @param context - Validation context
 * @returns Validation result
 */
export declare const validateSecurityRule: (rule: any, // SecurityRule
data: any, context?: any) => {
    errors: ValidationError[];
    warnings: ValidationWarning[];
};
/**
 * Validates schema rules
 * @param rule - Schema rule
 * @param data - Data to validate
 * @returns Validation result
 */
export declare const validateSchemaRule: (rule: any, // SchemaRule
data: any) => {
    errors: ValidationError[];
    warnings: ValidationWarning[];
};
/**
 * Creates an empty validation output
 */
export declare const createEmptyValidationOutput: () => ValidationOutput;
/**
 * Creates a passed rule result
 */
export declare const createPassedRuleResult: (ruleId: string) => RuleValidationResult;
/**
 * Creates a failed rule result
 */
export declare const createFailedRuleResult: (ruleId: string, errors: ValidationError[]) => RuleValidationResult;
/**
 * Creates a validation error or warning based on severity
 */
export declare const createValidationError: (ruleId: string, code: string, message: string, severity: string) => ValidationError;
/**
 * Creates a validation warning
 */
export declare const createValidationWarning: (ruleId: string, code: string, message: string) => ValidationWarning;
/**
 * Checks if an object has a property (supports dot notation)
 */
export declare const hasProperty: (obj: any, path: string) => boolean;
/**
 * Gets a nested value from an object (supports dot notation)
 */
export declare const getNestedValue: (obj: any, path: string) => any;
/**
 * Calculates the depth of an object
 */
export declare const calculateObjectDepth: (obj: any, currentDepth?: number) => number;
/**
 * Validates a value against a format
 */
export declare const validateFormat: (value: any, format: string) => boolean;
/**
 * Validates a value against a regex pattern
 */
export declare const validatePattern: (value: any, pattern: string) => boolean;
/**
 * Validates data against a JSON schema (simplified)
 */
export declare const validateAgainstSchema: (data: any, schema: any) => string[];
export declare const validateSecretDetection: (rule: any, data: any) => {
    errors: never[];
    warnings: never[];
};
export declare const validatePermissions: (rule: any, context: any) => {
    errors: never[];
    warnings: never[];
};
export declare const validateVulnerabilities: (rule: any, data: any) => {
    errors: never[];
    warnings: never[];
};
export declare const validateCompliance: (rule: any, data: any) => {
    errors: never[];
    warnings: never[];
};
//# sourceMappingURL=ValidationEngine.d.ts.map