@decaf-ts/decorator-validation/lib/esm/validation/Validators/Validator.d.ts

simple decorator based validation engine

import { ValidatorOptions } from "../types";
import type { PathProxy } from "../../utils";
import { BaseValidator } from "./BaseValidator";
/**
 * @description
 * Abstract class for defining synchronous validators.
 *
 * This class extends the base {@link BaseValidator} and enforces that any implementation of `hasErrors` must be synchronous.
 *
 * Use this when the validation process is immediate and does not require asynchronous operations.
 *
 * @example
 * ```typescript
 * // Example of a synchronous validator that checks if a number is greater than
 * class GreaterThanValidator extends Validator<{ gt?: number }> {
 *   constructor(message: string = "Value must be greater than {0}") {
 *     super(message);
 *   }
 *
 *   hasErrors(value: number, options?: { gt?: number }) {
 *     const minValue = options?.gt ?? 0;
 *     if (value <= minValue) {
 *       return this.getMessage();
 *     }
 *     return undefined;
 *   }
 * }
 *
 * // Example usage:
 * const validator = new GreaterThanValidator();
 * const error = validator.hasErrors(10, { gt: 15 });
 * if (error) {
 *   console.log('Value must be greater than 15')
 * } else {
 *   console.log('Value is valid');
 * }
 * ```
 *
 * - If `value` is less than or equal to `gt`, returns the error message.
 * - Otherwise, returns `undefined` indicating validation success.
 *
 * @see {@link BaseValidator} For the base validator.
 * @see {@link ValidatorOptions} For the base validator options.
 */
export declare abstract class Validator<V extends ValidatorOptions = ValidatorOptions> extends BaseValidator<V, false> {
    protected constructor(message?: string, ...acceptedTypes: string[]);
    /**
     * @description Validates a value against specific validation rules
     * @summary Abstract method that must be implemented by all validator subclasses.
     * This method contains the core validation logic that determines whether a value
     * is valid according to the specific rules of the validator. If the value is valid,
     * the method returns undefined; otherwise, it returns an error message.
     *
     * @template V - Type of the options object that can be passed to the validator
     * @param {any} value - The value to validate
     * @param {V} [options] - Optional configuration options for customizing validation behavior
     * @param {PathProxy<any>} proxy -
     * @return {string | undefined} Error message if validation fails, undefined if validation passes
     *
     * @abstract
     *
     * @see Model#validate
     */
    abstract hasErrors(value: any, options?: V, proxy?: PathProxy<any>): string | undefined;
}