diff --git a/src/diff.c b/src/diff.c
index ab37b33..05c79d9 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -102,7 +102,7 @@
         /* find next node parent */
         parent = node;
         while (parent->parent && (!diff_parent || (parent->parent->schema != diff_parent->schema))) {
-            parent = (struct lyd_node *)parent->parent;
+            parent = lyd_parent(parent);
         }
         if (parent == node) {
             /* no more parents to find */
@@ -127,14 +127,14 @@
 
     /* find the first duplicated parent */
     if (!diff_parent) {
-        diff_parent = (struct lyd_node *)dup->parent;
+        diff_parent = lyd_parent(dup);
         while (diff_parent && diff_parent->parent) {
-            diff_parent = (struct lyd_node *)diff_parent->parent;
+            diff_parent = lyd_parent(diff_parent);
         }
     } else {
-        diff_parent = (struct lyd_node *)dup;
+        diff_parent = dup;
         while (diff_parent->parent && (diff_parent->parent->schema == parent->schema)) {
-            diff_parent = (struct lyd_node *)diff_parent->parent;
+            diff_parent = lyd_parent(diff_parent);
         }
     }
 
@@ -754,7 +754,7 @@
     const struct lyd_node *diff_parent;
     const char *str;
 
-    for (diff_parent = diff_node; diff_parent; diff_parent = (struct lyd_node *)diff_parent->parent) {
+    for (diff_parent = diff_node; diff_parent; diff_parent = lyd_parent(diff_parent)) {
         LY_LIST_FOR(diff_parent->meta, meta) {
             if (!strcmp(meta->name, "operation") && !strcmp(meta->annotation->module->name, "yang")) {
                 str = meta->value.canonical;
@@ -810,7 +810,7 @@
         return lyd_insert_child(parent_node, new_node);
     }
 
-    assert(!(*first_node)->parent || ((struct lyd_node *)(*first_node)->parent == parent_node));
+    assert(!(*first_node)->parent || (lyd_parent(*first_node) == parent_node));
 
     if (!lysc_is_userordered(new_node->schema)) {
         /* simple insert */
diff --git a/src/parser_json.c b/src/parser_json.c
index e84ee97..8fd2f06 100644
--- a/src/parser_json.c
+++ b/src/parser_json.c
@@ -165,7 +165,7 @@
             *prefix_p = onode->name.prefix;
             break;
         }
-        node = (struct lyd_node *)node->parent;
+        node = lyd_parent(node);
     }
     *prefix_len_p = ly_strlen(module_name);
 
@@ -198,7 +198,7 @@
     /* init return value */
     *snode_p = NULL;
 
-    LOG_LOCSET(NULL, (const struct lyd_node *)parent, NULL, NULL);
+    LOG_LOCSET(NULL, &parent->node, NULL, NULL);
 
     /* get the element module */
     if (prefix_len) {
@@ -831,7 +831,7 @@
 {
     if (*node_p) {
         /* insert, keep first pointer correct */
-        lyd_insert_node((struct lyd_node *)parent, first_p, *node_p);
+        lyd_insert_node(&parent->node, first_p, *node_p);
         if (first_p) {
             if (parent) {
                 *first_p = parent->child;
@@ -889,7 +889,7 @@
     }
 
     /* create node */
-    lydjson_get_node_prefix((struct lyd_node *)parent, prefix, prefix_len, &module_name, &module_name_len);
+    lydjson_get_node_prefix(&parent->node, prefix, prefix_len, &module_name, &module_name_len);
     ret = lyd_create_opaq(lydctx->jsonctx->ctx, name, name_len, prefix, prefix_len, module_name, module_name_len, value,
             value_len, &dynamic, LY_PREF_JSON, NULL, type_hint, node_p);
     if (dynamic) {
@@ -1188,7 +1188,7 @@
                 ret = LY_EVALID;
                 goto cleanup;
             }
-            attr_node = (struct lyd_node *)parent;
+            attr_node = &parent->node;
             snode = attr_node->schema;
         }
         ret = lydjson_parse_attribute(lydctx, attr_node, snode, name, name_len, prefix, prefix_len, parent, &status,
@@ -1296,7 +1296,7 @@
     goto cleanup;
 
 representation_error:
-    LOG_LOCSET(NULL, (const struct lyd_node *)parent, NULL, NULL);
+    LOG_LOCSET(NULL, &parent->node, NULL, NULL);
     LOGVAL(ctx, LYVE_SYNTAX_JSON, "The %s \"%s\" is expected to be represented as JSON %s, but input data contains name/%s.",
             lys_nodetype2str(snode->nodetype), snode->name, expected, lyjson_token2str(status));
     LOG_LOCBACK(0, parent ? 1 : 0, 0, 0);
diff --git a/src/parser_lyb.c b/src/parser_lyb.c
index 7fc3ea1..97cb85d 100644
--- a/src/parser_lyb.c
+++ b/src/parser_lyb.c
@@ -880,7 +880,7 @@
     }
 
     /* insert, keep first pointer correct */
-    lyd_insert_node((struct lyd_node *)parent, first, node);
+    lyd_insert_node(&parent->node, first, node);
     while (!parent && (*first)->prev->next) {
         *first = (*first)->prev;
     }
diff --git a/src/parser_xml.c b/src/parser_xml.c
index bfd82b2..2c96b6d 100644
--- a/src/parser_xml.c
+++ b/src/parser_xml.c
@@ -603,7 +603,7 @@
     }
 
     /* insert, keep first pointer correct */
-    lyd_insert_node((struct lyd_node *)parent, first_p, node);
+    lyd_insert_node(&parent->node, first_p, node);
     while (!parent && (*first_p)->prev->next) {
         *first_p = (*first_p)->prev;
     }
diff --git a/src/path.c b/src/path.c
index 2d1e868..36ff6d2 100644
--- a/src/path.c
+++ b/src/path.c
@@ -923,7 +923,7 @@
     } else {
         /* absolute path, start from the first top-level sibling */
         while (start->parent) {
-            start = (struct lyd_node *)start->parent;
+            start = lyd_parent(start);
         }
         while (start->prev->next) {
             start = start->prev;
diff --git a/src/printer_data.c b/src/printer_data.c
index 14bb879..b66511d 100644
--- a/src/printer_data.c
+++ b/src/printer_data.c
@@ -59,7 +59,7 @@
     if (root) {
         /* get first top-level sibling */
         while (root->parent) {
-            root = (struct lyd_node *)root->parent;
+            root = lyd_parent(root);
         }
         while (root->prev->next) {
             root = root->prev;
diff --git a/src/printer_json.c b/src/printer_json.c
index 28ee18f..a3fe6fc 100644
--- a/src/printer_json.c
+++ b/src/printer_json.c
@@ -403,7 +403,7 @@
 
     for (attr = node->attr; attr; attr = attr->next) {
         PRINT_COMMA;
-        json_print_member2(ctx, (struct lyd_node *)node, attr->format, &attr->name, 0);
+        json_print_member2(ctx, &node->node, attr->format, &attr->name, 0);
 
         if (attr->hints & (LYD_VALHINT_BOOLEAN | LYD_VALHINT_DECNUM)) {
             ly_print_(ctx->out, "%s", attr->value[0] ? attr->value : "null");
@@ -763,26 +763,24 @@
     ly_bool first = 1, last = 1;
 
     if (node->hints & (LYD_NODEHINT_LIST | LYD_NODEHINT_LEAFLIST)) {
-        const struct lyd_node_opaq *prev = (const struct lyd_node_opaq *)node->prev;
-        const struct lyd_node_opaq *next = (const struct lyd_node_opaq *)node->next;
-        if (prev->next && matching_node((const struct lyd_node *)prev, (const struct lyd_node *)node)) {
+        if (node->prev->next && matching_node(node->prev, &node->node)) {
             first = 0;
         }
-        if (next && matching_node((const struct lyd_node *)node, (const struct lyd_node *)next)) {
+        if (node->next && matching_node(&node->node, node->next)) {
             last = 0;
         }
     }
 
     if (first) {
-        LY_CHECK_RET(json_print_member2(ctx, node->parent, node->format, &node->name, 0));
+        LY_CHECK_RET(json_print_member2(ctx, lyd_parent(&node->node), node->format, &node->name, 0));
 
         if (node->hints & (LYD_NODEHINT_LIST | LYD_NODEHINT_LEAFLIST)) {
-            LY_CHECK_RET(json_print_array_open(ctx, (struct lyd_node *)node));
+            LY_CHECK_RET(json_print_array_open(ctx, &node->node));
             LEVEL_INC;
         }
     }
     if (node->child || (node->hints & (LYD_NODEHINT_LIST | LYD_NODEHINT_LEAFLIST))) {
-        LY_CHECK_RET(json_print_inner(ctx, (struct lyd_node *)node));
+        LY_CHECK_RET(json_print_inner(ctx, &node->node));
         LEVEL_PRINTED;
     } else {
         if (node->hints & LYD_VALHINT_EMPTY) {
diff --git a/src/printer_lyb.c b/src/printer_lyb.c
index 83730f8..2082999 100644
--- a/src/printer_lyb.c
+++ b/src/printer_lyb.c
@@ -919,7 +919,7 @@
     LY_CHECK_RET(lyb_write_start_subtree(out, lybctx->lybctx));
 
     /* write model info first */
-    if (!node->schema && !((struct lyd_node_opaq *)node)->parent) {
+    if (!node->schema && !lyd_parent(node)) {
         LY_CHECK_RET(lyb_print_model(out, NULL, lybctx->lybctx));
     } else if (node->schema && !lysc_data_parent(node->schema)) {
         LY_CHECK_RET(lyb_print_model(out, node->schema->module, lybctx->lybctx));
diff --git a/src/printer_xml.c b/src/printer_xml.c
index 744f5be..086c62b 100644
--- a/src/printer_xml.c
+++ b/src/printer_xml.c
@@ -323,7 +323,7 @@
     ly_bool dynamic;
     const char *value;
 
-    xml_print_node_open(ctx, (struct lyd_node *)node);
+    xml_print_node_open(ctx, &node->node);
     value = ((struct lysc_node_leaf *)node->schema)->type->plugin->print(&node->value, LY_PREF_XML, &ns_list, &dynamic);
 
     /* print namespaces connected with the values's prefixes */
@@ -358,7 +358,7 @@
     LY_ERR ret;
     struct lyd_node *child;
 
-    xml_print_node_open(ctx, (struct lyd_node *)node);
+    xml_print_node_open(ctx, &node->node);
 
     LY_LIST_FOR(node->child, child) {
         if (ly_should_print(child, ctx->options)) {
@@ -394,7 +394,7 @@
     uint32_t prev_opts, prev_lo;
     LY_ERR ret;
 
-    xml_print_node_open(ctx, (struct lyd_node *)node);
+    xml_print_node_open(ctx, &node->node);
 
     if (!any->value.tree) {
         /* no content */
diff --git a/src/tree_data.c b/src/tree_data.c
index d429bdb..2944077 100644
--- a/src/tree_data.c
+++ b/src/tree_data.c
@@ -175,13 +175,13 @@
         stored = 1;
 
         /* resolve */
-        rc = type->plugin->validate(ctx ? ctx : LYD_CTX(node), type, (struct lyd_node *)node, tree, &val, &err);
+        rc = type->plugin->validate(ctx ? ctx : LYD_CTX(node), type, &node->node, tree, &val, &err);
     }
 
     if (rc) {
         if (err) {
             if (ctx) {
-                LOG_LOCSET(NULL, (const struct lyd_node *)node, NULL, NULL);
+                LOG_LOCSET(NULL, &node->node, NULL, NULL);
                 LOGVAL(ctx, err->vecode, err->msg);
                 LOG_LOCBACK(0, 1, 0, 0);
             }
@@ -219,7 +219,7 @@
     type = ((struct lysc_node_leaf *)node->schema)->type;
 
     /* store the value */
-    LOG_LOCSET(node->schema, (const struct lyd_node *)node, NULL, NULL);
+    LOG_LOCSET(node->schema, &node->node, NULL, NULL);
     ret = lyd_value_store(ctx, &val, type, value, value_len, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, node->schema, NULL);
     LOG_LOCBACK(1, 1, 0, 0);
     LY_CHECK_RET(ret);
@@ -535,7 +535,7 @@
     LY_CHECK_ERR_RET(!term, LOGMEM(schema->module->ctx), LY_EMEM);
 
     term->schema = schema;
-    term->prev = (struct lyd_node *)term;
+    term->prev = &term->node;
     term->flags = LYD_NEW;
 
     LOG_LOCSET(schema, NULL, NULL, NULL);
@@ -543,9 +543,9 @@
             value_len, dynamic, format, prefix_data, hints, schema, incomplete);
     LOG_LOCBACK(1, 0, 0, 0);
     LY_CHECK_ERR_RET(ret, free(term), ret);
-    lyd_hash((struct lyd_node *)term);
+    lyd_hash(&term->node);
 
-    *node = (struct lyd_node *)term;
+    *node = &term->node;
     return ret;
 }
 
@@ -563,7 +563,7 @@
     LY_CHECK_ERR_RET(!term, LOGMEM(schema->module->ctx), LY_EMEM);
 
     term->schema = schema;
-    term->prev = (struct lyd_node *)term;
+    term->prev = &term->node;
     term->flags = LYD_NEW;
 
     type = ((struct lysc_node_leaf *)schema)->type;
@@ -573,9 +573,9 @@
         free(term);
         return ret;
     }
-    lyd_hash((struct lyd_node *)term);
+    lyd_hash(&term->node);
 
-    *node = (struct lyd_node *)term;
+    *node = &term->node;
     return ret;
 }
 
@@ -590,7 +590,7 @@
     LY_CHECK_ERR_RET(!in, LOGMEM(schema->module->ctx), LY_EMEM);
 
     in->schema = schema;
-    in->prev = (struct lyd_node *)in;
+    in->prev = &in->node;
     in->flags = LYD_NEW;
     if ((schema->nodetype == LYS_CONTAINER) && !(schema->flags & LYS_PRESENCE)) {
         in->flags |= LYD_DEFAULT;
@@ -598,10 +598,10 @@
 
     /* do not hash list with keys, we need them for the hash */
     if ((schema->nodetype != LYS_LIST) || (schema->flags & LYS_KEYLESS)) {
-        lyd_hash((struct lyd_node *)in);
+        lyd_hash(&in->node);
     }
 
-    *node = (struct lyd_node *)in;
+    *node = &in->node;
     return LY_SUCCESS;
 }
 
@@ -681,7 +681,7 @@
     LY_CHECK_ERR_RET(!any, LOGMEM(schema->module->ctx), LY_EMEM);
 
     any->schema = schema;
-    any->prev = (struct lyd_node *)any;
+    any->prev = &any->node;
     any->flags = LYD_NEW;
 
     /* TODO: convert XML/JSON strings into a opaq data tree */
@@ -691,12 +691,12 @@
         any->value_type = value_type;
     } else {
         any_val.str = value;
-        ret = lyd_any_copy_value((struct lyd_node *)any, &any_val, value_type);
+        ret = lyd_any_copy_value(&any->node, &any_val, value_type);
         LY_CHECK_ERR_RET(ret, free(any), ret);
     }
-    lyd_hash((struct lyd_node *)any);
+    lyd_hash(&any->node);
 
-    *node = (struct lyd_node *)any;
+    *node = &any->node;
     return LY_SUCCESS;
 }
 
@@ -717,7 +717,7 @@
     opaq = calloc(1, sizeof *opaq);
     LY_CHECK_ERR_GOTO(!opaq, LOGMEM(ctx); ret = LY_EMEM, finish);
 
-    opaq->prev = (struct lyd_node *)opaq;
+    opaq->prev = &opaq->node;
     LY_CHECK_GOTO(ret = lydict_insert(ctx, name, name_len, &opaq->name.name), finish);
 
     if (pref_len) {
@@ -740,10 +740,10 @@
 
 finish:
     if (ret) {
-        lyd_free_tree((struct lyd_node *)opaq);
+        lyd_free_tree(&opaq->node);
         ly_free_prefix_data(format, val_prefix_data);
     } else {
-        *node = (struct lyd_node *)opaq;
+        *node = &opaq->node;
     }
     return ret;
 }
@@ -1182,7 +1182,7 @@
 
     /* always clear the default flag */
     if (term->flags & LYD_DEFAULT) {
-        for (parent = term; parent; parent = (struct lyd_node *)parent->parent) {
+        for (parent = term; parent; parent = lyd_parent(parent)) {
             parent->flags &= ~LYD_DEFAULT;
         }
         dflt_change = 1;
@@ -1204,9 +1204,9 @@
         } else if ((term->schema->flags & LYS_KEY) && term->parent) {
             /* list needs to be updated if its key was changed */
             assert(term->parent->schema->nodetype == LYS_LIST);
-            lyd_unlink_hash((struct lyd_node *)term->parent);
-            lyd_hash((struct lyd_node *)term->parent);
-            LY_CHECK_GOTO(ret = lyd_insert_hash((struct lyd_node *)term->parent), cleanup);
+            lyd_unlink_hash(lyd_parent(term));
+            lyd_hash(lyd_parent(term));
+            LY_CHECK_GOTO(ret = lyd_insert_hash(lyd_parent(term)), cleanup);
         } /* else leaf that is not a key, its value is not used for its hash so it does not change */
     }
 
@@ -1623,7 +1623,7 @@
         /* skip added default nodes */
         if (((node->flags & (LYD_DEFAULT | LYD_NEW)) != (LYD_DEFAULT | LYD_NEW)) &&
                 (node->schema->nodetype & LYD_NODE_INNER)) {
-            LY_CHECK_GOTO(ret = lyd_new_implicit_r(node, lyd_node_children_p((struct lyd_node *)node), NULL, NULL, NULL,
+            LY_CHECK_GOTO(ret = lyd_new_implicit_r(node, lyd_node_children_p(node), NULL, NULL, NULL,
                     &node_when, implicit_options, diff), cleanup);
         }
 
@@ -1846,7 +1846,7 @@
         }
         if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
             /* rehash key-less list */
-            lyd_hash((struct lyd_node *)par);
+            lyd_hash(&par->node);
         }
     }
 }
@@ -1886,7 +1886,7 @@
         }
         if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
             /* rehash key-less list */
-            lyd_hash((struct lyd_node *)par);
+            lyd_hash(&par->node);
         }
     }
 }
@@ -1919,7 +1919,7 @@
         }
         if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
             /* rehash key-less list */
-            lyd_hash((struct lyd_node *)par);
+            lyd_hash(&par->node);
         }
     }
 }
@@ -1963,11 +1963,11 @@
             (parent->schema->nodetype & (LYS_CONTAINER | LYS_LIST | LYS_RPC | LYS_ACTION | LYS_NOTIF)));
 
     if (!parent && first_sibling_p && (*first_sibling_p) && (*first_sibling_p)->parent) {
-        parent = (struct lyd_node *)(*first_sibling_p)->parent;
+        parent = lyd_parent(*first_sibling_p);
     }
 
     /* get first sibling */
-    first_sibling = parent ? ((struct lyd_node_inner *)parent)->child : *first_sibling_p;
+    first_sibling = parent ? lyd_child(parent) : *first_sibling_p;
 
     /* find the anchor, our next node, so we can insert before it */
     anchor = lyd_insert_get_next_anchor(first_sibling, node);
@@ -2206,7 +2206,7 @@
         }
 
         /* check for keyless list and update its hash */
-        for (iter = (struct lyd_node *)node->parent; iter; iter = (struct lyd_node *)iter->parent) {
+        for (iter = lyd_parent(node); iter; iter = lyd_parent(iter)) {
             if (iter->schema && (iter->schema->flags & LYS_KEYLESS)) {
                 lyd_hash(iter);
             }
@@ -2245,7 +2245,7 @@
     /* remove default flags from NP containers */
     while (clear_dflt && parent && (parent->schema->nodetype == LYS_CONTAINER) && (parent->flags & LYD_DEFAULT)) {
         parent->flags &= ~LYD_DEFAULT;
-        parent = (struct lyd_node *)parent->parent;
+        parent = lyd_parent(parent);
     }
 }
 
@@ -2474,8 +2474,8 @@
                 }
             }
             if (options & LYD_COMPARE_FULL_RECURSION) {
-                iter1 = ((struct lyd_node_inner *)node1)->child;
-                iter2 = ((struct lyd_node_inner *)node2)->child;
+                iter1 = lyd_child(node1);
+                iter2 = lyd_child(node2);
                 goto all_children_compare;
             }
             return LY_SUCCESS;
@@ -2495,8 +2495,8 @@
             }
             return LY_SUCCESS;
         case LYS_LIST:
