### Validator Setup and Basic Checks

Source: https://context7.com/effad/validatorfx/llms.txt

Initialize a Validator, create checks for username and email fields, and bind a submit button's disabled state to validation errors. This example demonstrates immediate validation mode.

```java
import net.synedra.validatorfx.Validator;
import net.synedra.validatorfx.Severity;
import javafx.beans.binding.Bindings;
import javafx.scene.control.*;

Validator validator = new Validator();

TextField usernameField = new TextField();
TextField emailField    = new TextField();

// Check 1: username must be non-empty and lowercase
validator.createCheck()
    .dependsOn("username", usernameField.textProperty())
    .withMethod(c -> {
        String v = c.get("username");
        if (v == null || v.isBlank())          { c.error("Username is required."); }
        else if (!v.equals(v.toLowerCase()))   { c.error("Username must be lowercase."); }
    })
    .decorates(usernameField)
    .immediate();

// Check 2: basic e-mail format warning (non-blocking)
validator.createCheck()
    .dependsOn("email", emailField.textProperty())
    .withMethod(c -> {
        String v = c.get("email");
        if (!v.contains("@")) { c.warn("Value does not look like an e-mail address."); }
    })
    .decorates(emailField)
    .immediate();

// Bind a submit button's disabled state to validation errors
Button submitBtn = new Button("Submit");
submitBtn.disableProperty().bind(validator.containsErrorsProperty());

// Programmatic on-submit validation (explicit mode)
submitBtn.setOnAction(e -> {
    if (validator.validate()) {
        System.out.println("Form is valid — proceeding.");
    } else {
        System.out.println("Errors: " + validator.createStringBinding().get());
        // e.g. "• Username is required.\n• ..."
    }
});

// Query state at any time
boolean hasErrors   = validator.containsErrors();
boolean hasWarnings = validator.containsWarnings();
validator.getValidationResult().getMessages()
    .forEach(m -> System.out.println(m.getSeverity() + ": " + m.getText()));
```

--------------------------------

### Custom Decoration with `decoratingWith`

Source: https://context7.com/effad/validatorfx/llms.txt

Replace the default decoration factory with a custom one using `decoratingWith`. This example updates a label instead of showing an icon.

```java
Validator validator = new Validator();
TextField s1 = new TextField("10");
TextField s2 = new TextField("5");
TextField result = new TextField("14");
Label statusLabel = new Label("OK");

validator.createCheck()
    .dependsOn("s1",  s1.textProperty())
    .dependsOn("s2",  s2.textProperty())
    .dependsOn("res", result.textProperty())
    .withMethod(c -> {
        try {
            int a = Integer.parseInt(c.get("s1"));
            int b = Integer.parseInt(c.get("s2"));
            int r = Integer.parseInt(c.get("res"));
            if (a + b != r) { c.error("Sum should be " + (a + b)); }
        } catch (NumberFormatException e) { c.error("All values must be numbers."); }
    })
    // Custom decoration: update a label instead of showing an icon
    .decoratingWith(msg -> new Decoration() {
        @Override public void add(Node target)    { ((Label) target).setText("ERR – " + msg.getText()); }
        @Override public void remove(Node target) { ((Label) target).setText("OK"); }
    })
    .decorates(statusLabel)
    .immediate();
```

--------------------------------

### Implement Validation Logic

Source: https://github.com/effad/validatorfx/blob/master/README.md

Defines the custom validation logic to be executed. Access dependencies using the provided context object. Multiple calls to withMethod install multiple checks.

```java
.withMethod(c -> {
        String userName = c.get("username");
        if (!userName.toLowerCase().equals(userName)) {
          c.error("Please use only lowercase letters.");
        }
      })
```

--------------------------------

### Minimal ValidatorFX Example

Source: https://github.com/effad/validatorfx/blob/master/README.md

A basic JavaFX application demonstrating ValidatorFX for form validation. It sets up a TextField and applies an immediate validation check for lowercase letters.

