diff --git a/test-suite/build.gradle b/test-suite/build.gradle
index 408d4145..e777baf0 100644
--- a/test-suite/build.gradle
+++ b/test-suite/build.gradle
@@ -3,9 +3,12 @@ plugins {
 }
 
 dependencies {
+    testAnnotationProcessor("org.projectlombok:lombok")
     testAnnotationProcessor projects.micronautValidationProcessor
     testAnnotationProcessor mn.micronaut.inject.java
 
+    testCompileOnly("org.projectlombok:lombok")
+
     testImplementation mn.micronaut.inject
     testImplementation mn.micronaut.core.reactive
     testImplementation libs.managed.validation
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/ValidationTest.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/ValidationTest.java
new file mode 100644
index 00000000..f3ee7210
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/ValidationTest.java
@@ -0,0 +1,53 @@
+package io.micronaut.docs.validation.path;
+
+import io.micronaut.docs.validation.path.model.Dag;
+import io.micronaut.docs.validation.path.model.Flow;
+import io.micronaut.docs.validation.path.model.Log;
+import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
+import jakarta.inject.Inject;
+import jakarta.validation.Validator;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@MicronautTest(startApplication = false)
+public class ValidationTest {
+    @Inject
+    Validator validator;
+
+    @Test
+    void testValidationOk() {
+        Flow f = Flow.builder()
+            .id("id")
+            .namespace("namespace")
+            .tasks(List.of(Log.builder().id("task").type(Log.class.getName()).message("").build()))
+            .build();
+
+        var violation = validator.validate(f).stream().findFirst().get();
+        assertEquals("tasks[0].message", violation.getPropertyPath().toString());
+        assertEquals("must not be blank", violation.getMessage());
+    }
+
+    @Test
+    void testValidationKo() {
+        Flow f = Flow.builder()
+            .id("id")
+            .namespace("namespace")
+            .tasks(List.of(
+                Dag.builder()
+                    .id("dag")
+                    .type(Dag.class.getName())
+                    .tasks(List.of(
+                        Dag.DagTask.builder().task(Log.builder().id("cycle").type(Log.class.getName()).message("").build()).dependsOn(List.of("cycle")).build()
+                    ))
+                .build())
+            )
+            .build();
+
+        var violation = validator.validate(f).stream().findFirst().get();
+        assertEquals("tasks[0].tasks", violation.getPropertyPath().toString());
+        assertEquals("Cyclic dependency detected: cycle", violation.getMessage());
+    }
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/model/AbstractTrigger.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/AbstractTrigger.java
new file mode 100644
index 00000000..486fd445
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/AbstractTrigger.java
@@ -0,0 +1,41 @@
+package io.micronaut.docs.validation.path.model;
+
+import io.micronaut.core.annotation.Introspected;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Pattern;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+import java.util.List;
+
+@SuperBuilder
+@Getter
+@NoArgsConstructor
+@Introspected
+abstract public class AbstractTrigger {
+    @NotNull
+    @NotBlank
+    @Pattern(regexp="[a-zA-Z0-9_-]+")
+    protected String id;
+
+    @NotNull
+    @NotBlank
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
+    protected String type;
+
+    private String description;
+
+    @Valid
+    private List<Condition> conditions;
+
+    @NotNull
+    @Builder.Default
+    private boolean disabled = false;
+
+    @Valid
+    private WorkerGroup workerGroup;
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Condition.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Condition.java
new file mode 100644
index 00000000..65a5298f
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Condition.java
@@ -0,0 +1,20 @@
+package io.micronaut.docs.validation.path.model;
+
+import io.micronaut.core.annotation.Introspected;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Pattern;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+@SuperBuilder
+@Getter
+@NoArgsConstructor
+@AllArgsConstructor
+@Introspected
+public abstract class Condition {
+    @NotNull
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
+    protected String type;
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Dag.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Dag.java
new file mode 100644
index 00000000..ffb907bd
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Dag.java
@@ -0,0 +1,105 @@
+package io.micronaut.docs.validation.path.model;
+
+import io.micronaut.core.annotation.Introspected;
+import io.micronaut.docs.validation.path.validations.DagTaskValidation;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+import lombok.experimental.SuperBuilder;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@SuperBuilder
+@ToString
+@EqualsAndHashCode
+@Getter
+@NoArgsConstructor
+@DagTaskValidation
+public class Dag extends Task{
+    @NotNull
+    @Builder.Default
+    private final Integer concurrent = 0;
+
+    @NotEmpty
+    @Valid
+    private List<DagTask> tasks;
+
+    @Valid
+    protected List<Task> errors;
+
+    public List<String> dagCheckNotExistTask(List<DagTask> taskDepends) {
+        List<String> dependenciesIds = taskDepends
+            .stream()
+            .map(DagTask::getDependsOn)
+            .filter(Objects::nonNull)
+            .flatMap(Collection::stream)
+            .toList();
+
+        List<String> tasksIds = taskDepends
+            .stream()
+            .map(taskDepend -> taskDepend.getTask().getId())
+            .toList();
+
+        return dependenciesIds.stream()
+            .filter(dependencyId -> !tasksIds.contains(dependencyId))
+            .collect(Collectors.toList());
+    }
+
+    public ArrayList<String> dagCheckCyclicDependencies(List<DagTask> taskDepends) {
+        ArrayList<String> cyclicDependency = new ArrayList<>();
+        taskDepends.forEach(taskDepend -> {
+            if (taskDepend.getDependsOn() != null) {
+                List<String> nestedDependencies = this.nestedDependencies(taskDepend, taskDepends, new ArrayList<>());
+                if (nestedDependencies.contains(taskDepend.getTask().getId())) {
+                    cyclicDependency.add(taskDepend.getTask().getId());
+                }
+            }
+        });
+
+        return cyclicDependency;
+    }
+
+    private ArrayList<String> nestedDependencies(DagTask taskDepend, List<DagTask> tasks, List<String> visited) {
+        final ArrayList<String> localVisited = new ArrayList<>(visited);
+        if (taskDepend.getDependsOn() != null) {
+            taskDepend.getDependsOn()
+                .stream()
+                .filter(depend -> !localVisited.contains(depend))
+                .forEach(depend -> {
+                    localVisited.add(depend);
+                    Optional<DagTask> task = tasks
+                        .stream()
+                        .filter(t -> t.getTask().getId().equals(depend))
+                        .findFirst();
+
+                    if (task.isPresent()) {
+                        localVisited.addAll(this.nestedDependencies(task.get(), tasks, localVisited));
+                    }
+                });
+        }
+        return localVisited;
+    }
+
+    @SuperBuilder
+    @ToString
+    @EqualsAndHashCode
+    @Getter
+    @NoArgsConstructor
+    @Introspected
+    public static class DagTask {
+        @NotNull
+        private Task task;
+
+        private List<String> dependsOn;
+    }
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/model/DeletedInterface.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/DeletedInterface.java
new file mode 100644
index 00000000..2c57afd5
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/DeletedInterface.java
@@ -0,0 +1,5 @@
+package io.micronaut.docs.validation.path.model;
+
+public interface DeletedInterface {
+    boolean isDeleted();
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Flow.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Flow.java
new file mode 100644
index 00000000..4d624f80
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Flow.java
@@ -0,0 +1,201 @@
+package io.micronaut.docs.validation.path.model;
+
+import io.micronaut.core.annotation.Introspected;
+import io.micronaut.docs.validation.path.validations.FlowValidation;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Pattern;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+import lombok.With;
+import lombok.experimental.SuperBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+@SuperBuilder(toBuilder = true)
+@Getter
+@AllArgsConstructor
+@NoArgsConstructor
+@Introspected
+@ToString
+@EqualsAndHashCode
+@FlowValidation
+public class Flow implements DeletedInterface {
+
+    @NotNull
+    @NotBlank
+    @Pattern(regexp = "[a-zA-Z0-9._-]+")
+    String id;
+
+    @NotNull
+    @Pattern(regexp = "[a-z0-9._-]+")
+    String namespace;
+
+    @With
+    @Min(value = 1)
+    Integer revision;
+
+    String description;
+
+    List<Label> labels;
+
+    Map<String, Object> variables;
+
+    @Valid
+    @NotEmpty
+    List<Task> tasks;
+
+    @Valid
+    List<Task> errors;
+
+    @Valid
+    List<Listener> listeners;
+
+    @Valid
+    List<AbstractTrigger> triggers;
+
+    List<TaskDefault> taskDefaults;
+
+    @NotNull
+    @Builder.Default
+    boolean disabled = false;
+
+    @NotNull
+    @Builder.Default
+    boolean deleted = false;
+
+    public Logger logger() {
+        return LoggerFactory.getLogger("flow." + this.id);
+    }
+
+    public static String uid(String namespace, String id, Optional<Integer> revision) {
+        return String.join("_", Arrays.asList(
+            namespace,
+            id,
+            String.valueOf(revision.orElse(-1))
+        ));
+    }
+
+    public static String uidWithoutRevision(String namespace, String id) {
+        return String.join("_", Arrays.asList(
+            namespace,
+            id
+        ));
+    }
+
+    public Stream<String> allTypes() {
+        return Stream.of(
+                Optional.ofNullable(triggers).orElse(Collections.emptyList()).stream().map(AbstractTrigger::getType),
+                allTasks().map(Task::getType),
+                Optional.ofNullable(taskDefaults).orElse(Collections.emptyList()).stream().map(TaskDefault::getType)
+            ).reduce(Stream::concat).orElse(Stream.empty())
+            .distinct();
+    }
+
+    public Stream<Task> allTasks() {
+        return Stream.of(
+                this.tasks != null ? this.tasks : new ArrayList<Task>(),
+                this.errors != null ? this.errors : new ArrayList<Task>(),
+                this.listenersTasks()
+            )
+            .flatMap(Collection::stream);
+    }
+
+    public List<Task> allTasksWithChilds() {
+        return allTasks()
+            .flatMap(this::allTasksWithChilds)
+            .collect(Collectors.toList());
+    }
+
+    private Stream<Task> allTasksWithChilds(Task task) {
+        if (task == null) {
+            return Stream.empty();
+        } else if (task.isFlowable()) {
+            Stream<Task> taskStream = ((FlowableTask<?>) task).allChildTasks()
+                .stream()
+                .flatMap(this::allTasksWithChilds);
+
+            return Stream.concat(
+                Stream.of(task),
+                taskStream
+            );
+        } else {
+            return Stream.of(task);
+        }
+    }
+
+    public List<String> allTriggerIds() {
+        return this.triggers != null ? this.triggers.stream()
+            .map(AbstractTrigger::getId)
+            .collect(Collectors.toList()) : new ArrayList<>();
+    }
+
+    public List<String> allTasksWithChildsAndTriggerIds() {
+        return Stream.concat(
+            this.allTasksWithChilds().stream()
+                .map(Task::getId),
+            this.allTriggerIds().stream()
+        )
+            .collect(Collectors.toList());
+    }
+
+    public List<Task> allErrorsWithChilds() {
+        var allErrors = allTasksWithChilds().stream()
+            .filter(task -> task.isFlowable() && ((FlowableTask<?>) task).getErrors() != null)
+            .flatMap(task -> ((FlowableTask<?>) task).getErrors().stream())
+            .collect(Collectors.toCollection(ArrayList::new));
+
+        if (this.getErrors() != null && !this.getErrors().isEmpty()) {
+            allErrors.addAll(this.getErrors());
+        }
+
+        return allErrors;
+    }
+
+
+    private List<Task> listenersTasks() {
+        if (this.getListeners() == null) {
+            return new ArrayList<>();
+        }
+
+        return this.getListeners()
+            .stream()
+            .flatMap(listener -> listener.getTasks().stream())
+            .collect(Collectors.toList());
+    }
+
+    public Flow toDeleted() {
+        return new Flow(
+            this.id,
+            this.namespace,
+            this.revision + 1,
+            this.description,
+            this.labels,
+            this.variables,
+            this.tasks,
+            this.errors,
+            this.listeners,
+            this.triggers,
+            this.taskDefaults,
+            this.disabled,
+            true
+        );
+    }
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/model/FlowWithException.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/FlowWithException.java
new file mode 100644
index 00000000..d9235352
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/FlowWithException.java
@@ -0,0 +1,20 @@
+package io.micronaut.docs.validation.path.model;
+
+import io.micronaut.core.annotation.Introspected;
+import lombok.AllArgsConstructor;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+import lombok.experimental.SuperBuilder;
+
+@SuperBuilder(toBuilder = true)
+@Getter
+@AllArgsConstructor
+@NoArgsConstructor
+@Introspected
+@ToString
+@EqualsAndHashCode
+public class FlowWithException extends FlowWithSource {
+    String exception;
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/model/FlowWithSource.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/FlowWithSource.java
new file mode 100644
index 00000000..b1a77647
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/FlowWithSource.java
@@ -0,0 +1,62 @@
+package io.micronaut.docs.validation.path.model;
+
+import io.micronaut.core.annotation.Introspected;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+import lombok.experimental.SuperBuilder;
+import lombok.extern.slf4j.Slf4j;
+
+@SuperBuilder(toBuilder = true)
+@Getter
+@AllArgsConstructor
+@NoArgsConstructor
+@Introspected
+@ToString
+@Slf4j
+public class FlowWithSource extends Flow {
+    String source;
+
+    public Flow toFlow() {
+        return Flow.builder()
+            .id(this.id)
+            .namespace(this.namespace)
+            .revision(this.revision)
+            .description(this.description)
+            .labels(this.labels)
+            .variables(this.variables)
+            .tasks(this.tasks)
+            .errors(this.errors)
+            .listeners(this.listeners)
+            .triggers(this.triggers)
+            .taskDefaults(this.taskDefaults)
+            .disabled(this.disabled)
+            .deleted(this.deleted)
+            .build();
+    }
+
+    private static String cleanupSource(String source) {
+        return source.replaceFirst("(?m)^revision: \\d+\n?","");
+    }
+
+
+    public static FlowWithSource of(Flow flow, String source) {
+        return FlowWithSource.builder()
+            .id(flow.id)
+            .namespace(flow.namespace)
+            .revision(flow.revision)
+            .description(flow.description)
+            .labels(flow.labels)
+            .variables(flow.variables)
+            .tasks(flow.tasks)
+            .errors(flow.errors)
+            .listeners(flow.listeners)
+            .triggers(flow.triggers)
+            .taskDefaults(flow.taskDefaults)
+            .disabled(flow.disabled)
+            .deleted(flow.deleted)
+            .source(source)
+            .build();
+    }
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/model/FlowableTask.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/FlowableTask.java
new file mode 100644
index 00000000..c3d7c2ee
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/FlowableTask.java
@@ -0,0 +1,9 @@
+package io.micronaut.docs.validation.path.model;
+
+import java.util.List;
+
+public interface FlowableTask<T extends Output> {
+    List<Task> getErrors();
+
+    List<Task> allChildTasks();
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Label.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Label.java
new file mode 100644
index 00000000..bb402b45
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Label.java
@@ -0,0 +1,5 @@
+package io.micronaut.docs.validation.path.model;
+
+import jakarta.validation.constraints.NotNull;
+
+public record Label(@NotNull String key, @NotNull String value) {}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Listener.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Listener.java
new file mode 100644
index 00000000..fc2d531e
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Listener.java
@@ -0,0 +1,23 @@
+package io.micronaut.docs.validation.path.model;
+
+import io.micronaut.core.annotation.Introspected;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotEmpty;
+import lombok.Builder;
+import lombok.Value;
+
+import java.util.List;
+
+@Value
+@Builder
+@Introspected
+public class Listener {
+    String description;
+
+    @Valid
+    List<Condition> conditions;
+
+    @Valid
+    @NotEmpty
+    List<Task> tasks;
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Log.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Log.java
new file mode 100644
index 00000000..77f5bd0f
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Log.java
@@ -0,0 +1,27 @@
+package io.micronaut.docs.validation.path.model;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+import lombok.experimental.SuperBuilder;
+import org.slf4j.event.Level;
+
+@SuperBuilder
+@ToString
+@EqualsAndHashCode
+@Getter
+@NoArgsConstructor
+public class Log extends Task {
+    @NotNull
+    @NotBlank
+    private Object message;
+
+    @Builder.Default
+    private Level level = Level.INFO;
+}
+
+
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Output.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Output.java
new file mode 100644
index 00000000..e6eb99d3
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Output.java
@@ -0,0 +1,9 @@
+package io.micronaut.docs.validation.path.model;
+
+import java.util.Optional;
+
+public interface Output {
+    default Optional<State.Type> finalState() {
+        return Optional.empty();
+    }
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/model/State.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/State.java
new file mode 100644
index 00000000..1eda58fc
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/State.java
@@ -0,0 +1,167 @@
+package io.micronaut.docs.validation.path.model;
+
+import io.micronaut.core.annotation.Introspected;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
+import lombok.Value;
+import lombok.extern.slf4j.Slf4j;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+@Value
+@Slf4j
+@Introspected
+public class State {
+    @NotNull
+    Type current;
+
+    @Valid
+    List<History> histories;
+
+    public State() {
+        this.current = Type.CREATED;
+        this.histories = new ArrayList<>();
+        this.histories.add(new History(this.current, Instant.now()));
+    }
+
+    public State(Type type) {
+        this.current = type;
+        this.histories = new ArrayList<>();
+        this.histories.add(new History(this.current, Instant.now()));
+    }
+
+    public State(State state, Type type) {
+        this.current = type;
+        this.histories = state.histories;
+        this.histories.add(new History(this.current, Instant.now()));
+    }
+
+    public State(Type state, State actual) {
+        this.current = state;
+        this.histories = new ArrayList<>(actual.histories);
+        this.histories.add(new History(this.current, Instant.now()));
+    }
+
+    public static State of(Type state, List<History> histories) {
+        State result = new State(state);
+
+        result.histories.removeIf(history -> true);
+        result.histories.addAll(histories);
+
+        return result;
+    }
+
+    public State withState(Type state) {
+        if (this.current == state) {
+            log.warn("Can't change state, already " + current);
+            return this;
+        }
+
+        return new State(state, this);
+    }
+
+    public Duration getDuration() {
+        return Duration.between(
+            this.histories.get(0).getDate(),
+            this.histories.size() > 1 ? this.histories.get(this.histories.size() - 1).getDate() : Instant.now()
+        );
+    }
+
+    public Instant getStartDate() {
+        return this.histories.get(0).getDate();
+    }
+
+    public Optional<Instant> getEndDate() {
+        if (!this.isTerminated() && !this.isPaused()) {
+            return Optional.empty();
+        }
+
+        return Optional.of(this.histories.get(this.histories.size() - 1).getDate());
+    }
+
+    public Instant maxDate() {
+        if (this.histories.size() == 0) {
+            return Instant.now();
+        }
+
+        return this.histories.get(this.histories.size() - 1).getDate();
+    }
+
+    public boolean isTerminated() {
+        return this.current.isTerminated();
+    }
+
+    public boolean isRunning() {
+        return this.current.isRunning();
+    }
+
+    public boolean isCreated() {
+        return this.current.isCreated();
+    }
+
+    public static Type[] runningTypes() {
+        return Arrays.stream(Type.values())
+            .filter(type -> type.isRunning() || type.isCreated())
+            .toArray(Type[]::new);
+    }
+
+    public boolean isFailed() {
+        return this.current.isFailed();
+    }
+
+    public boolean isPaused() {
+        return this.current.isPaused();
+    }
+
+    public boolean isRestartable() {
+        return this.current.isFailed() || this.isPaused();
+    }
+
+
+    @Introspected
+    public enum Type {
+        CREATED,
+        RUNNING,
+        PAUSED,
+        RESTARTED,
+        KILLING,
+        SUCCESS,
+        WARNING,
+        FAILED,
+        KILLED;
+
+        public boolean isTerminated() {
+            return this == Type.FAILED || this == Type.WARNING || this == Type.SUCCESS || this == Type.KILLED;
+        }
+
+        public boolean isCreated() {
+            return this == Type.CREATED || this == Type.RESTARTED;
+        }
+
+        public boolean isRunning() {
+            return this == Type.RUNNING || this == Type.KILLING;
+        }
+
+        public boolean isFailed() {
+            return this == Type.FAILED;
+        }
+
+        public boolean isPaused() {
+            return this == Type.PAUSED;
+        }
+    }
+
+    @Value
+    public static class History {
+        @NotNull
+        Type state;
+
+        @NotNull
+        Instant date;
+    }
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Task.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Task.java
new file mode 100644
index 00000000..54130f7a
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/Task.java
@@ -0,0 +1,66 @@
+package io.micronaut.docs.validation.path.model;
+
+import io.micronaut.core.annotation.Introspected;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Pattern;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+import java.time.Duration;
+import java.util.Optional;
+
+@SuperBuilder(toBuilder = true)
+@Getter
+@NoArgsConstructor
+@Introspected
+abstract public class Task {
+    @NotNull
+    @NotBlank
+    @Pattern(regexp="[a-zA-Z0-9_-]+")
+    protected String id;
+
+    @NotNull
+    @NotBlank
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
+    protected String type;
+
+    private String description;
+
+    protected Duration timeout;
+
+    @Builder.Default
+    protected Boolean disabled = false;
+
+    @Valid
+    private WorkerGroup workerGroup;
+
+    public Optional<Task> findById(String id) {
+        if (this.getId().equals(id)) {
+            return Optional.of(this);
+        }
+
+        if (this.isFlowable()) {
+            Optional<Task> childs = ((FlowableTask<?>) this).allChildTasks()
+                .stream()
+                .map(t -> t.findById(id))
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .findFirst();
+
+            if (childs.isPresent()) {
+                return childs;
+            }
+        }
+
+        return Optional.empty();
+    }
+
+    public boolean isFlowable() {
+        return this instanceof FlowableTask;
+    }
+
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/model/TaskDefault.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/TaskDefault.java
new file mode 100644
index 00000000..aec56ab8
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/TaskDefault.java
@@ -0,0 +1,23 @@
+package io.micronaut.docs.validation.path.model;
+
+import io.micronaut.core.convert.format.MapFormat;
+import io.micronaut.core.naming.conventions.StringConvention;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+
+import java.util.Map;
+
+@Getter
+@Builder(toBuilder = true)
+@AllArgsConstructor
+public class TaskDefault {
+    private final String type;
+
+    @Builder.Default
+    private final boolean forced = false;
+
+    @MapFormat(transformation = MapFormat.MapTransformation.NESTED, keyFormat = StringConvention.CAMEL_CASE)
+    private final Map<String, Object> values;
+}
+
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/model/WorkerGroup.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/WorkerGroup.java
new file mode 100644
index 00000000..b97255b3
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/model/WorkerGroup.java
@@ -0,0 +1,18 @@
+package io.micronaut.docs.validation.path.model;
+
+import io.micronaut.core.annotation.Introspected;
+import io.micronaut.docs.validation.path.validations.WorkerGroupValidation;
+import jakarta.validation.constraints.Pattern;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@NoArgsConstructor
+@AllArgsConstructor
+@Introspected
+@WorkerGroupValidation
+public class WorkerGroup {
+    @Pattern(regexp="[a-zA-Z0-9_-]+")
+    private String key;
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/DagTaskValidation.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/DagTaskValidation.java
new file mode 100644
index 00000000..b49353f1
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/DagTaskValidation.java
@@ -0,0 +1,13 @@
+package io.micronaut.docs.validation.path.validations;
+
+import io.micronaut.docs.validation.path.validations.validator.DagTaskValidator;
+import jakarta.validation.Constraint;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Constraint(validatedBy = DagTaskValidator.class)
+public @interface DagTaskValidation {
+    String message() default "invalid Dag task";
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/DateFormat.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/DateFormat.java
new file mode 100644
index 00000000..8482761d
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/DateFormat.java
@@ -0,0 +1,13 @@
+package io.micronaut.docs.validation.path.validations;
+
+import io.micronaut.docs.validation.path.validations.validator.DateTimeValidator;
+import jakarta.validation.Constraint;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Constraint(validatedBy = DateTimeValidator.class)
+public @interface DateFormat {
+    String message() default "invalid date format value";
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/FlowValidation.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/FlowValidation.java
new file mode 100644
index 00000000..9aefc260
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/FlowValidation.java
@@ -0,0 +1,13 @@
+package io.micronaut.docs.validation.path.validations;
+
+import io.micronaut.docs.validation.path.validations.validator.FlowValidator;
+import jakarta.validation.Constraint;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Constraint(validatedBy = FlowValidator.class)
+public @interface FlowValidation {
+    String message() default "invalid Flow";
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/Regex.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/Regex.java
new file mode 100644
index 00000000..2650a044
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/Regex.java
@@ -0,0 +1,13 @@
+package io.micronaut.docs.validation.path.validations;
+
+import io.micronaut.docs.validation.path.validations.validator.PatternValidator;
+import jakarta.validation.Constraint;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Constraint(validatedBy = PatternValidator.class)
+public @interface Regex {
+    String message() default "invalid pattern ({validatedValue})";
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/WorkerGroupValidation.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/WorkerGroupValidation.java
new file mode 100644
index 00000000..4824b7c8
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/WorkerGroupValidation.java
@@ -0,0 +1,13 @@
+package io.micronaut.docs.validation.path.validations;
+
+import io.micronaut.docs.validation.path.validations.validator.WorkerGroupValidator;
+import jakarta.validation.Constraint;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Constraint(validatedBy = WorkerGroupValidator.class)
+public @interface WorkerGroupValidation {
+    String message() default "invalid workerGroup property";
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/validator/DagTaskValidator.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/validator/DagTaskValidator.java
new file mode 100644
index 00000000..047b0bee
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/validator/DagTaskValidator.java
@@ -0,0 +1,55 @@
+package io.micronaut.docs.validation.path.validations.validator;
+
+import io.micronaut.core.annotation.AnnotationValue;
+import io.micronaut.core.annotation.Introspected;
+import io.micronaut.core.annotation.NonNull;
+import io.micronaut.core.annotation.Nullable;
+import io.micronaut.docs.validation.path.model.Dag;
+import io.micronaut.docs.validation.path.validations.DagTaskValidation;
+import io.micronaut.validation.validator.constraints.ConstraintValidator;
+import io.micronaut.validation.validator.constraints.ConstraintValidatorContext;
+import jakarta.inject.Singleton;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Singleton
+@Introspected
+public class DagTaskValidator implements ConstraintValidator<DagTaskValidation, Dag> {
+    @Override
+    public boolean isValid(
+        @Nullable Dag value,
+        @NonNull AnnotationValue<DagTaskValidation> annotationMetadata,
+        @NonNull ConstraintValidatorContext context) {
+        if (value == null) {
+            return true;
+        }
+
+        if (value.getTasks() == null || value.getTasks().isEmpty()) {
+            context.messageTemplate("No task defined");
+
+            return false;
+        }
+
+        List<Dag.DagTask> taskDepends = value.getTasks();
+
+        // Check for not existing taskId
+        List<String> invalidDependencyIds = value.dagCheckNotExistTask(taskDepends);
+        if (!invalidDependencyIds.isEmpty()) {
+            String errorMessage = "Not existing task id in dependency: " + String.join(", ", invalidDependencyIds);
+            context.messageTemplate(errorMessage);
+
+            return false;
+        }
+
+        // Check for cyclic dependencies
+        ArrayList<String> cyclicDependency = value.dagCheckCyclicDependencies(taskDepends);
+        if (!cyclicDependency.isEmpty()) {
+            context.messageTemplate("Cyclic dependency detected: " + String.join(", ", cyclicDependency));
+
+            return false;
+        }
+
+        return true;
+    }
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/validator/DateTimeValidator.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/validator/DateTimeValidator.java
new file mode 100644
index 00000000..48fb8b36
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/validator/DateTimeValidator.java
@@ -0,0 +1,38 @@
+package io.micronaut.docs.validation.path.validations.validator;
+
+import io.micronaut.core.annotation.AnnotationValue;
+import io.micronaut.core.annotation.Introspected;
+import io.micronaut.core.annotation.NonNull;
+import io.micronaut.core.annotation.Nullable;
+import io.micronaut.docs.validation.path.validations.DateFormat;
+import io.micronaut.validation.validator.constraints.ConstraintValidator;
+import io.micronaut.validation.validator.constraints.ConstraintValidatorContext;
+import jakarta.inject.Singleton;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+@Singleton
+@Introspected
+public class DateTimeValidator implements ConstraintValidator<DateFormat, String> {
+    @Override
+    public boolean isValid(
+        @Nullable String value,
+        @NonNull AnnotationValue<DateFormat> annotationMetadata,
+        @NonNull ConstraintValidatorContext context) {
+        if (value == null) {
+            return true; // nulls are allowed according to spec
+        }
+
+        try {
+            Date now = new Date();
+            SimpleDateFormat dateFormat = new SimpleDateFormat(value);
+            dateFormat.format(now);
+        } catch (Exception e) {
+            context.messageTemplate("invalid date format value '({validatedValue})': " + e.getMessage());
+
+            return false;
+        }
+        return true;
+    }
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/validator/FlowValidator.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/validator/FlowValidator.java
new file mode 100644
index 00000000..3da25fa7
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/validator/FlowValidator.java
@@ -0,0 +1,53 @@
+package io.micronaut.docs.validation.path.validations.validator;
+
+import io.micronaut.core.annotation.AnnotationValue;
+import io.micronaut.core.annotation.Introspected;
+import io.micronaut.core.annotation.NonNull;
+import io.micronaut.core.annotation.Nullable;
+import io.micronaut.docs.validation.path.model.Flow;
+import io.micronaut.docs.validation.path.model.Task;
+import io.micronaut.docs.validation.path.validations.FlowValidation;
+import io.micronaut.validation.validator.constraints.ConstraintValidator;
+import io.micronaut.validation.validator.constraints.ConstraintValidatorContext;
+import jakarta.inject.Singleton;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+@Singleton
+@Introspected
+public class FlowValidator  implements ConstraintValidator<FlowValidation, Flow> {
+    @Override
+    public boolean isValid(
+        @Nullable Flow value,
+        @NonNull AnnotationValue<FlowValidation> annotationMetadata,
+        @NonNull ConstraintValidatorContext context) {
+        if (value == null) {
+            return true;
+        }
+
+        List<String> violations = new ArrayList<>();
+
+        // task unique id
+        List<String> taskIds = value.allTasksWithChilds()
+            .stream()
+            .map(Task::getId)
+            .toList();
+        List<String> taskDuplicates = taskIds
+            .stream()
+            .distinct()
+            .filter(entry -> Collections.frequency(taskIds, entry) > 1)
+            .toList();
+        if (!taskDuplicates.isEmpty()) {
+            violations.add("Duplicate task id with name [" + String.join(", ", taskDuplicates) + "]");
+        }
+
+        if (!violations.isEmpty()) {
+            context.messageTemplate("Invalid Flow: " + String.join(", ", violations));
+            return false;
+        } else {
+            return true;
+        }
+    }
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/validator/PatternValidator.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/validator/PatternValidator.java
new file mode 100644
index 00000000..66ef5b73
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/validator/PatternValidator.java
@@ -0,0 +1,36 @@
+package io.micronaut.docs.validation.path.validations.validator;
+
+import io.micronaut.core.annotation.AnnotationValue;
+import io.micronaut.core.annotation.Introspected;
+import io.micronaut.core.annotation.NonNull;
+import io.micronaut.core.annotation.Nullable;
+import io.micronaut.docs.validation.path.validations.Regex;
+import io.micronaut.validation.validator.constraints.ConstraintValidator;
+import io.micronaut.validation.validator.constraints.ConstraintValidatorContext;
+import jakarta.inject.Singleton;
+
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+
+@Singleton
+@Introspected
+public class PatternValidator  implements ConstraintValidator<Regex, String> {
+    @Override
+    public boolean isValid(
+        @Nullable String value,
+        @NonNull AnnotationValue<Regex> annotationMetadata,
+        @NonNull ConstraintValidatorContext context) {
+        if (value == null) {
+            return true;
+        }
+
+        try {
+            Pattern.compile(value);
+        } catch(PatternSyntaxException e) {
+            context.messageTemplate("invalid pattern [" + value + "]");
+            return false;
+        }
+
+        return true;
+    }
+}
diff --git a/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/validator/WorkerGroupValidator.java b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/validator/WorkerGroupValidator.java
new file mode 100644
index 00000000..a29d83d4
--- /dev/null
+++ b/test-suite/src/test/java/io/micronaut/docs/validation/path/validations/validator/WorkerGroupValidator.java
@@ -0,0 +1,28 @@
+package io.micronaut.docs.validation.path.validations.validator;
+
+import io.micronaut.core.annotation.AnnotationValue;
+import io.micronaut.core.annotation.Introspected;
+import io.micronaut.core.annotation.NonNull;
+import io.micronaut.core.annotation.Nullable;
+import io.micronaut.docs.validation.path.model.WorkerGroup;
+import io.micronaut.docs.validation.path.validations.WorkerGroupValidation;
+import io.micronaut.validation.validator.constraints.ConstraintValidator;
+import io.micronaut.validation.validator.constraints.ConstraintValidatorContext;
+import jakarta.inject.Singleton;
+
+@Singleton
+@Introspected
+public class WorkerGroupValidator  implements ConstraintValidator<WorkerGroupValidation, WorkerGroup> {
+    @Override
+    public boolean isValid(
+        @Nullable WorkerGroup value,
+        @NonNull AnnotationValue<WorkerGroupValidation> annotationMetadata,
+        @NonNull ConstraintValidatorContext context) {
+        if (value == null) {
+            return true;
+        }
+
+        context.messageTemplate("Worker Group is an Enterprise Edition functionality");
+        return false;
+    }
+}