-            iter1 = ((struct lyd_node_inner *)node1)->child;
-            iter2 = ((struct lyd_node_inner *)node2)->child;
+            iter1 = lyd_child(node1);
+            iter2 = lyd_child(node2);
 
             if (!(node1->schema->flags & LYS_KEYLESS) && !(options & LYD_COMPARE_FULL_RECURSION)) {
                 /* lists with keys, their equivalence is based on their keys */
@@ -2820,7 +2820,7 @@
             }
         } else {
             /* if there is no local parent, it will be inserted into first */
-            rc = lyd_dup_r(orig, (struct lyd_node *)local_parent, &first, options, first ? NULL : &first);
+            rc = lyd_dup_r(orig, &local_parent->node, &first, options, first ? NULL : &first);
             LY_CHECK_GOTO(rc, error);
         }
         if (nosiblings) {
@@ -2831,7 +2831,7 @@
     /* rehash if needed */
     for ( ; local_parent; local_parent = local_parent->parent) {
         if ((local_parent->schema->nodetype == LYS_LIST) && (local_parent->schema->flags & LYS_KEYLESS)) {
-            lyd_hash((struct lyd_node *)local_parent);
+            lyd_hash(&local_parent->node);
         }
     }
 
@@ -3169,14 +3169,14 @@
     case LYD_PATH_STD:
     case LYD_PATH_STD_NO_LAST_PRED:
         depth = 1;
-        for (iter = node; iter->parent; iter = (const struct lyd_node *)iter->parent) {
+        for (iter = node; iter->parent; iter = lyd_parent(iter)) {
             ++depth;
         }
 
         goto iter_print;
         while (depth) {
             /* find the right node */
-            for (iter = node, i = 1; i < depth; iter = (const struct lyd_node *)iter->parent, ++i) {}
+            for (iter = node, i = 1; i < depth; iter = lyd_parent(iter), ++i) {}
 iter_print:
             /* print prefix and name */
             mod = NULL;
@@ -3303,7 +3303,7 @@
         }
     }
 
-    parent = (struct lyd_node_inner *)siblings->parent;
+    parent = siblings->parent;
     if (parent && parent->schema && parent->children_ht) {
         assert(target->hash);
 
@@ -3386,7 +3386,7 @@
 
     assert(siblings && schema);
 
-    parent = (struct lyd_node_inner *)siblings->parent;
+    parent = siblings->parent;
     if (parent && parent->schema && parent->children_ht) {
         /* calculate our hash */
         hash = dict_hash_multi(0, schema->module->name, strlen(schema->module->name));
diff --git a/src/tree_data.h b/src/tree_data.h
index a5804c9..949faaa 100644
--- a/src/tree_data.h
+++ b/src/tree_data.h
@@ -326,7 +326,7 @@
     }\
     if (!(LYD_TREE_DFS_next)) { \
         /* no children */ \
-        if ((ELEM) == (struct lyd_node*)(START)) { \
+        if ((ELEM) == (struct lyd_node *)(START)) { \
             /* we are done, (START) has no children */ \
             break; \
         } \
@@ -335,7 +335,7 @@
     } \
     while (!(LYD_TREE_DFS_next)) { \
         /* parent is already processed, go to its sibling */ \
-        (ELEM) = (struct lyd_node*)(ELEM)->parent; \
+        (ELEM) = (struct lyd_node *)(ELEM)->parent; \
         /* no siblings, go back through parents */ \
         if ((ELEM)->parent == (START)->parent) { \
             /* we are done, no next element to process */ \
@@ -498,7 +498,6 @@
     LY_PREFIX_FORMAT format;        /**< format of the attribute and any prefixes, ::LY_PREF_XML or ::LY_PREF_JSON */
     void *val_prefix_data;          /**< format-specific prefix data */
     uint32_t hints;                 /**< additional information about from the data source, see the [hints list](@ref lydhints) */
-
 };
 
 #define LYD_NODE_INNER (LYS_CONTAINER|LYS_LIST|LYS_RPC|LYS_ACTION|LYS_NOTIF) /**< Schema nodetype mask for lyd_node_inner */
@@ -558,20 +557,26 @@
  * @brief Data node structure for the inner data tree nodes - containers, lists, RPCs, actions and Notifications.
  */
 struct lyd_node_inner {
-    uint32_t hash;                   /**< hash of this particular node (module name + schema name + key string values if list or
-                                          hashes of all nodes of subtree in case of keyless list). Note that while hash can be
-                                          used to get know that nodes are not equal, it cannot be used to decide that the
-                                          nodes are equal due to possible collisions. */
-    uint32_t flags;                  /**< [data node flags](@ref dnodeflags) */
-    const struct lysc_node *schema;  /**< pointer to the schema definition of this node */
-    struct lyd_node_inner *parent;   /**< pointer to the parent node, NULL in case of root node */
-    struct lyd_node *next;           /**< pointer to the next sibling node (NULL if there is no one) */
-    struct lyd_node *prev;           /**< pointer to the previous sibling node \note Note that this pointer is
-                                          never NULL. If there is no sibling node, pointer points to the node
-                                          itself. In case of the first node, this pointer points to the last
-                                          node in the list. */
-    struct lyd_meta *meta;           /**< pointer to the list of metadata of this node */
-    void *priv;                      /**< private user data, not used by libyang */
+    union {
+        struct lyd_node node;               /**< implicit cast for the members compatible with ::lyd_node */
+        struct {
+            uint32_t hash;                  /**< hash of this particular node (module name + schema name + key string
+                                                 values if list or hashes of all nodes of subtree in case of keyless
+                                                 list). Note that while hash can be used to get know that nodes are
+                                                 not equal, it cannot be used to decide that the nodes are equal due
+                                                 to possible collisions. */
+            uint32_t flags;                 /**< [data node flags](@ref dnodeflags) */
+            const struct lysc_node *schema; /**< pointer to the schema definition of this node */
+            struct lyd_node_inner *parent;  /**< pointer to the parent node, NULL in case of root node */
+            struct lyd_node *next;          /**< pointer to the next sibling node (NULL if there is no one) */
+            struct lyd_node *prev;          /**< pointer to the previous sibling node \note Note that this pointer is
+                                                 never NULL. If there is no sibling node, pointer points to the node
+                                                 itself. In case of the first node, this pointer points to the last
+                                                 node in the list. */
+            struct lyd_meta *meta;          /**< pointer to the list of metadata of this node */
+            void *priv;                     /**< private user data, not used by libyang */
+        };
+    };                                      /**< common part corresponding to ::lyd_node */
 
     struct lyd_node *child;          /**< pointer to the first child node. */
     struct hash_table *children_ht;  /**< hash table with all the direct children (except keys for a list, lists without keys) */
@@ -582,51 +587,63 @@
  * @brief Data node structure for the terminal data tree nodes - leaves and leaf-lists.
  */
 struct lyd_node_term {
-    uint32_t hash;                   /**< hash of this particular node (module name + schema name + key string values if list or
-                                          hashes of all nodes of subtree in case of keyless list). Note that while hash can be
-                                          used to get know that nodes are not equal, it cannot be used to decide that the
-                                          nodes are equal due to possible collisions. */
-    uint32_t flags;                  /**< [data node flags](@ref dnodeflags) */
-    const struct lysc_node *schema;  /**< pointer to the schema definition of this node */
-    struct lyd_node_inner *parent;   /**< pointer to the parent node, NULL in case of root node */
-    struct lyd_node *next;           /**< pointer to the next sibling node (NULL if there is no one) */
-    struct lyd_node *prev;           /**< pointer to the previous sibling node \note Note that this pointer is
-                                          never NULL. If there is no sibling node, pointer points to the node
-                                          itself. In case of the first node, this pointer points to the last
-                                          node in the list. */
-    struct lyd_meta *meta;           /**< pointer to the list of metadata of this node */
-    void *priv;                      /**< private user data, not used by libyang */
+    union {
+        struct lyd_node node;               /**< implicit cast for the members compatible with ::lyd_node */
+        struct {
+            uint32_t hash;                  /**< hash of this particular node (module name + schema name + key string
+                                                 values if list or hashes of all nodes of subtree in case of keyless
+                                                 list). Note that while hash can be used to get know that nodes are
+                                                 not equal, it cannot be used to decide that the nodes are equal due
+                                                 to possible collisions. */
+            uint32_t flags;                 /**< [data node flags](@ref dnodeflags) */
+            const struct lysc_node *schema; /**< pointer to the schema definition of this node */
+            struct lyd_node_inner *parent;  /**< pointer to the parent node, NULL in case of root node */
+            struct lyd_node *next;          /**< pointer to the next sibling node (NULL if there is no one) */
+            struct lyd_node *prev;          /**< pointer to the previous sibling node \note Note that this pointer is
+                                                 never NULL. If there is no sibling node, pointer points to the node
+                                                 itself. In case of the first node, this pointer points to the last
+                                                 node in the list. */
+            struct lyd_meta *meta;          /**< pointer to the list of metadata of this node */
+            void *priv;                     /**< private user data, not used by libyang */
+        };
+    };                                      /**< common part corresponding to ::lyd_node */
 
     struct lyd_value value;          /**< node's value representation */
 };
 
 /**
- * @brief Data node structure for the anydata data tree nodes - anydatas and anyxmls.
+ * @brief Data node structure for the anydata data tree nodes - anydata or anyxml.
  */
 struct lyd_node_any {
-    uint32_t hash;                   /**< hash of this particular node (module name + schema name + key string values if list or
-                                          hashes of all nodes of subtree in case of keyless list). Note that while hash can be
-                                          used to get know that nodes are not equal, it cannot be used to decide that the
-                                          nodes are equal due to possible collisions. */
-    uint32_t flags;                  /**< [data node flags](@ref dnodeflags) */
-    const struct lysc_node *schema;  /**< pointer to the schema definition of this node */
-    struct lyd_node_inner *parent;   /**< pointer to the parent node, NULL in case of root node */
-    struct lyd_node *next;           /**< pointer to the next sibling node (NULL if there is no one) */
-    struct lyd_node *prev;           /**< pointer to the previous sibling node \note Note that this pointer is
-                                          never NULL. If there is no sibling node, pointer points to the node
-                                          itself. In case of the first node, this pointer points to the last
-                                          node in the list. */
-    struct lyd_meta *meta;           /**< pointer to the list of metadata of this node */
-    void *priv;                      /**< private user data, not used by libyang */
+    union {
+        struct lyd_node node;               /**< implicit cast for the members compatible with ::lyd_node */
+        struct {
+            uint32_t hash;                  /**< hash of this particular node (module name + schema name + key string
+                                                 values if list or hashes of all nodes of subtree in case of keyless
+                                                 list). Note that while hash can be used to get know that nodes are
+                                                 not equal, it cannot be used to decide that the nodes are equal due
+                                                 to possible collisions. */
+            uint32_t flags;                 /**< [data node flags](@ref dnodeflags) */
+            const struct lysc_node *schema; /**< pointer to the schema definition of this node */
+            struct lyd_node_inner *parent;  /**< pointer to the parent node, NULL in case of root node */
+            struct lyd_node *next;          /**< pointer to the next sibling node (NULL if there is no one) */
+            struct lyd_node *prev;          /**< pointer to the previous sibling node \note Note that this pointer is
+                                                 never NULL. If there is no sibling node, pointer points to the node
+                                                 itself. In case of the first node, this pointer points to the last
+                                                 node in the list. */
+            struct lyd_meta *meta;          /**< pointer to the list of metadata of this node */
+            void *priv;                     /**< private user data, not used by libyang */
+        };
+    };                                      /**< common part corresponding to ::lyd_node */
 
     union lyd_any_value {
-        struct lyd_node *tree;       /**< data tree */
-        const char *str;             /**< Generic string data */
-        const char *xml;             /**< Serialized XML data */
-        const char *json;            /**< I-JSON encoded string */
-        char *mem;                   /**< LYD_ANYDATA_LYB memory chunk */
-    } value;                         /**< pointer to the stored value representation of the anydata/anyxml node */
-    LYD_ANYDATA_VALUETYPE value_type;/**< type of the data stored as ::lyd_node_any.value */
+        struct lyd_node *tree;          /**< data tree */
+        const char *str;                /**< Generic string data */
+        const char *xml;                /**< Serialized XML data */
+        const char *json;               /**< I-JSON encoded string */
+        char *mem;                      /**< LYD_ANYDATA_LYB memory chunk */
+    } value;                            /**< pointer to the stored value representation of the anydata/anyxml node */
+    LYD_ANYDATA_VALUETYPE value_type;   /**< type of the data stored as ::lyd_node_any.value */
 };
 
 /**
@@ -690,14 +707,22 @@
  * @brief Data node structure for unparsed (opaque) nodes.
  */
 struct lyd_node_opaq {
-    uint32_t hash;                  /**< always 0 */
-    uint32_t flags;                 /**< always 0 */
-    const struct lysc_node *schema; /**< always NULL */
-    struct lyd_node *parent;        /**< pointer to the parent node (NULL in case of root node) */
-    struct lyd_node *next;          /**< pointer to the next sibling node (NULL if there is no one) */
-    struct lyd_node *prev;          /**< pointer to the previous sibling node (last sibling if there is none) */
-    struct lyd_attr *attr;          /**< pointer to the list of generic attributes of this node */
-    void *priv;                     /**< private user data, not used by libyang */
+    union {
+        struct lyd_node node;               /**< implicit cast for the members compatible with ::lyd_node */
+        struct {
+            uint32_t hash;                  /**< always 0 */
+            uint32_t flags;                 /**< always 0 */
+            const struct lysc_node *schema; /**< always NULL */
+            struct lyd_node_inner *parent;  /**< pointer to the parent node, NULL in case of root node */
+            struct lyd_node *next;          /**< pointer to the next sibling node (NULL if there is no one) */
+            struct lyd_node *prev;          /**< pointer to the previous sibling node \note Note that this pointer is
+                                                 never NULL. If there is no sibling node, pointer points to the node
+                                                 itself. In case of the first node, this pointer points to the last
+                                                 node in the list. */
+            struct lyd_meta *meta;          /**< always NULL */
+            void *priv;                     /**< private user data, not used by libyang */
+        };
+    };                                      /**< common part corresponding to ::lyd_node */
 
     struct lyd_node *child;         /**< pointer to the child node (compatible with ::lyd_node_inner) */
 
@@ -707,6 +732,7 @@
     void *val_prefix_data;          /**< format-specific prefix data */
     uint32_t hints;                 /**< additional information about from the data source, see the [hints list](@ref lydhints) */
 
+    struct lyd_attr *attr;          /**< pointer to the list of generic attributes of this node */
     const struct ly_ctx *ctx;       /**< libyang context */
 };
 
diff --git a/src/tree_data_free.c b/src/tree_data_free.c
index 274897a..cb5a6c5 100644
--- a/src/tree_data_free.c
+++ b/src/tree_data_free.c
@@ -214,7 +214,7 @@
 
     /* get the first (top-level) sibling */
     if (top) {
-        for ( ; node->parent; node = (struct lyd_node *)node->parent) {}
+        for ( ; node->parent; node = lyd_parent(node)) {}
     }
     while (node->prev->next) {
         node = node->prev;
diff --git a/src/tree_data_hash.c b/src/tree_data_hash.c
index 523c85d..921a1a0 100644
--- a/src/tree_data_hash.c
+++ b/src/tree_data_hash.c
@@ -34,7 +34,7 @@
         switch (iter->schema->nodetype) {
         case LYS_CONTAINER:
         case LYS_LIST:
-            lyd_hash_keyless_list_dfs(((struct lyd_node_inner *)iter)->child, hash);
+            lyd_hash_keyless_list_dfs(lyd_child(iter), hash);
             break;
         case LYS_LEAFLIST:
         case LYS_ANYXML:
diff --git a/src/tree_data_helpers.c b/src/tree_data_helpers.c
index 78f53af..02bc433 100644
--- a/src/tree_data_helpers.c
+++ b/src/tree_data_helpers.c
@@ -92,7 +92,7 @@
         return NULL;
     }
 
-    return (struct lyd_node *)(node)->parent;
+    return &node->parent->node;
 }
 
 API struct lyd_node *
@@ -106,7 +106,7 @@
 
     if (!node->schema) {
         /* opaq node */
-        return ((struct lyd_node_opaq *)(node))->child;
+        return ((struct lyd_node_opaq *)node)->child;
     }
 
     children = lyd_node_children_p((struct lyd_node *)node);
@@ -128,7 +128,7 @@
 
     if (!node->schema) {
         /* opaq node */
-        return ((struct lyd_node_opaq *)(node))->child;
+        return ((struct lyd_node_opaq *)node)->child;
     }
 
     children = lyd_node_children_p((struct lyd_node *)node);
diff --git a/src/validation.c b/src/validation.c
index 9e2d105..c31c456 100644
--- a/src/validation.c
+++ b/src/validation.c
@@ -124,7 +124,7 @@
                 ctx_node = node;
             } else {
                 assert((!when->context && !node->parent) || (when->context == node->parent->schema));
-                ctx_node = (struct lyd_node *)node->parent;
+                ctx_node = lyd_parent(node);
             }
 
             /* evaluate when */
@@ -252,8 +252,8 @@
             struct lysc_type *type = ((struct lysc_node_leaf *)node->schema)->type;
 
             /* resolve the value of the node */
-            LOG_LOCSET(node->schema, (struct lyd_node *)node, NULL, NULL);
-            ret = lyd_value_validate_incomplete(LYD_CTX(node), type, &node->value, (struct lyd_node *)node, *tree);
+            LOG_LOCSET(node->schema, &node->node, NULL, NULL);
+            ret = lyd_value_validate_incomplete(LYD_CTX(node), type, &node->value, &node->node, *tree);
             LOG_LOCBACK(node->schema ? 1 : 0, 1, 0, 0);
             LY_CHECK_RET(ret);
 
@@ -1181,7 +1181,7 @@
     }
 
     /* find first top-level node */
-    for (tree = node; tree->parent; tree = (struct lyd_node *)tree->parent) {}
+    for (tree = node; tree->parent; tree = lyd_parent(tree)) {}
     while (tree->prev->next) {
         tree = tree->prev;
     }
@@ -1309,11 +1309,10 @@
             LY_CHECK_RET(ly_set_add(node_types, (void *)node, 1, NULL));
         } else if (node->schema->nodetype & LYD_NODE_INNER) {
             /* new node validation, autodelete */
-            LY_CHECK_RET(lyd_validate_new(lyd_node_children_p((struct lyd_node *)node), node->schema, NULL, diff));
+            LY_CHECK_RET(lyd_validate_new(lyd_node_children_p(node), node->schema, NULL, diff));
 
             /* add nested defaults */
-            LY_CHECK_RET(lyd_new_implicit_r(node, lyd_node_children_p((struct lyd_node *)node), NULL, NULL, NULL,
-                    NULL, impl_opts, diff));
+            LY_CHECK_RET(lyd_new_implicit_r(node, lyd_node_children_p(node), NULL, NULL, NULL, NULL, impl_opts, diff));
         }
 
         if (lysc_node_when(node->schema)) {
@@ -1446,7 +1445,7 @@
 
     /* learn op depth (top-level being depth 0) */
     op_depth = 0;
-    for (op_iter = op_node; op_iter != op_tree; op_iter = (struct lyd_node *)op_iter->parent) {
+    for (op_iter = op_node; op_iter != op_tree; op_iter = lyd_parent(op_iter)) {
         ++op_depth;
     }
 
@@ -1469,7 +1468,7 @@
         /* find next op parent */
         op_iter = op_node;
         for (i = 0; i < cur_depth; ++i) {
-            op_iter = (struct lyd_node *)op_iter->parent;
+            op_iter = lyd_parent(op_iter);
         }
     }
 
@@ -1521,7 +1520,7 @@
 
     /* move op_tree to top-level node */
     while (op_tree->parent) {
-        op_tree = (struct lyd_node *)op_tree->parent;
+        op_tree = lyd_parent(op_tree);
     }
 
     /* merge op_tree into tree */
diff --git a/src/xpath.c b/src/xpath.c
index 8f10af7..9dc8d24 100644
--- a/src/xpath.c
+++ b/src/xpath.c
@@ -193,11 +193,10 @@
                 LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ROOT CONFIG", i + 1, item->pos);
                 break;
             case LYXP_NODE_ELEM:
-                if ((item->node->schema->nodetype == LYS_LIST) &&
-                        (((struct lyd_node_inner *)item->node)->child->schema->nodetype == LYS_LEAF)) {
+                if ((item->node->schema->nodetype == LYS_LIST) && (lyd_child(item->node)->schema->nodetype == LYS_LEAF)) {
                     LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s (1st child val: %s)", i + 1, item->pos,
                             item->node->schema->name, LYD_CANON_VALUE(lyd_child(item->node)));
-                } else if (((struct lyd_node_inner *)item->node)->schema->nodetype == LYS_LEAFLIST) {
+                } else if (item->node->schema->nodetype == LYS_LEAFLIST) {
                     LOGDBG(LY_LDGXPATH, "\t%d (pos %u): ELEM %s (val: %s)", i + 1, item->pos,
                             item->node->schema->name, LYD_CANON_VALUE(item->node));
                 } else {
@@ -1611,7 +1610,7 @@
     }
 
     /* find first top-level node to be used as anchor for positions */
-    for (root = set->cur_node; root->parent; root = (const struct lyd_node *)root->parent) {}
+    for (root = set->cur_node; root->parent; root = lyd_parent(root)) {}
     for ( ; root->prev->next; root = root->prev) {}
 
     /* fill positions */
@@ -1731,7 +1730,7 @@
     }
 
     /* find first top-level node to be used as anchor for positions */
-    for (root = trg->cur_node; root->parent; root = (const struct lyd_node *)root->parent) {}
+    for (root = trg->cur_node; root->parent; root = lyd_parent(root)) {}
     for ( ; root->prev->next; root = root->prev) {}
 
     /* fill positions */
@@ -3729,8 +3728,8 @@
         if (sleaf->nodetype & (LYS_LEAF | LYS_LEAFLIST)) {
             if (sleaf->type->basetype == LY_TYPE_LEAFREF) {
                 /* find leafref target */
-                if (ly_type_find_leafref((struct lysc_type_leafref *)sleaf->type, (struct lyd_node *)leaf,
-                        &leaf->value, set->tree, &node, &errmsg)) {
+                if (ly_type_find_leafref((struct lysc_type_leafref *)sleaf->type, &leaf->node, &leaf->value, set->tree,
+                        &node, &errmsg)) {
                     LOGERR(set->ctx, LY_EVALID, errmsg);
                     free(errmsg);
                     return LY_EVALID;
@@ -4040,7 +4039,7 @@
     }
 
     /* find lang metadata */
-    for ( ; node; node = (struct lyd_node *)node->parent) {
+    for ( ; node; node = lyd_parent(node)) {
         for (meta = node->meta; meta; meta = meta->next) {
             /* annotations */
             if (meta->name && !strcmp(meta->name, "lang") && !strcmp(meta->annotation->module->name, "xml")) {
@@ -5772,12 +5771,12 @@
             }
             while (!next) {
                 /* no siblings, go back through the parents */
-                if ((struct lyd_node *)elem->parent == start) {
+                if (lyd_parent(elem) == start) {
                     /* we are done, no next element to process */
                     break;
                 }
                 /* parent is already processed, go to its sibling */
-                elem = (struct lyd_node *)elem->parent;
+                elem = lyd_parent(elem);
                 next = elem->next;
             }
         }
@@ -6321,7 +6320,7 @@
         node = set->val.nodes[i].node;
 
         if (set->val.nodes[i].type == LYXP_NODE_ELEM) {
-            new_node = (struct lyd_node *)node->parent;
+            new_node = lyd_parent(node);
         } else if (set->val.nodes[i].type == LYXP_NODE_TEXT) {
             new_node = node;
         } else if (set->val.nodes[i].type == LYXP_NODE_META) {
@@ -6748,8 +6747,8 @@
             /* remember the node context position for position() and context size for last(),
              * predicates should always be evaluated with respect to the child axis (since we do
              * not support explicit axes) so we assign positions based on their parents */
-            if (parent_pos_pred && ((struct lyd_node *)set->val.nodes[i].node->parent != orig_parent)) {
-                orig_parent = (struct lyd_node *)set->val.nodes[i].node->parent;
+            if (parent_pos_pred && (lyd_parent(set->val.nodes[i].node) != orig_parent)) {
+                orig_parent = lyd_parent(set->val.nodes[i].node);
                 orig_pos = 1;
             } else {
                 ++orig_pos;