```java
package net.synedra.validatorfx.demo;

import javafx.application.Application;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.TextField;
import javafx.scene.layout.GridPane;
import javafx.stage.Stage;
import net.synedra.validatorfx.Validator;

public class MinimalExample extends Application {

  private Validator validator = new Validator();

  @Override
  public void start(Stage primaryStage) throws Exception {

    TextField userTextField = new TextField();

    validator.createCheck()
      .dependsOn("username", userTextField.textProperty())
      .withMethod(c -> {
        String userName = c.get("username");
        if (!userName.toLowerCase().equals(userName)) {
          c.error("Please use only lowercase letters.");
        }
      })
      .decorates(userTextField)
      .immediate();

    GridPane grid = createGrid();
    grid.add(userTextField, 1, 1);

    Scene scene = new Scene(grid);		
    primaryStage.setScene(scene);		
    primaryStage.show();		
  }

  private GridPane createGrid() {
    GridPane grid = new GridPane();
    grid.setAlignment(Pos.CENTER);
    grid.setPrefSize(400,  200);
    return grid;
  }

  public static void main(String[] args) {
    launch();
  }
}
```

--------------------------------

### DefaultDecoration Strategies

Source: https://context7.com/effad/validatorfx/llms.txt

Provides built-in decoration factories for styling validation feedback. `createGraphicDecoration` adds an icon with a tooltip, while `createStyleClassDecoration` toggles CSS classes.

```java
// Use CSS-class-based decorations globally (e.g. for custom themes)
DefaultDecoration.setFactory(DefaultDecoration::createStyleClassDecoration);
// Now all checks without an explicit decoratingWith() will toggle:
//   "validatorfx-error" or "validatorfx-warning" on the target node

// Customize the default graphic decoration (e.g. increase tooltip font size)
DefaultDecoration.setFactory(msg -> {
    GraphicDecoration decoration = DefaultDecoration.createGraphicDecoration(msg);
    Node node = decoration.getDecorationNode();
    if (node instanceof Label lbl && lbl.getTooltip() != null) {
        lbl.getTooltip().setStyle(lbl.getTooltip().getStyle() + "-fx-font-size: 14px;");
    }
    return decoration;
});

// Reset to default graphic factory
DefaultDecoration.setFactory(DefaultDecoration::createGraphicDecoration);
```

--------------------------------

### Provide Custom Default Decoration Factory

Source: https://github.com/effad/validatorfx/blob/master/README.md

Set a custom factory for default decorations using `DefaultDecoration.setFactory(...)`. This allows modification of default graphic decorations.

```java
DefaultDecoration.setFactory(this::createGraphicDecoration);
...
public GraphicDecoration createGraphicDecoration(ValidationMessage message) {
    GraphicDecoration decoration = DefaultDecoration.createGraphicDecoration(message);
    if (decoration.getDecorationNode() instanceof Label label && label.getTooltip() instanceof Tooltip tooltip) {
        tooltip.setStyle(tooltip.getStyle() + "-fx-font-size: 20em");
    }
    return decoration;
}
```

--------------------------------

### DefaultDecoration

Source: https://context7.com/effad/validatorfx/llms.txt

Provides built-in decoration strategies for visual feedback, including graphic overlays and CSS class toggling.

```APIDOC
## `DefaultDecoration` — Built-in Decoration Strategies

`DefaultDecoration` provides two ready-made decoration factories and a global factory override. `createGraphicDecoration` overlays a small error/warning icon with a styled tooltip. `createStyleClassDecoration` toggles CSS classes (`validatorfx-error`, `validatorfx-warning`) for stylesheet-driven styling. Call `DefaultDecoration.setFactory(...)` to replace the global default for all checks.

```java
// Use CSS-class-based decorations globally (e.g. for custom themes)
DefaultDecoration.setFactory(DefaultDecoration::createStyleClassDecoration);
// Now all checks without an explicit decoratingWith() will toggle:
//   "validatorfx-error" or "validatorfx-warning" on the target node

// Customize the default graphic decoration (e.g. increase tooltip font size)
DefaultDecoration.setFactory(msg -> {
    GraphicDecoration decoration = DefaultDecoration.createGraphicDecoration(msg);
    Node node = decoration.getDecorationNode();
    if (node instanceof Label lbl && lbl.getTooltip() != null) {
        lbl.getTooltip().setStyle(lbl.getTooltip().getStyle() + "-fx-font-size: 14px;");
    }
    return decoration;
});

// Reset to default graphic factory
DefaultDecoration.setFactory(DefaultDecoration::createGraphicDecoration);
```
```

--------------------------------

