@umbrelladocs/rdformat-validator/dist/validator/index.d.ts

Validate and fix Reviewdog Diagnostic Format (RD Format) - A comprehensive library and CLI tool for validating JSON data against the Reviewdog Diagnostic Format specification

/**
 * Core validator module for RDFormat validation
 */
import { JSONSchema } from '../types/schema';
import { ValidationOptions, ValidationResult, ValidationError, ValidationWarning } from '../types/validation';
/**
 * Error codes for different types of validation failures
 */
export declare enum ValidationErrorCode {
    NULL_INPUT = "NULL_INPUT",
    EMPTY_INPUT = "EMPTY_INPUT",
    INVALID_JSON = "INVALID_JSON",
    TYPE_MISMATCH = "TYPE_MISMATCH",
    ONEOF_VALIDATION_FAILED = "ONEOF_VALIDATION_FAILED",
    ENUM_VALIDATION_FAILED = "ENUM_VALIDATION_FAILED",
    MIN_LENGTH_VIOLATION = "MIN_LENGTH_VIOLATION",
    MAX_LENGTH_VIOLATION = "MAX_LENGTH_VIOLATION",
    PATTERN_MISMATCH = "PATTERN_MISMATCH",
    EMPTY_STRING = "EMPTY_STRING",
    MIN_VALUE_VIOLATION = "MIN_VALUE_VIOLATION",
    MAX_VALUE_VIOLATION = "MAX_VALUE_VIOLATION",
    INVALID_NUMBER = "INVALID_NUMBER",
    REQUIRED_PROPERTY_MISSING = "REQUIRED_PROPERTY_MISSING",
    UNKNOWN_PROPERTY = "UNKNOWN_PROPERTY",
    INVALID_OBJECT_STRUCTURE = "INVALID_OBJECT_STRUCTURE",
    INVALID_ARRAY_ITEM = "INVALID_ARRAY_ITEM",
    EMPTY_ARRAY = "EMPTY_ARRAY",
    INVALID_SEVERITY = "INVALID_SEVERITY",
    INVALID_LOCATION = "INVALID_LOCATION",
    INVALID_RANGE = "INVALID_RANGE",
    INVALID_POSITION = "INVALID_POSITION",
    MISSING_DIAGNOSTIC_MESSAGE = "MISSING_DIAGNOSTIC_MESSAGE",
    MISSING_DIAGNOSTIC_LOCATION = "MISSING_DIAGNOSTIC_LOCATION"
}
/**
 * Enhanced error reporter for detailed validation feedback
 */
export declare class ErrorReporter {
    private strictMode;
    constructor(strictMode?: boolean);
    /**
     * Creates a detailed validation error with context
     */
    createError(path: string, code: ValidationErrorCode, value: any, context?: {
        expected?: string;
        constraint?: string | number;
        suggestion?: string;
    }): ValidationError;
    /**
     * Creates a validation warning
     */
    createWarning(path: string, code: ValidationErrorCode, message?: string): ValidationWarning;
    /**
     * Gets a human-readable error message based on the error code
     */
    private getErrorMessage;
    /**
     * Gets a human-readable warning message
     */
    private getWarningMessage;
}
export declare class Validator {
    private options;
    private schema;
    private errorReporter;
    constructor(options?: ValidationOptions);
    /**
     * Validates data against the RDFormat schema
     */
    validate(data: any): ValidationResult;
    /**
     * Performs additional edge case validation specific to RDFormat
     */
    private performEdgeCaseValidation;
    /**
     * Checks if an object appears to be a partial diagnostic
     */
    private isPartialDiagnostic;
    /**
     * Checks if an object appears to be a diagnostic result
     */
    private isDiagnosticResult;
    /**
     * Validates partial diagnostic objects and provides helpful error messages
     */
    private validatePartialDiagnostic;
    /**
     * Validates diagnostic result structure
     */
    private validateDiagnosticResult;
    /**
     * Validates location structure for common issues
     */
    private validateLocationStructure;
    /**
     * Validates range structure for common issues
     */
    private validateRangeStructure;
    /**
     * Validates position structure for common issues
     */
    private validatePositionStructure;
    /**
     * Validates a specific field at a given path
     */
    validateField(path: string, value: any, schema: JSONSchema): ValidationResult;
    /**
     * Internal method to validate a value against a schema
     */
    private validateValue;
    /**
     * Validates an object against an object schema
     */
    private validateObject;
    /**
     * Validates an array against an array schema
     */
    private validateArray;
    /**
     * Validates the type of a value
     */
    private validateType;
    /**
     * Joins path segments for error reporting
     */
    private joinPath;
    /**
     * Adds RDFormat-specific validation for better error messages
     */
    private addRDFormatSpecificValidation;
    /**
     * Adds location-specific validation for better error messages
     */
    private addLocationSpecificValidation;
    /**
     * Adds position-specific validation for better error messages
     */
    private addPositionSpecificValidation;
    /**
     * Updates validation options
     */
    setOptions(options: ValidationOptions): void;
    /**
     * Gets the current schema
     */
    getSchema(): JSONSchema;
    /**
     * Sorts schemas by likelihood of matching the input value
     */
    private sortSchemasByLikelihood;
    /**
     * Calculates a likelihood score for how well a schema might match a value
     */
    private getSchemaLikelihoodScore;
    /**
     * Calculates how well a schema matches based on validation errors
     */
    private calculateSchemaMatchScore;
}
export declare function validate(data: any, options?: ValidationOptions): ValidationResult;
export declare function validateField(path: string, value: any, schema: JSONSchema, options?: ValidationOptions): ValidationResult;
//# sourceMappingURL=index.d.ts.map