import { JavaObject } from '../../java/lang/JavaObject';
import { ValidatorFehlerart } from '../../asd/validate/ValidatorFehlerart';
import { ValidatorManager } from '../../asd/validate/ValidatorManager';
import { ValidatorFehler } from '../../asd/validate/ValidatorFehler';
import type { List } from '../../java/util/List';
import { Class } from '../../java/lang/Class';
import { ValidatorKontext } from '../../asd/validate/ValidatorKontext';
import type { BooleanSupplier } from '../../java/util/function/BooleanSupplier';
export declare abstract class Validator extends JavaObject {
    /**
     * Der vom Validator genutzte Kontext
     */
    private readonly _kontext;
    /**
     * Eine Liste von Validatoren, die bei diesem Validator mitgeprüft werden.
     */
    protected readonly _validatoren: List<Validator>;
    /**
     * Eine Liste mit Fehlern bei der Validierung
     */
    private readonly _fehler;
    /**
     * Die stärkste Fehlerart die bei einem Lauf des Validators vorgekommen ist.
     */
    private _fehlerart;
    /**
     * Erstellt einen neuen Validator in dem übegebenen Kontext
     *
     * @param kontext   der Kontext, in dem der Validator ausgeführt wird
     */
    protected constructor(kontext: ValidatorKontext);
    /**
     * Gibt den Kontext des Validators zurück.
     *
     * @return der Kontext des Validators
     */
    kontext(): ValidatorKontext;
    /**
     * Gibt den zugehörigen ValidatorManager zurück.
     *
     * @return der ValidatorManager
     */
    getValidatorManager(): ValidatorManager;
    /**
     * Führt die Prüfungen des Validators aus. Dabei wird zunächst die Fehlerliste
     * geleert und durch die ausführenden Prüfroutinen befüllt.
     *
     * @return true, falls alle Prüfroutinen erfolgreich waren, und ansonsten false
     */
    run(): boolean;
    /**
     * Diese Methode führt einen Prüfschritt aus, genau dann, wenn der Validator selbst und dieser explixite Schritt aktiv sind.
     * Das Lambda stellt die Fehlerbedingung da, die TRUE liefert, wenn ein Fehler vorliegt.
     *
     * @param schrittNummer     die Nummer des Prüfschrittes. Startet in der Regel mit 0
     * @param fehlerbedingung   die Prüfschrittbedingung als Lambda
     * @param error             die Fehlermeldung, falls der Prüfschritt fehlschlägt
     *
     * @return true, wenn der Prüfschritt erfolgreich ausgeführt wurde oder nicht aktiv ist und false, wenn ein Fehler beim Prüfschritt auftritt
     */
    protected exec(schrittNummer: number, fehlerbedingung: BooleanSupplier, error: string): boolean;
    /**
     * Aktualisiert die Fehlerart, die durch den Lauf dieses Validators erzeugt wurde
     * anhand der übergebenen Fehlerart. Wird null übergeben, so wird die Fehlerart genutzt, die
     * diesem Validator zugeordnet ist.
     *
     * @param art   die Fehlerart, die für die Überprüfung genutzt wird, oder null
     */
    private updateFehlerart;
    /**
     * Erstellt einen neuen Fehler mit der übergebenen Fehlermeldung
     *
     * @param pruefschritt    die Nummer des Prüfschrittes, bei welchem der Fehler aufgetreten ist
     * @param fehlermeldung   die Fehlermeldung
     */
    private addFehler;
    /**
     * Gibt die Fehler des Validators als unmodifiable List zurück.
     *
     * @return die Liste der Fehler als unmodifiable List
     */
    getFehler(): List<ValidatorFehler>;
    /**
     * Die Fehlerart, welche diesem speziellen Validator zugeordnet ist.
     *
     * @param pruefschritt   der Prüfschritt, bei welchem der Fehler aufgetreten ist
     *
     * @return die Fehlerart
     */
    getValidatorFehlerart(pruefschritt: number): ValidatorFehlerart;
    /**
     * Gibt das Fehlercode-Präfix zurück, welcher diesem speziellen Validator zugeordnet ist.
     *
     * @return das Fehlercode-Präfix
     */
    getFehlercodePraefix(): string;
    /**
     * Die Fehlerart, welche dem Validator nach dem Lauf der Validierung zugeordnet ist.
     * Dabei sind die Ergebnisse von ggf. vorhandene Sub-Validatoren mit einbezogen.
     * Es wird also die schwerwiegendste Fehlerart zurückgegeben.
     *
     * @return die Fehlerart
     */
    getFehlerart(): ValidatorFehlerart;
    /**
     * Führt die Prüfung der Daten aus. Befüllt ggf. die Fehlerliste, falls
     * es zu Fehlern kommt.
     *
     * @return true, falls die Prüfung erfolgreich war, und ansonsten false
     */
    protected abstract pruefe(): boolean;
    transpilerCanonicalName(): string;
    isTranspiledInstanceOf(name: string): boolean;
    static class: Class<Validator>;
}
export declare function cast_de_svws_nrw_asd_validate_Validator(obj: unknown): Validator;
//# sourceMappingURL=Validator.d.ts.map