### Check.decorates() and Check.decoratingWith()

Source: https://context7.com/effad/validatorfx/llms.txt

Specifies which UI nodes receive visual feedback upon validation failure using `decorates(Node)`. `decoratingWith(Function<ValidationMessage, Decoration>)` allows for custom decoration factories, replacing the default behavior.

```APIDOC
## `Check.decorates()` and `Check.decoratingWith()` — Decoration Targets and Factories

`decorates(Node)` specifies which node(s) receive decorations when the check fails. `decoratingWith(Function<ValidationMessage, Decoration>)` replaces the default graphic decoration factory for this specific check with a custom one.

```java
Validator validator = new Validator();
TextField s1 = new TextField("10");
TextField s2 = new TextField("5");
TextField result = new TextField("14");
Label statusLabel = new Label("OK");

validator.createCheck()
    .dependsOn("s1",  s1.textProperty())
    .dependsOn("s2",  s2.textProperty())
    .dependsOn("res", result.textProperty())
    .withMethod(c -> {
        try {
            int a = Integer.parseInt(c.get("s1"));
            int b = Integer.parseInt(c.get("s2"));
            int r = Integer.parseInt(c.get("res"));
            if (a + b != r) { c.error("Sum should be " + (a + b)); }
        } catch (NumberFormatException e) { c.error("All values must be numbers."); }
    })
    // Custom decoration: update a label instead of showing an icon
    .decoratingWith(msg -> new Decoration() {
        @Override public void add(Node target)    { ((Label) target).setText("ERR – " + msg.getText()); }
        @Override public void remove(Node target) { ((Label) target).setText("OK"); }
    })
    .decorates(statusLabel)
    .immediate();
```
```

--------------------------------

### Provide Custom Decorations Per Check Instance

Source: https://github.com/effad/validatorfx/blob/master/README.md

Use `decoratingWith` to apply custom decorations to individual validation checks. Requires a `Decoration` implementation.

```java
validator.createCheck()
    ... 
    .decoratingWith(this::sumDecorator)
    ... 
;
...
private Decoration sumDecorator(ValidationMessage m) {
    return new Decoration() {
        @Override
        public void remove(Node target) {
            ((Label) target).setText("OK");
        }

        @Override
        public void add(Node target) {
            ((Label) target).setText("ERR - " + m.getText());
        }
    };
}
```

--------------------------------

### GraphicDecoration for Overlay Nodes

Source: https://context7.com/effad/validatorfx/llms.txt

Allows placing an arbitrary Node as a decoration on top of a target, with configurable position and offsets. `updateDecorations` can manually trigger layout refreshes.

```java
// Custom icon overlay at bottom-right with a 4 px offset
ImageView warningIcon = new ImageView(new Image("/icons/custom-warning.png"));
GraphicDecoration customDeco = new GraphicDecoration(warningIcon, Pos.BOTTOM_RIGHT, -4, -4);

// Use it on a specific check
validator.createCheck()
    .dependsOn("val", someField.textProperty())
    .withMethod(c -> { if (c.get("val").toString().isBlank()) c.warn("Required."); })
    .decoratingWith(msg -> new GraphicDecoration(
        new ImageView(new Image("/icons/custom-" + msg.getSeverity().toString().toLowerCase() + ".png")),
        Pos.TOP_RIGHT
    ))
    .decorates(someField)
    .immediate();

// Force layout refresh after an animated transition moves decorated nodes
GraphicDecoration.updateDecorations(someField);
```

--------------------------------

### TooltipWrapper

Source: https://context7.com/effad/validatorfx/llms.txt

Wraps a Node to bind its disableProperty and show a Tooltip explaining the reason for being disabled, addressing JDK-8090379.

```APIDOC
## `TooltipWrapper` — Disabled Button with Explanatory Tooltip

`TooltipWrapper<T extends Node>` wraps any `Node` in an `HBox`, binds its `disableProperty` to a supplied `ObservableValue<Boolean>`, and shows a `Tooltip` explaining why the node is disabled — working around JDK-8090379 (tooltips do not fire on disabled JavaFX controls).

```java
Validator validator = new Validator();
Button signUpBtn = new Button("Sign Up");

