diff --git a/src/validation.c b/src/validation.c
index 96246cd..970401c 100644
--- a/src/validation.c
+++ b/src/validation.c
@@ -74,15 +74,15 @@
 /**
  * @brief Evaluate a single "when" condition.
  *
- * @param[in] when When to evaluate.
+ * @param[in,out] tree Data tree, is updated if some nodes are autodeleted.
  * @param[in] node Node whose existence depends on this when.
- * @param[in] tree Data tree.
+ * @param[in] when When to evaluate.
  * @return LY_ERR value (LY_EINCOMPLETE if a referenced node does not have its when evaluated)
  */
 static LY_ERR
-lyd_val_when(struct lysc_when *when, struct lyd_node *node, const struct lyd_node *tree)
+lyd_val_when(struct lyd_node **tree, struct lyd_node *node, struct lysc_when *when)
 {
-    LY_ERR ret;
+    LY_ERR ret = LY_SUCCESS;
     const struct lyd_node *ctx_node;
     struct lyxp_set xp_set;
 
@@ -97,7 +97,7 @@
 
     /* evaluate when */
     ret = lyxp_eval(when->cond, LYD_UNKNOWN, when->module, ctx_node, ctx_node ? LYXP_NODE_ELEM : LYXP_NODE_ROOT_CONFIG,
-                    tree, &xp_set, LYXP_SCHEMA);
+                    *tree, &xp_set, LYXP_SCHEMA);
     lyxp_set_cast(&xp_set, LYXP_SET_BOOLEAN);
 
     /* return error or LY_EINCOMPLETE for dependant unresolved when */
