fluent-ts-validator/dist/validation/ValidationRule.d.ts

A fluent validator written in TypeScript

import { Severity, ValidationFailure } from "../shared";
import { PropertyValidator } from "../validators/PropertyValidator";
import { RuleApplicationOutcome } from "./RuleApplicationOutcome";
import { ValidationCondition } from "./ValidationCondition";
export declare class ValidationRule<T, TProperty> {
    lambdaExpression: (input: T) => TProperty | undefined;
    protected validators: PropertyValidator<TProperty>[];
    protected propertyName: string;
    protected errorCode: string;
    protected errorMessage: string;
    protected severity: Severity;
    protected conditions: ValidationCondition<T>[];
    protected callback: (failure: ValidationFailure) => void;
    constructor(lambdaExpression: (input: T) => TProperty | undefined);
    setPropertyName(propertyName: string): void;
    addValidator(validator: PropertyValidator<TProperty>): void;
    setErrorCode(errorCode: string): void;
    setErrorMessage(errorMessage: string): void;
    setSeverity(severity: Severity): void;
    addCondition(condition: ValidationCondition<T>): void;
    onFailure(callback: (failure: ValidationFailure) => void): void;
    apply(input: T): RuleApplicationOutcome;
    protected lambdaExpressionResultWith(input: T): TProperty | undefined;
    protected isValid(input: T, propertyValue: TProperty | undefined): boolean;
    protected isNoValidationRequired(input: T): boolean;
    private isValidationRequired(input);
    private allValidatorsAreValid(propertyValue);
    protected createValidationFailure(input: T, propertyValue: TProperty | undefined): ValidationFailure;
    protected invokeCallbackWith(failure: ValidationFailure): void;
}