// Disable the button when there are errors; show what's wrong on hover
TooltipWrapper<Button> wrappedBtn = new TooltipWrapper<>(
    signUpBtn,
    validator.containsErrorsProperty(),
    Bindings.concat("Cannot sign up:\n", validator.createStringBinding())
);
// Add wrappedBtn (not signUpBtn) to the scene graph
gridPane.add(wrappedBtn, 1, 5);

// Access internals if needed
Button btn     = wrappedBtn.getWrappedNode();
Tooltip tip    = wrappedBtn.getDisabledTooltip();
tip.setStyle("-fx-font-size: 14px;");
```
```

--------------------------------

### Create StringBinding for Error Summary

Source: https://context7.com/effad/validatorfx/llms.txt

Generates a StringBinding that updates with bullet-separated error messages. An overload allows for custom prefixes, separators, and inclusion of warnings.

```java
Validator validator = new Validator();
TextArea summaryArea = new TextArea();

// Default: bullet-separated errors only
summaryArea.textProperty().bind(validator.createStringBinding());
// Example output:
// • Username is required.
// • Passwords do not match.

// Custom: numbered, errors + warnings
StringBinding custom = validator.createStringBinding("→ ", "\n", Severity.ERROR, Severity.WARNING);
Label customLabel = new Label();
customLabel.textProperty().bind(custom);
// Example output:
// → Username is required.
// → Password should be at least 8 characters.
```

--------------------------------

### Check.immediate() / Check.immediateClear() / Check.explicit()

Source: https://context7.com/effad/validatorfx/llms.txt

Defines the evaluation mode for validation checks. `immediate()` triggers validation on dependency changes. `immediateClear()` clears decorations but defers validation. `explicit()` requires manual validation calls.

```APIDOC
## `Check.immediate()` / `Check.immediateClear()` / `Check.explicit()` — Evaluation Modes

`immediate()` makes the check rerun automatically whenever any dependency changes. `immediateClear()` clears decorations on change but does not rerun the check (useful for "clear on edit, validate on submit" UX). `explicit()` (the default) requires a manual call to `validator.validate()` or `check.recheck()`.

```java
Validator validator = new Validator();
TextField field = new TextField();
Button submitBtn = new Button("Save");

Check myCheck = validator.createCheck()
    .dependsOn("value", field.textProperty())
    .withMethod(c -> {
        if (c.get("value").toString().isBlank()) { c.error("Field must not be empty."); }
    })
    .decorates(field);

// Scenario A — immediate reactive validation:
myCheck.immediate();

// Scenario B — clear on edit, validate on submit:
myCheck.immediateClear();
submitBtn.setOnAction(e -> validator.validate());

// Scenario C — fully explicit:
myCheck.explicit();
submitBtn.setOnAction(e -> {
    if (validator.validate()) { System.out.println("OK"); } 
});

// Switch all checks in the validator to explicit mode at once:
validator.explicit();
```
```

--------------------------------

### Evaluation Modes: `immediate`, `immediateClear`, `explicit`

Source: https://context7.com/effad/validatorfx/llms.txt

Control when validation runs. `immediate()` reruns on dependency change. `immediateClear()` clears decorations but doesn't rerun. `explicit()` requires manual calls.

```java
Validator validator = new Validator();
TextField field = new TextField();
Button submitBtn = new Button("Save");

Check myCheck = validator.createCheck()
    .dependsOn("value", field.textProperty())
    .withMethod(c -> {
        if (c.get("value").toString().isBlank()) { c.error("Field must not be empty."); }
    })
    .decorates(field);

// Scenario A — immediate reactive validation:
myCheck.immediate();

// Scenario B — clear on edit, validate on submit:
myCheck.immediateClear();
submitBtn.setOnAction(e -> validator.validate());

// Scenario C — fully explicit:
myCheck.explicit();
submitBtn.setOnAction(e -> {
    if (validator.validate()) { System.out.println("OK"); }
});

// Switch all checks in the validator to explicit mode at once:
validator.explicit();
```

--------------------------------

### Multiple `withMethod` for Validation Logic

Source: https://context7.com/effad/validatorfx/llms.txt

Define multiple validation methods that all run sequentially, even if earlier methods emit errors. Use `Context.error()` and `Context.warn()` to report issues.