@@ -107,6 +107,9 @@
     if (!xp_set.val.bool) {
         if (node->flags & LYD_WHEN_TRUE) {
             /* autodelete */
+            if (LYD_DEL_IS_ROOT(*tree, node)) {
+                *tree = (*tree)->next;
+            }
             lyd_free_tree(node);
         } else {
             /* invalid data */
@@ -122,107 +125,319 @@
 }
 
 LY_ERR
-lyd_validate_unres(struct ly_set *node_types, struct ly_set *attr_types, struct ly_set *node_when, LYD_FORMAT format,
-                   ly_clb_resolve_prefix get_prefix_clb, void *parser_data, const struct lyd_node *tree)
+lyd_validate_unres(struct lyd_node **tree, struct ly_set *node_when, struct ly_set *node_types, struct ly_set *attr_types,
+                   LYD_FORMAT format, ly_clb_resolve_prefix get_prefix_clb, void *parser_data)
 {
     LY_ERR ret = LY_SUCCESS;
     uint32_t u;
 
-    /* finish incompletely validated terminal values */
-    for (u = 0; node_types && (u < node_types->count); u++) {
-        struct lyd_node_term *node = (struct lyd_node_term *)node_types->objs[u];
+    if (node_when) {
+        /* evaluate all when conditions */
+        uint32_t prev_count;
+        do {
+            prev_count = node_when->count;
+            u = 0;
+            while (u < node_when->count) {
+                /* evaluate all when expressions that affect this node's existence */
+                struct lyd_node *node = (struct lyd_node *)node_when->objs[u];
+                const struct lysc_node *schema = node->schema;
+                int unres_when = 0;
 
-        /* validate and store the value of the node */
-        ret = lyd_value_parse(node, node->value.original, strlen(node->value.original), 0, 1, get_prefix_clb,
-                            parser_data, format, tree);
-        LY_CHECK_RET(ret);
-    }
-
-    /* ... and attribute values */
-    for (u = 0; attr_types && (u < attr_types->count); u++) {
-        struct lyd_attr *attr = (struct lyd_attr *)attr_types->objs[u];
-
-        /* validate and store the value of the node */
-        ret = lyd_value_parse_attr(attr->parent->schema->module->ctx, attr, attr->value.original,
-                                   strlen(attr->value.original), 0, 1, get_prefix_clb, parser_data, format, NULL, tree);
-        LY_CHECK_RET(ret);
-    }
-
-    /* no when conditions */
-    if (!node_when || !node_when->count) {
-        return ret;
-    }
-
-    /* evaluate all when conditions */
-    uint32_t prev_count;
-    do {
-        prev_count = node_when->count;
-        u = 0;
-        while (u < node_when->count) {
-            /* evaluate all when expressions that affect this node's existence */
-            struct lyd_node *node = (struct lyd_node *)node_when->objs[u];
-            const struct lysc_node *schema = node->schema;
-            int unres_when = 0;
-
-            do {
-                uint32_t i;
-                LY_ARRAY_FOR(schema->when, i) {
-                    ret = lyd_val_when(schema->when[i], node, tree);
-                    if (ret) {
-                        break;
+                do {
+                    uint32_t i;
+                    LY_ARRAY_FOR(schema->when, i) {
+                        ret = lyd_val_when(tree, node, schema->when[i]);
+                        if (ret) {
+                            break;
+                        }
                     }
-                }
-                if (ret == LY_EINCOMPLETE) {
-                    /* could not evaluate this when */
-                    unres_when = 1;
-                    break;
-                } else if (ret) {
-                    /* error */
-                    return ret;
-                }
-                schema = schema->parent;
-            } while (schema && (schema->nodetype & (LYS_CASE | LYS_CHOICE)));
+                    if (ret == LY_EINCOMPLETE) {
+                        /* could not evaluate this when */
+                        unres_when = 1;
+                        break;
+                    } else if (ret) {
+                        /* error */
+                        return ret;
+                    }
+                    schema = schema->parent;
+                } while (schema && (schema->nodetype & (LYS_CASE | LYS_CHOICE)));
 
-            if (unres_when) {
-                /* keep in set and go to the next node */
-                ++u;
-            } else {
-                /* remove this node from the set */
-                ly_set_rm_index(node_when, u, NULL);
+                if (unres_when) {
+                    /* keep in set and go to the next node */
+                    ++u;
+                } else {
+                    /* remove this node from the set */
+                    ly_set_rm_index(node_when, u, NULL);
+                }
             }
-        }
 
-    /* there must have been some when conditions resolved */
-    } while (prev_count > node_when->count);
+        /* there must have been some when conditions resolved */
+        } while (prev_count > node_when->count);
 
-    /* there could have been no cyclic when dependencies, checked during compilation */
-    assert(!node_when->count);
+        /* there could have been no cyclic when dependencies, checked during compilation */
+        assert(!node_when->count);
+    }
+
+    if (node_types && node_types->count) {
+        /* finish incompletely validated terminal values (traverse from the end for efficient set removal) */
+        u = node_types->count;
+        do {
+            --u;
+
+            struct lyd_node_term *node = (struct lyd_node_term *)node_types->objs[u];
+
+            /* validate and store the value of the node */
+            ret = lyd_value_parse(node, node->value.original, strlen(node->value.original), 0, 1, get_prefix_clb,
+                                  parser_data, format, *tree);
+            LY_CHECK_RET(ret);
+
+            /* remove this node from the set */
+            ly_set_rm_index(node_types, u, NULL);
+        } while (u);
+    }
+
+    if (attr_types && attr_types->count) {
+        /* ... and attribute values */
+        u = attr_types->count;
+        do {
+            --u;
+
+            struct lyd_attr *attr = (struct lyd_attr *)attr_types->objs[u];
+
+            /* validate and store the value of the node */
+            ret = lyd_value_parse_attr(attr->parent->schema->module->ctx, attr, attr->value.original,
+                                    strlen(attr->value.original), 0, 1, get_prefix_clb, parser_data, format, NULL, *tree);
+            LY_CHECK_RET(ret);
+
+            /* remove this attr from the set */
+            ly_set_rm_index(attr_types, u, NULL);
+        } while (u);
+    }
 
     return ret;
 }
 
-static const struct lys_module *
-lyd_val_next_module(const struct lys_module **modules, int mod_count, struct ly_ctx *ctx, uint32_t *i)
+static LY_ERR
+lyd_validate_duplicates(const struct lyd_node *first, const struct lyd_node *node)
 {
-    if (modules && mod_count) {
-        return modules[(*i)++];
+    struct lyd_node **match_p;
+    int fail = 0;
+
+    if ((node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) && (node->schema->flags & LYS_CONFIG_R)) {
+        /* duplicate instances allowed */
+        return LY_SUCCESS;
     }
 
-    return ly_ctx_get_module_iter(ctx, i);
+    /* find exactly the same next instance using hashes if possible */
+    if (node->parent && node->parent->children_ht) {
+        if (!lyht_find_next(node->parent->children_ht, &node, node->hash, (void **)&match_p)) {
+            fail = 1;
+        }
+    } else {
+        for (; first; first = first->next) {
+            if (first == node) {
+                continue;
+            }
+
+            if (node->schema->nodetype & (LYD_NODE_ANY | LYS_LEAF)) {
+                if (first->schema == node->schema) {
+                    fail = 1;
+                    break;
+                }
+            } else if (!lyd_compare(first, node, 0)) {
+                fail = 1;
+                break;
+            }
+        }
+    }
+
+    if (fail) {
+        LOGVAL(node->schema->module->ctx, LY_VLOG_LYD, node, LY_VCODE_DUP, node->schema->name);
+        return LY_EVALID;
+    }
+    return LY_SUCCESS;
 }
 
 static LY_ERR
-lyd_validate_mandatory(const struct lysc_node *snode, struct lyd_node *sibling)
+lyd_validate_cases(struct lyd_node **first, const struct lysc_node_choice *choic)
+{
+    const struct lysc_node *scase, *iter, *old_case = NULL, *new_case = NULL;
+    struct lyd_node *match, *to_del;
+    int found;
+
+    LY_LIST_FOR((struct lysc_node *)choic->cases, scase) {
+        found = 0;
+        iter = NULL;
+        match = NULL;
+        while ((match = lys_getnext_data(match, *first, &iter, scase, NULL))) {
+            if (match->flags & LYD_NEW) {
+                /* a new case data found, nothing more to look for */
+                found = 2;
+                break;
+            } else {
+                /* and old case data found */
+                if (found == 0) {
+                    found = 1;
+                }
+            }
+        }
+
+        if (found == 1) {
+            /* there should not be 2 old cases */
+            if (old_case) {
+                /* old data from 2 cases */
+                LOGVAL(choic->module->ctx, LY_VLOG_LYSC, choic, LY_VCODE_DUPCASE, old_case->name, scase->name);
+                return LY_EVALID;
+            }
+
+            /* remember an old existing case */
+            old_case = scase;
+        } else if (found == 2) {
+            if (new_case) {
+                /* new data from 2 cases */
+                LOGVAL(choic->module->ctx, LY_VLOG_LYSC, choic, LY_VCODE_DUPCASE, new_case->name, scase->name);
+                return LY_EVALID;
+            }
+
+            /* remember a new existing case */
+            new_case = scase;
+        }
+    }
+
+    if (old_case && new_case) {
+        /* auto-delete old case */
+        iter = NULL;
+        match = NULL;
+        to_del = NULL;
+        while ((match = lys_getnext_data(match, *first, &iter, old_case, NULL))) {
+            if (LYD_DEL_IS_ROOT(*first, to_del)) {
+                *first = (*first)->next;
+            }
+            lyd_free_tree(to_del);
+            to_del = match;
+        }
+        if (LYD_DEL_IS_ROOT(*first, to_del)) {
+            *first = (*first)->next;
+        }
+        lyd_free_tree(to_del);
+    }
+
+    return LY_SUCCESS;
+}
+
+static int
+lyd_val_has_default(const struct lysc_node *schema)
+{
+    switch (schema->nodetype) {
+    case LYS_LEAF:
+        if (((struct lysc_node_leaf *)schema)->dflt) {
+            return 1;
+        }
+        break;
+    case LYS_LEAFLIST:
+        if (((struct lysc_node_leaflist *)schema)->dflts) {
+            return 1;
+        }
+        break;
+    case LYS_CONTAINER:
+        if (!(schema->flags & LYS_PRESENCE)) {
+            return 1;
+        }
+        break;
+    default:
+        break;
+    }
+
+    return 0;
+}
+
+static void
+lyd_validate_autodel_dup(struct lyd_node **first, struct lyd_node *node, struct lyd_node **next_p)
+{
+    struct lyd_node *match, *next;
+
+    if (lyd_val_has_default(node->schema)) {
+        assert(node->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST | LYS_CONTAINER));
+        if (node->schema->nodetype == LYS_LEAFLIST) {
+            lyd_find_sibling_next2(*first, node->schema, NULL, 0, &match);
+        } else {
+            lyd_find_sibling_val(*first, node->schema, NULL, 0, &match);
+        }
+
+        while (match) {
+            next = match->next;
+            if ((match->flags & LYD_DEFAULT) && !(match->flags & LYD_NEW)) {
+                /* default instance found, remove it */
+                if (LYD_DEL_IS_ROOT(*first, match)) {
+                    *first = (*first)->next;
+                }
+                if (match == *next_p) {
+                    *next_p = (*next_p)->next;
+                }
+                lyd_free_tree(match);
+
+                /* remove only a single container/leaf default instance, if there are more, it is an error */
+                if (node->schema->nodetype & (LYS_LEAF | LYS_CONTAINER)) {
+                    break;
+                }
+            }
+
+            lyd_find_sibling_next2(next, node->schema, NULL, 0, &match);
+        }
+    }
+}
+
+LY_ERR
+lyd_validate_new(struct lyd_node **first, const struct lysc_node *sparent, const struct lys_module *mod)
+{
+    struct lyd_node *next, *node;
+    const struct lysc_node *snode = NULL;
+
+    assert(first && (sparent || mod));
+
+    while (*first && (snode = lys_getnext(snode, sparent, mod ? mod->compiled : NULL, LYS_GETNEXT_WITHCHOICE))) {
+        /* check case duplicites */
+        if (snode->nodetype == LYS_CHOICE) {
+            LY_CHECK_RET(lyd_validate_cases(first, (struct lysc_node_choice *)snode));
+        }
+    }
+
+    LY_LIST_FOR_SAFE(*first, next, node) {
+        if (mod && (lyd_top_node_module(node) != mod)) {
+            /* all top-level data from this module checked */
+            break;
+        }
+
+        if (!(node->flags & LYD_NEW)) {
+            /* check only new nodes */
+            continue;
+        }
+
+        /* remove old default(s) if it exists */
+        lyd_validate_autodel_dup(first, node, &next);
+
+        /* then check new node instance duplicities */
+        LY_CHECK_RET(lyd_validate_duplicates(*first, node));
+
+        /* this node is valid */
+        node->flags &= ~LYD_NEW;
+    }
+
+    return LY_SUCCESS;
+}
+
+static LY_ERR
+lyd_validate_mandatory(const struct lyd_node *first, const struct lysc_node *snode)
 {
     if (snode->nodetype == LYS_CHOICE) {
         /* some data of a choice case exist */
-        if (lys_getnext_data(NULL, sibling, NULL, snode, NULL)) {
+        if (lys_getnext_data(NULL, first, NULL, snode, NULL)) {
             return LY_SUCCESS;
         }
     } else {
         assert(snode->nodetype & (LYS_LEAF | LYS_CONTAINER | LYD_NODE_ANY));
 
-        if (!lyd_find_sibling_val(sibling, snode, NULL, 0, NULL)) {
+        if (!lyd_find_sibling_val(first, snode, NULL, 0, NULL)) {
             /* data instance found */
             return LY_SUCCESS;
         }
@@ -234,14 +449,14 @@
 }
 
 static LY_ERR
-lyd_validate_minmax(const struct lysc_node *snode, uint32_t min, uint32_t max, struct lyd_node *sibling)
+lyd_validate_minmax(const struct lyd_node *first, const struct lysc_node *snode, uint32_t min, uint32_t max)
 {
     uint32_t count = 0;
-    struct lyd_node *iter;
+    const struct lyd_node *iter;
 
     assert(min || max);
 
-    LY_LIST_FOR(sibling, iter) {
+    LY_LIST_FOR(first, iter) {
         if (iter->schema == snode) {
             ++count;
 
@@ -406,9 +621,9 @@
 }
 
 static LY_ERR
-lyd_validate_unique(const struct lysc_node *snode, struct lysc_node_leaf ***uniques, struct lyd_node *sibling)
+lyd_validate_unique(const struct lyd_node *first, const struct lysc_node *snode, struct lysc_node_leaf ***uniques)
 {
-    struct lyd_node *diter;
+    const struct lyd_node *diter;
     struct ly_set *set;
     uint32_t i, j, n = 0;
     LY_ERR ret = LY_SUCCESS;
@@ -424,9 +639,9 @@
     /* get all list instances */
     set = ly_set_new();
     LY_CHECK_ERR_RET(!set, LOGMEM(ctx), LY_EMEM);
-    LY_LIST_FOR(sibling, diter) {
+    LY_LIST_FOR(first, diter) {
         if (diter->schema == snode) {
-            ly_set_add(set, diter, LY_SET_OPT_USEASLIST);
+            ly_set_add(set, (void *)diter, LY_SET_OPT_USEASLIST);
         }
     }
 
@@ -517,71 +732,7 @@
 }
 
 static LY_ERR
-lyd_validate_cases(const struct lysc_node_choice *choic, struct lyd_node **sibling)
-{
-    const struct lysc_node *scase, *iter, *old_case = NULL, *new_case = NULL;
-    struct lyd_node *match, *to_del;
-    int found;
-
-    LY_LIST_FOR((struct lysc_node *)choic->cases, scase) {
-        found = 0;
-        iter = NULL;
-        match = NULL;
-        while ((match = lys_getnext_data(match, *sibling, &iter, scase, NULL))) {
-            if (match->flags & LYD_NEW) {
-                /* a new case data found, nothing more to look for */
-                found = 2;
-                break;
-            } else {
-                /* and old case data found */
-                if (found == 0) {
-                    found = 1;
-                }
-            }
-        }
-
-        if (found == 1) {
-            /* there cannot be 2 old cases */
-            assert(!old_case);
-
-            /* remember an old existing case */
-            old_case = scase;
-        } else if (found == 2) {
-            if (new_case) {
-                /* new data from 2 cases */
-                LOGVAL(choic->module->ctx, LY_VLOG_LYSC, choic, LY_VCODE_DUPCASE, new_case->name, scase->name);
-                return LY_EVALID;
-            }
-
-            /* remember a new existing case */
-            new_case = scase;
-        }
-    }
-
-    if (old_case && new_case) {
-        /* auto-delete old case */
-        iter = NULL;
-        match = NULL;
-        to_del = NULL;
-        while ((match = lys_getnext_data(match, *sibling, &iter, old_case, NULL))) {
-            if ((*sibling == to_del) && !(*sibling)->parent) {
-                *sibling = (*sibling)->next;
-            }
-            lyd_free_tree(to_del);
-            to_del = match;
-        }
-        if ((*sibling == to_del) && !(*sibling)->parent) {
-            *sibling = (*sibling)->next;
-        }
-        lyd_free_tree(to_del);
-    }
-
-    return LY_SUCCESS;
-}
-
-static LY_ERR
-lyd_validate_siblings_schema_r(struct lyd_node **sibling, const struct lysc_node *sparent, const struct lysc_module *mod,
-                               int options)
+lyd_validate_siblings_schema_r(const struct lyd_node *first, const struct lysc_node *sparent, const struct lysc_module *mod)
 {
     const struct lysc_node *snode = NULL;
     struct lysc_node_list *slist;
@@ -592,109 +743,42 @@
         if (snode->nodetype & (LYS_LIST | LYS_LEAFLIST)) {
             slist = (struct lysc_node_list *)snode;
             if (slist->min || slist->max) {
-                LY_CHECK_RET(lyd_validate_minmax(snode, slist->min, slist->max, *sibling));
+                LY_CHECK_RET(lyd_validate_minmax(first, snode, slist->min, slist->max));
             }
 
         /* check generic mandatory existence */
         } else if (snode->flags & LYS_MAND_TRUE) {
-            LY_CHECK_RET(lyd_validate_mandatory(snode, *sibling));
+            LY_CHECK_RET(lyd_validate_mandatory(first, snode));
         }
 
         /* check unique */
         if (snode->nodetype == LYS_LIST) {
             slist = (struct lysc_node_list *)snode;
             if (slist->uniques) {
-                LY_CHECK_RET(lyd_validate_unique(snode, slist->uniques, *sibling));
+                LY_CHECK_RET(lyd_validate_unique(first, snode, slist->uniques));
             }
         }
 
-        /* check case duplicites */
-        if (snode->nodetype == LYS_CHOICE) {
-            LY_CHECK_RET(lyd_validate_cases((struct lysc_node_choice *)snode, sibling));
-        }
-
         if (snode->nodetype & (LYS_CHOICE | LYS_CASE)) {
             /* go recursively for schema-only nodes */
-            LY_CHECK_RET(lyd_validate_siblings_schema_r(sibling, snode, mod, options));
+            LY_CHECK_RET(lyd_validate_siblings_schema_r(first, snode, mod));
         }
     }
 
     return LY_SUCCESS;
 }
 
-static LY_ERR
-lyd_validate_dup_nodes(struct lyd_node *sibling, struct lyd_node *node)
+LY_ERR
+lyd_validate_siblings_r(struct lyd_node *first, const struct lysc_node *sparent, const struct lys_module *mod,
+                        int val_opts)
 {
-    struct lyd_node **match_p;
-    int fail = 0;
-
-    if ((node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) && (node->schema->flags & LYS_CONFIG_R)) {
-        /* duplicate instances allowed */
-        return LY_SUCCESS;
-    }
-
-    /* find exactly the same next instance using hashes if possible */
-    if (node->parent && node->parent->children_ht) {
-        if (!lyht_find_next(node->parent->children_ht, &node, node->hash, (void **)&match_p)) {
-            fail = 1;
-        }
-    } else {
-        for (; sibling; sibling = sibling->next) {
-            if (sibling == node) {
-                continue;
-            }
-
-            if (node->schema->nodetype & (LYD_NODE_ANY | LYS_LEAF)) {
-                if (sibling->schema == node->schema) {
-                    fail = 1;
-                    break;
-                }
-            } else if (!lyd_compare(sibling, node, 0)) {
-                fail = 1;
-                break;
-            }
-        }
-    }
-
-    if (fail) {
-        LOGVAL(node->schema->module->ctx, LY_VLOG_LYD, node, LY_VCODE_DUP, node->schema->name);
-        return LY_EVALID;
-    }
-    return LY_SUCCESS;
-}
-
-static LY_ERR
-lyd_validate_siblings_r(struct lyd_node **sibling, const struct lysc_node *sparent, const struct lysc_module *mod, int options)
-{
-    struct lyd_node *next, *node, *match;
-
-    assert(sibling);
+    struct lyd_node *next, *node;
 
     /* validate all restrictions of nodes themselves */
-    LY_LIST_FOR_SAFE(*sibling, next, node) {
-        if (node->flags & LYD_NEW) {
-            /* new node instance duplicities */
-            LY_CHECK_RET(lyd_validate_dup_nodes(*sibling, node));
-        } else if (node->flags & LYD_DEFAULT) {
-            /* remove default if there is an explicit instance */
-            assert(node->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST | LYS_CONTAINER));
-            if (node->schema->nodetype == LYS_LEAFLIST) {
-                lyd_find_sibling_next2(*sibling, node->schema, NULL, 0, &match);
-            } else {
-                lyd_find_sibling_val(*sibling, node->schema, NULL, 0, &match);
-            }
-            while (match && (match->flags & LYD_DEFAULT) && !(match->flags & LYD_NEW)) {
-                lyd_find_sibling_next2(match->next, node->schema, NULL, 0, &match);
-            }
-
-            if (match) {
-                /* non-default (or at least new for container) instance found, remove the default one */
-                if ((*sibling == node) && !(*sibling)->parent) {
-                    *sibling = (*sibling)->next;
-                }
-                lyd_free_tree(node);
-                continue;
-            }
+    LY_LIST_FOR_SAFE(first, next, node) {
+        if (mod && (lyd_top_node_module(node) != mod)) {
+            /* all top-level data from this module checked */
+            break;
         }
 
         /* TODO node's must */
@@ -705,42 +789,22 @@
     }
 
     /* validate schema-based restrictions */
-    LY_CHECK_RET(lyd_validate_siblings_schema_r(sibling, sparent, mod, options));
+    LY_CHECK_RET(lyd_validate_siblings_schema_r(first, sparent, mod ? mod->compiled : NULL));
 
-    LY_LIST_FOR(*sibling, node) {
-        /* this sibling is valid */
-        node->flags &= ~LYD_NEW;
-
+    LY_LIST_FOR(first, node) {
         /* validate all children recursively */
-        if (node->schema->nodetype & LYD_NODE_INNER) {
-            LY_CHECK_RET(lyd_validate_siblings_r(lyd_node_children_p(node), node->schema, mod, options));
-        }
-    }
+        LY_CHECK_RET(lyd_validate_siblings_r((struct lyd_node *)lyd_node_children(node), node->schema, NULL, val_opts));
 
-    return LY_SUCCESS;
-}
-
-LY_ERR
-lyd_validate_data(struct lyd_node **tree, const struct lys_module **modules, int mod_count, struct ly_ctx *ctx,
-                  int val_opts)
-{
-    uint32_t i = 0;
-    const struct lys_module *mod;
-
-    if (val_opts & LYD_VALOPT_DATA_ONLY) {
-        if (*tree) {
-            /* TODO all modules, not just first */
-            /* validate all top-level nodes and then inner nodes recursively */
-            LY_CHECK_RET(lyd_validate_siblings_r(tree, NULL, (*tree)->schema->module->compiled, val_opts));
-        }
-    } else {
-        while ((mod = lyd_val_next_module(modules, mod_count, ctx, &i))) {
-            if (!mod->implemented) {
-                continue;
+        /* set default for containers */
+        if ((node->schema->nodetype == LYS_CONTAINER) && !(node->schema->flags & LYS_PRESENCE)) {
+            LY_LIST_FOR((struct lyd_node *)lyd_node_children(node), next) {
+                if (!(next->flags & LYD_DEFAULT)) {
+                    break;
+                }
             }
-
-            /* validate all top-level nodes and then inner nodes recursively */
-            LY_CHECK_RET(lyd_validate_siblings_r(tree, NULL, mod->compiled, val_opts));
+            if (!next) {
+                node->flags |= LYD_DEFAULT;
+            }
         }
     }
 
@@ -748,17 +812,22 @@
 }
 
 LY_ERR
-lyd_validate_defaults_r(struct lyd_node_inner *parent, struct lyd_node **first, const struct lysc_node *schema,
-                        const struct lysc_module *mod, struct ly_set *node_types, struct ly_set *node_when)
+lyd_validate_defaults_r(struct lyd_node *parent, struct lyd_node **first, const struct lysc_node *sparent,
+                        const struct lys_module *mod, struct ly_set *node_types, struct ly_set *node_when)
 {
+    LY_ERR ret;
     const struct lysc_node *iter = NULL;
     struct lyd_node *node;
     struct lyd_value **dflts;
     size_t i;
 
-    assert(first && (schema || mod) && node_types && node_when);
+    assert(first && (parent || sparent || mod) && node_types && node_when);
 
-    while ((iter = lys_getnext(iter, schema, mod, LYS_GETNEXT_WITHCHOICE))) {
+    if (!sparent && parent) {
+        sparent = parent->schema;
+    }
+
+    while ((iter = lys_getnext(iter, sparent, mod ? mod->compiled : NULL, LYS_GETNEXT_WITHCHOICE))) {
         switch (iter->nodetype) {
         case LYS_CHOICE:
             if (((struct lysc_node_choice *)iter)->dflt && !lys_getnext_data(NULL, *first, NULL, iter, NULL)) {
@@ -769,22 +838,32 @@
             break;
         case LYS_CONTAINER:
             if (!(iter->flags & LYS_PRESENCE) && lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
-                /* create default NP container (default flag automatically set) */
+                /* create default NP container */
                 LY_CHECK_RET(lyd_create_inner(iter, &node));
-                lyd_insert_node((struct lyd_node *)parent, first, node);
+                node->flags = LYD_DEFAULT;
+                lyd_insert_node(parent, first, node);
 
                 if (iter->when) {
                     /* remember to resolve when */
                     ly_set_add(node_when, node, LY_SET_OPT_USEASLIST);
                 }
+
+                /* create any default children */
+                LY_CHECK_RET(lyd_validate_defaults_r(node, lyd_node_children_p(node), NULL, NULL, node_types, node_when));
             }
             break;
         case LYS_LEAF:
             if (((struct lysc_node_leaf *)iter)->dflt && lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
                 /* create default leaf */
-                LY_CHECK_RET(lyd_create_term2(iter, ((struct lysc_node_leaf *)iter)->dflt, &node));
-                node->flags |= LYD_DEFAULT;
-                lyd_insert_node((struct lyd_node *)parent, first, node);
+                ret = lyd_create_term2(iter, ((struct lysc_node_leaf *)iter)->dflt, &node);
+                if (ret == LY_EINCOMPLETE) {
+                    /* remember to resolve type */
+                    ly_set_add(node_types, node, LY_SET_OPT_USEASLIST);
+                } else if (ret) {
+                    return ret;
+                }
+                node->flags = LYD_DEFAULT;
+                lyd_insert_node(parent, first, node);
 
                 if (iter->when) {
                     /* remember to resolve when */
@@ -797,9 +876,15 @@
                 /* create all default leaf-lists */
                 dflts = ((struct lysc_node_leaflist *)iter)->dflts;
                 LY_ARRAY_FOR(dflts, i) {
-                    LY_CHECK_RET(lyd_create_term2(iter, dflts[i], &node));
-                    node->flags |= LYD_DEFAULT;
-                    lyd_insert_node((struct lyd_node *)parent, first, node);
+                    ret = lyd_create_term2(iter, dflts[i], &node);
+                    if (ret == LY_EINCOMPLETE) {
+                        /* remember to resolve type */
+                        ly_set_add(node_types, node, LY_SET_OPT_USEASLIST);
+                    } else if (ret) {
+                        return ret;
+                    }
+                    node->flags = LYD_DEFAULT;
+                    lyd_insert_node(parent, first, node);
 
                     if (iter->when) {
                         /* remember to resolve when */
@@ -817,92 +902,102 @@
     return LY_SUCCESS;
 }
 
-LY_ERR
-lyd_validate_defaults_top(struct lyd_node **first, const struct lys_module **modules, int mod_count, struct ly_ctx *ctx,
-                          struct ly_set *node_types, struct ly_set *node_when, int val_opts)
-{
-    uint32_t i = 0;
-    const struct lys_module *mod;
-    struct lyd_node *sibling;
-
-    assert(node_types && node_when);
-
-    if (val_opts & LYD_VALOPT_DATA_ONLY) {
-        mod = NULL;
-        LY_LIST_FOR(*first, sibling) {
-            if (lyd_top_node_module(sibling) != mod) {
-                /* remember this module */
-                mod = lyd_top_node_module(sibling);
-
-                /* add all top-level defaults for this module */
-                LY_CHECK_RET(lyd_validate_defaults_r(NULL, first, NULL, mod->compiled, node_types, node_when));
-            }
-        }
-    } else {
-        while ((mod = lyd_val_next_module(modules, mod_count, ctx, &i))) {
-            if (!mod->implemented) {
-                continue;
-            }
-
-            /* add all top-level defaults for this module */
-            LY_CHECK_RET(lyd_validate_defaults_r(NULL, first, NULL, mod->compiled, node_types, node_when));
-        }
-    }
-
-    return LY_SUCCESS;
-}
-
-API LY_ERR
-lyd_validate(const struct ly_ctx *ctx, struct lyd_node **tree, int val_opts)
+static LY_ERR
+_lyd_validate(struct lyd_node **tree, const struct lys_module **modules, int mod_count, const struct ly_ctx *ctx,
+              int val_opts)
 {
     LY_ERR ret = LY_SUCCESS;
-    struct lyd_node *root, *next, *elem;
+    struct lyd_node *first, *next, *node, **first2;
+    const struct lys_module *mod;
     const struct lyd_attr *attr;
     struct ly_set type_check = {0}, type_attr_check = {0}, when_check = {0};
+    uint32_t i = 0;
 
-    LY_CHECK_ARG_RET(ctx, tree, ctx || *tree, LY_EINVAL);
+    LY_CHECK_ARG_RET(NULL, tree, *tree || ctx || (modules && mod_count), LY_EINVAL);
 
-    if (!ctx) {
-        ctx = (*tree)->schema->module->ctx;
-    }
-
-    /* add nested defaults, collect all types and nodes with when condition */
-    LY_LIST_FOR(*tree, root) {
-        LYD_TREE_DFS_BEGIN(root, next, elem) {
-            LY_LIST_FOR(elem->attr, attr) {
-                ly_set_add(&type_attr_check, (void *)attr, LY_SET_OPT_USEASLIST);
-            }
-            if (elem->schema->nodetype & LYD_NODE_TERM) {
-                ly_set_add(&type_check, (void *)elem, LY_SET_OPT_USEASLIST);
-            } else if (elem->schema->nodetype & LYD_NODE_INNER) {
-                ret = lyd_validate_defaults_r((struct lyd_node_inner *)elem, lyd_node_children_p((struct lyd_node *)elem),
-                                              elem->schema, NULL, &type_check, &when_check);
-                LY_CHECK_GOTO(ret, cleanup);
-            }
-            if (!(elem->schema->nodetype & (LYS_ACTION | LYS_NOTIF)) && elem->schema->when) {
-                ly_set_add(&when_check, (void *)elem, LY_SET_OPT_USEASLIST);
-            }
-
-            LYD_TREE_DFS_END(root, next, elem);
+    next = *tree;
+    while (1) {
+        if (val_opts & LYD_VALOPT_DATA_ONLY) {
+            mod = lyd_data_next_module(&next, &first);
+        } else {
+            mod = lyd_mod_next_module(next, modules, mod_count, ctx, &i, &first);
         }
+        if (!mod) {
+            break;
+        }
+        if (first == *tree) {
+            /* make sure first2 changes are carried to tree */
+            first2 = tree;
+        } else {
+            first2 = &first;
+        }
+
+        /* validate new top-level nodes of this module, autodelete */
+        ret = lyd_validate_new(first2, NULL, mod);
+        LY_CHECK_GOTO(ret, cleanup);
+
+        /* add all top-level defaults for this module */
+        ret = lyd_validate_defaults_r(NULL, first2, NULL, mod, &type_check, &when_check);
+        LY_CHECK_GOTO(ret, cleanup);
+
+        /* process nested nodes */
+        LY_LIST_FOR(*first2, first) {
+            LYD_TREE_DFS_BEGIN(first, next, node) {
+                /* skip added default nodes */
+                if ((node->flags & (LYD_DEFAULT | LYD_NEW)) != (LYD_DEFAULT | LYD_NEW)) {
+                    LY_LIST_FOR(node->attr, attr) {
+                        /* attribute type resolution */
+                        ly_set_add(&type_attr_check, (void *)attr, LY_SET_OPT_USEASLIST);
+                    }
+
+                    if (node->schema->nodetype & LYD_NODE_TERM) {
+                        /* node type resolution */
+                        ly_set_add(&type_check, (void *)node, LY_SET_OPT_USEASLIST);
+                    } else if (node->schema->nodetype & LYD_NODE_INNER) {
+                        /* new node validation, autodelete */
+                        ret = lyd_validate_new(lyd_node_children_p((struct lyd_node *)node), node->schema, NULL);
+                        LY_CHECK_GOTO(ret, cleanup);
+
+                        /* add nested defaults */
+                        ret = lyd_validate_defaults_r(node, lyd_node_children_p((struct lyd_node *)node), NULL, NULL, &type_check,
+                                                    &when_check);
+                        LY_CHECK_GOTO(ret, cleanup);
+                    }
+
+                    if (!(node->schema->nodetype & (LYS_ACTION | LYS_NOTIF)) && node->schema->when) {
+                        /* when evaluation */
+                        ly_set_add(&when_check, (void *)node, LY_SET_OPT_USEASLIST);
+                    }
+                }
+
+                LYD_TREE_DFS_END(first, next, node);
+            }
+        }
+
+        /* finish incompletely validated terminal values/attributes and when conditions */
+        ret = lyd_validate_unres(tree, &when_check, &type_check, &type_attr_check, LYD_JSON, lydjson_resolve_prefix, NULL);
+        LY_CHECK_GOTO(ret, cleanup);
+
+        /* perform final validation that assumes the data tree is final */
+        ret = lyd_validate_siblings_r(*first2, NULL, mod, val_opts);
+        LY_CHECK_GOTO(ret, cleanup);
     }
 
-    /* add top-level default nodes */
-    ret = lyd_validate_defaults_top(tree, NULL, 0, (struct ly_ctx *)ctx, &type_check, &when_check, val_opts);
-    LY_CHECK_GOTO(ret, cleanup);
-
-    /* finish incompletely validated terminal values/attributes and when conditions */
-    ret = lyd_validate_unres(&type_check, &type_attr_check, &when_check, LYD_JSON, lydjson_resolve_prefix, NULL,
-                             (const struct lyd_node *)tree);
-    LY_CHECK_GOTO(ret, cleanup);
-
-    /* context node and other validation tasks that depend on other data nodes */
-    ret = lyd_validate_data(tree, NULL, 0, (struct ly_ctx *)ctx, val_opts);
-    LY_CHECK_GOTO(ret, cleanup);
-
 cleanup:
     ly_set_erase(&type_check, NULL);
     ly_set_erase(&type_attr_check, NULL);
     ly_set_erase(&when_check, NULL);
     return ret;
 }
+
+API LY_ERR
+lyd_validate(struct lyd_node **tree, const struct ly_ctx *ctx, int val_opts)
+{
+    return _lyd_validate(tree, NULL, 0, ctx, val_opts);
+}
+
+API LY_ERR
+lyd_validate_modules(struct lyd_node **tree, const struct lys_module **modules, int mod_count, int val_opts)
+{
+    return _lyd_validate(tree, modules, mod_count, NULL, val_opts);
+}