```java
Validator validator = new Validator();
TextField age = new TextField();

validator.createCheck()
    .dependsOn("age", age.textProperty())
    // First method: numeric format check
    .withMethod(c -> {
        try { Integer.parseInt(c.get("age")); } 
        catch (NumberFormatException e) { c.error("Age must be a number."); }
    })
    // Second method: range check (runs even if first emitted an error)
    .withMethod(c -> {
        try {
            int v = Integer.parseInt(c.get("age"));
            if (v < 0)   { c.error("Age cannot be negative."); }
            if (v < 18)  { c.warn("Users under 18 need parental consent."); }
            if (v > 120) { c.error("Please enter a realistic age."); }
        } catch (NumberFormatException ignored) { /* already reported above */ }
    })
    .decorates(age)
    .immediate();
```

--------------------------------

### GraphicDecoration

Source: https://context7.com/effad/validatorfx/llms.txt

Allows arbitrary Node decorations to be placed on top of target nodes, with configurable positioning and offsets. Includes a method to manually trigger layout refreshes.

```APIDOC
## `GraphicDecoration` — Overlay Node Decoration

`GraphicDecoration` places an arbitrary `Node` on top of a decorated target using a `GraphicDecorationStackPane` injected as the scene root. Position and pixel offsets are configurable. `GraphicDecoration.updateDecorations(node)` manually triggers a layout refresh if decorations drift out of sync.

```java
// Custom icon overlay at bottom-right with a 4 px offset
ImageView warningIcon = new ImageView(new Image("/icons/custom-warning.png"));
GraphicDecoration customDeco = new GraphicDecoration(warningIcon, Pos.BOTTOM_RIGHT, -4, -4);

// Use it on a specific check
validator.createCheck()
    .dependsOn("val", someField.textProperty())
    .withMethod(c -> { if (c.get("val").toString().isBlank()) c.warn("Required."); })
    .decoratingWith(msg -> new GraphicDecoration(
        new ImageView(new Image("/icons/custom-" + msg.getSeverity().toString().toLowerCase() + ".png")),
        Pos.TOP_RIGHT
    ))
    .decorates(someField)
    .immediate();

// Force layout refresh after an animated transition moves decorated nodes
GraphicDecoration.updateDecorations(someField);
```
```

--------------------------------

### Fluent Check Builder and Dynamic Removal

Source: https://context7.com/effad/validatorfx/llms.txt

Demonstrates building and registering a check using the fluent API and dynamically removing it from the validator. This is useful for managing checks associated with form elements that can be added or removed at runtime.

```java
Validator validator = new Validator();
TextField qty = new TextField("0");

// Build and register a check in one fluent chain
Check stockCheck = validator.createCheck()
    .dependsOn("qty", qty.textProperty())
    .withMethod(c -> {
        try {
            int n = Integer.parseInt(c.get("qty"));
            if (n < 1)   c.error("Quantity must be at least 1.");
            if (n > 999) c.warn("Large quantities may require approval.");
        } catch (NumberFormatException ex) {
            c.error("Quantity must be a number.");
        }
    })
    .decorates(qty)
    .immediate();

// Dynamically remove the check when the field is hidden
validator.remove(stockCheck);  // decorations cleared, check no longer runs
```

--------------------------------

### Decorate UI Nodes

Source: https://github.com/effad/validatorfx/blob/master/README.md

Specifies which UI nodes should be visually decorated based on the validation result. Multiple nodes can be decorated by calling this method multiple times.

```java
.decorates(userTextField)
```

--------------------------------

### Validator.createStringBinding()

Source: https://context7.com/effad/validatorfx/llms.txt

Creates a StringBinding that automatically updates with error messages. Overloads allow customization of prefixes, separators, and severity levels.

```APIDOC
## `Validator.createStringBinding()` — Human-Readable Error Summary

`createStringBinding()` returns a `StringBinding` that automatically updates with bullet-separated error messages. An overload accepts a custom prefix, separator, and one or more `Severity` values to include warnings too.

```java
Validator validator = new Validator();
TextArea summaryArea = new TextArea();

// Default: bullet-separated errors only
summaryArea.textProperty().bind(validator.createStringBinding());
// Example output:
// • Username is required.
// • Passwords do not match.

// Custom: numbered, errors + warnings
StringBinding custom = validator.createStringBinding("→ ", "\n", Severity.ERROR, Severity.WARNING);
Label customLabel = new Label();
customLabel.textProperty().bind(custom);
// Example output:
// → Username is required.
// → Password should be at least 8 characters.
```
```

--------------------------------

### Check.withMethod()

Source: https://context7.com/effad/validatorfx/llms.txt

Registers the lambda expression that performs the actual validation logic. Multiple methods can be registered and will all execute without short-circuiting. Errors and warnings are emitted using Context.error() and Context.warn().

```APIDOC
## `Check.withMethod()` — Check Logic (Multiple Methods Supported)

`withMethod(Consumer<Context>)` registers the lambda that performs the actual validation. Since 0.5.0, `withMethod` can be called multiple times on the same `Check`; all registered methods run (no short-circuit evaluation). `Context.error(String)` emits an error; `Context.warn(String)` emits a warning.

```java
Validator validator = new Validator();
TextField age = new TextField();

validator.createCheck()
    .dependsOn("age", age.textProperty())
    // First method: numeric format check
    .withMethod(c -> {
        try { Integer.parseInt(c.get("age")); } 
        catch (NumberFormatException e) { c.error("Age must be a number."); }
    })
    // Second method: range check (runs even if first emitted an error)
    .withMethod(c -> {
        try {
            int v = Integer.parseInt(c.get("age"));
            if (v < 0)   { c.error("Age cannot be negative."); }
            if (v < 18)  { c.warn("Users under 18 need parental consent."); }
            if (v > 120) { c.error("Please enter a realistic age."); }
        } catch (NumberFormatException ignored) { /* already reported above */ }
    })
    .decorates(age)
    .immediate();
```
```

--------------------------------

### Apply CSS Style Classes on Validation Failure

Source: https://context7.com/effad/validatorfx/llms.txt

Adds CSS style classes to a node when a check fails and removes them when the check passes. Requires CSS definitions for the applied classes.

```java
validator.createCheck()
    .dependsOn("email", emailField.textProperty())
    .withMethod(c -> {
        String v = c.get("email");
        if (!v.contains("@")) { c.error("Invalid e-mail."); }
    })
    .decoratingWith(msg -> new StyleClassDecoration("field-error", "field-invalid"))
    .decorates(emailField)
    .immediate();

// In CSS:
// .field-error { -fx-border-color: red; -fx-border-width: 2; }
// .field-invalid { -fx-background-color: #ffe0e0; }
```

--------------------------------

### Set Immediate Validation Mode

Source: https://github.com/effad/validatorfx/blob/master/README.md

Configures the validation check to be evaluated constantly and decorations updated immediately as the dependent properties change. Alternatively, validation can be triggered on demand.

```java
.immediate()
```

--------------------------------

### Disable Button with Tooltip using TooltipWrapper

Source: https://github.com/effad/validatorfx/blob/master/README.md

Use `TooltipWrapper` to disable a button and show a tooltip when validation fails, providing a workaround for JDK-8090379.

```java
TooltipWrapper<Button> signUpWrapper = new TooltipWrapper<>(
	signUp, 
	validator.containsErrorsProperty(), 
	Bindings.concat("Cannot sign up:\n", validator.createStringBinding())
);
```

--------------------------------

### TooltipWrapper for Disabled Buttons

Source: https://context7.com/effad/validatorfx/llms.txt

Wraps a Node to disable it based on an ObservableValue and display a Tooltip explaining the reason for disablement, addressing JDK-8090379.

```java
Validator validator = new Validator();
Button signUpBtn = new Button("Sign Up");

// Disable the button when there are errors; show what's wrong on hover
TooltipWrapper<Button> wrappedBtn = new TooltipWrapper<>(
    signUpBtn,
    validator.containsErrorsProperty(),
    Bindings.concat("Cannot sign up:\n", validator.createStringBinding())
);
// Add wrappedBtn (not signUpBtn) to the scene graph
gridPane.add(wrappedBtn, 1, 5);

// Access internals if needed
Button btn     = wrappedBtn.getWrappedNode();
Tooltip tip    = wrappedBtn.getDisabledTooltip();
tip.setStyle("-fx-font-size: 14px;");
```

--------------------------------

### Inspect Validation Results Programmatically

Source: https://context7.com/effad/validatorfx/llms.txt

Performs validation and iterates through the results to print severity and text for each message. Useful for one-time checks after explicit validation.

```java
Validator validator = new Validator();
// ... add checks ...

// One-time programmatic inspection after explicit validate()
boolean ok = validator.validate();
ValidationResult result = validator.getValidationResult();
for (ValidationMessage msg : result.getMessages()) {
    System.out.printf("[%s] %s%n", msg.getSeverity(), msg.getText());
}
// Output example:
// [ERROR] Username is required.
// [WARNING] Password should be at least 8 characters.
```

--------------------------------

### Create New Validation Check

Source: https://github.com/effad/validatorfx/blob/master/README.md

Initiates the creation of a new validation check using the ValidatorFX fluent API.

```java
validator.createCheck()
```

--------------------------------

### Check.dependsOn()

Source: https://context7.com/effad/validatorfx/llms.txt

Registers named observables as inputs for a validation check. Multiple dependencies can be chained, and their values can be retrieved within the check method using context.get(key).

```APIDOC
## `Check.dependsOn()` — Observable Dependencies

`dependsOn(String key, ObservableValue<?> observable)` registers a named observable as input for the check method. Multiple `dependsOn` calls can be chained. Inside the check method, `context.get(key)` retrieves the current value with automatic type casting.

```java
Validator validator = new Validator();
PasswordField pw1 = new PasswordField();
PasswordField pw2 = new PasswordField();

validator.createCheck()
    .dependsOn("password",     pw1.textProperty())
    .dependsOn("confirmation", pw2.textProperty())
    .withMethod(c -> {
        String p1 = c.get("password");
        String p2 = c.get("confirmation");
        if (p1.length() < 8)    { c.warn("Password should be at least 8 characters."); }
        if (!p1.equals(p2))     { c.error("Passwords do not match."); }
    })
    .decorates(pw1)
    .decorates(pw2)   // both fields get decorated on mismatch
    .immediate();
```
```

--------------------------------

### Chaining `dependsOn` for Observable Dependencies

Source: https://context7.com/effad/validatorfx/llms.txt

Register observable inputs for a check and retrieve their values within the validation method. Chaining `dependsOn` is supported.

```java
Validator validator = new Validator();
PasswordField pw1 = new PasswordField();
PasswordField pw2 = new PasswordField();

validator.createCheck()
    .dependsOn("password",     pw1.textProperty())
    .dependsOn("confirmation", pw2.textProperty())
    .withMethod(c -> {
        String p1 = c.get("password");
        String p2 = c.get("confirmation");
        if (p1.length() < 8)    { c.warn("Password should be at least 8 characters."); }
        if (!p1.equals(p2))     { c.error("Passwords do not match."); }
    })
    .decorates(pw1)
    .decorates(pw2)   // both fields get decorated on mismatch
    .immediate();
```

--------------------------------

### Gradle Dependency for ValidatorFX

Source: https://context7.com/effad/validatorfx/llms.txt

Add this dependency to your Gradle project to include ValidatorFX.

```groovy
implementation 'net.synedra:validatorfx:0.6.3'
```

--------------------------------

### Listen to Validation Result Changes Reactively

Source: https://context7.com/effad/validatorfx/llms.txt

Adds a listener to the validation result property to react to changes. This is useful for updating UI elements or counters based on the current validation status.

```java
validator.validationResultProperty().addListener((obs, oldResult, newResult) -> {
    long errorCount   = newResult.getMessages().stream()
        .filter(m -> m.getSeverity() == Severity.ERROR).count();
    long warningCount = newResult.getMessages().stream()
        .filter(m -> m.getSeverity() == Severity.WARNING).count();
    System.out.println(errorCount + " error(s), " + warningCount + " warning(s)");
});
```

--------------------------------

### Add ValidatorFX Dependency

Source: https://github.com/effad/validatorfx/blob/master/README.md

Include this Maven dependency to add ValidatorFX to your project.

```xml
<dependency>
   <groupId>net.synedra</groupId>
   <artifactId>validatorfx</artifactId>
   <version>0.6.3</version>
</dependency>
```

--------------------------------

### Define Validation Dependency

Source: https://github.com/effad/validatorfx/blob/master/README.md

Declares a dependency for a validation check, linking it to an observable property. Multiple dependencies can be added using multiple calls.

```java
.dependsOn("username", userTextField.textProperty())
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.