diff --git a/tests/utests/data/test_parser_json.c b/tests/utests/data/test_parser_json.c
index d0b479c..c253c7a 100644
--- a/tests/utests/data/test_parser_json.c
+++ b/tests/utests/data/test_parser_json.c
@@ -377,7 +377,7 @@
 
     /* opaq flag */
     CHECK_PARSE_LYD(data, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, LYD_VALIDATE_PRESENT, tree);
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0, LY_PREF_JSON, "foo3", 0, 0, NULL,  0,  "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0, LY_VALUE_JSON, "foo3", 0, 0, NULL,  0,  "");
     CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
     lyd_free_all(tree);
 
@@ -388,7 +388,7 @@
 
     /* opaq flag */
     CHECK_PARSE_LYD(data, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, LYD_VALIDATE_PRESENT, tree);
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_PREF_JSON, "l1", 0, 0, NULL,  0,  "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_VALUE_JSON, "l1", 0, 0, NULL,  0,  "");
     CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
     lyd_free_all(tree);
 
@@ -399,19 +399,19 @@
 
     /* opaq flag */
     CHECK_PARSE_LYD(data, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, LYD_VALIDATE_PRESENT, tree);
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_PREF_JSON, "l1", 0, 0, NULL,  0,  "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_VALUE_JSON, "l1", 0, 0, NULL,  0,  "");
     CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
     lyd_free_all(tree);
 
     data = "{\"a:l1\":[{\"a\":\"val_a\",\"b\":\"val_b\",\"c\":{\"val\":\"val_c\"}}]}";
     CHECK_PARSE_LYD(data, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, LYD_VALIDATE_PRESENT, tree);
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_PREF_JSON, "l1", 0, 0, NULL,  0,  "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_VALUE_JSON, "l1", 0, 0, NULL,  0,  "");
     CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
     lyd_free_all(tree);
 
     data = "{\"a:l1\":[{\"a\":\"val_a\",\"b\":\"val_b\"}]}";
     CHECK_PARSE_LYD(data, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, LYD_VALIDATE_PRESENT, tree);
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_PREF_JSON, "l1", 0, 0, NULL,  0,  "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_VALUE_JSON, "l1", 0, 0, NULL,  0,  "");
     CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
     lyd_free_all(tree);
 }
@@ -458,10 +458,10 @@
             1, LYS_CONTAINER, 0, 0, NULL, 0);
     node = lyd_child(node);
     /* z has no value */
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0, LY_PREF_JSON, "z", 0, 0, NULL,  0,  "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0, LY_VALUE_JSON, "z", 0, 0, NULL,  0,  "");
     node = node->parent->next;
     /* l1 key c has invalid value so it is at the end */
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0x1, LY_PREF_JSON, "l1", 0, 0, NULL,  0,  "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0x1, LY_VALUE_JSON, "l1", 0, 0, NULL,  0,  "");
 
     CHECK_LYD_STRING(tree, LYD_PRINT_SHRINK | LYD_PRINT_WITHSIBLINGS, data);
     lyd_free_all(tree);
diff --git a/tests/utests/data/test_parser_xml.c b/tests/utests/data/test_parser_xml.c
index 3d26002..ba79548 100644
--- a/tests/utests/data/test_parser_xml.c
+++ b/tests/utests/data/test_parser_xml.c
@@ -247,7 +247,7 @@
 
     /* opaq flag */
     CHECK_PARSE_LYD(data, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, tree);
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0, LY_PREF_XML, "foo3", 0, 0, NULL,  0,  "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0, LY_VALUE_XML, "foo3", 0, 0, NULL,  0,  "");
     CHECK_LYD_STRING(tree, LYD_PRINT_WITHSIBLINGS, "<foo3 xmlns=\"urn:tests:a\"/>\n");
     lyd_free_all(tree);
 
@@ -262,7 +262,7 @@
 
     /* opaq flag */
     CHECK_PARSE_LYD(data, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, tree);
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_PREF_XML, "l1", 0, 0, NULL,  0,  "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_VALUE_XML, "l1", 0, 0, NULL,  0,  "");
     CHECK_LYD_STRING(tree, LYD_PRINT_WITHSIBLINGS, data);
     lyd_free_all(tree);
 
@@ -277,7 +277,7 @@
 
     /* opaq flag */
     CHECK_PARSE_LYD(data, LYD_PARSE_OPAQ | LYD_PARSE_ONLY, 0, tree);
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_PREF_XML, "l1", 0, 0, NULL,  0,  "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 0x1, LY_VALUE_XML, "l1", 0, 0, NULL,  0,  "");
     CHECK_LYD_STRING(tree, LYD_PRINT_WITHSIBLINGS, data);
     lyd_free_all(tree);
 
@@ -346,10 +346,10 @@
 
     node = lyd_child(node);
     /* z has no value */
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0, LY_PREF_XML, "z", 0, 0, NULL,  0,  "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0, LY_VALUE_XML, "z", 0, 0, NULL,  0,  "");
     node = node->parent->next;
     /* l1 key c has invalid value so it is at the end */
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0x1, LY_PREF_XML, "l1", 0, 0, NULL,  0,  "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0x1, LY_VALUE_XML, "l1", 0, 0, NULL,  0,  "");
 
     CHECK_LYD_STRING(tree, LYD_PRINT_WITHSIBLINGS,
             "<edit-config xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\">\n"
@@ -524,7 +524,7 @@
     assert_non_null(op);
 
     node = tree;
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 1, 0, LY_PREF_XML, "rpc", 0, 0, 0, 0, "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 1, 0, LY_VALUE_XML, "rpc", 0, 0, 0, 0, "");
 
     assert_non_null(tree);
 
@@ -542,10 +542,10 @@
 
     node = lyd_child(node);
     /* z has no value */
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0, LY_PREF_XML, "z", 0, 0, NULL,  0,  "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0, LY_VALUE_XML, "z", 0, 0, NULL,  0,  "");
     node = node->parent->next;
     /* l1 key c has invalid value so it is at the end */
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0x1, LY_PREF_XML, "l1", 0, 0, NULL,  0,  "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)node, 0x1, 0x1, LY_VALUE_XML, "l1", 0, 0, NULL,  0,  "");
 
     CHECK_LYD_STRING(tree, LYD_PRINT_WITHSIBLINGS,
             "<rpc xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\" message-id=\"25\"/>\n");
@@ -593,8 +593,8 @@
     assert_int_equal(LY_SUCCESS, lyd_parse_op(UTEST_LYCTX, NULL, in, LYD_XML, LYD_TYPE_RPC_NETCONF, &tree, &op));
     ly_in_free(in, 0);
 
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 1, 1, LY_PREF_XML, "rpc", 0, 0, 0, 0, "");
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)lyd_child(tree), 0, 0, LY_PREF_XML, "action", 0, 0, 0, 0, "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 1, 1, LY_VALUE_XML, "rpc", 0, 0, 0, 0, "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)lyd_child(tree), 0, 0, LY_VALUE_XML, "action", 0, 0, 0, 0, "");
 
     assert_non_null(op);
     CHECK_LYSC_ACTION((struct lysc_node_action *)op->schema, NULL, 0, LYS_STATUS_CURR,
@@ -647,8 +647,8 @@
     assert_int_equal(LY_SUCCESS, lyd_parse_op(UTEST_LYCTX, NULL, in, LYD_XML, LYD_TYPE_NOTIF_NETCONF, &tree, &op2));
     ly_in_free(in, 0);
 
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 1, LY_PREF_XML, "notification", 0, 0, 0, 0, "");
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)lyd_child(tree), 0, 0, LY_PREF_XML, "eventTime", 0, 0, 0, 0,
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 0, 1, LY_VALUE_XML, "notification", 0, 0, 0, 0, "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)lyd_child(tree), 0, 0, LY_VALUE_XML, "eventTime", 0, 0, 0, 0,
             "2010-12-06T08:00:01Z");
 
     assert_non_null(op2);
@@ -674,7 +674,7 @@
     assert_int_equal(LY_SUCCESS, lyd_parse_op(UTEST_LYCTX, op, in, LYD_XML, LYD_TYPE_REPLY_NETCONF, &tree, NULL));
     ly_in_free(in, 0);
 
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 1, 0, LY_PREF_XML, "rpc-reply", 0, 0, 0, 0, "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 1, 0, LY_VALUE_XML, "rpc-reply", 0, 0, 0, 0, "");
 
     CHECK_LYD_STRING(tree, LYD_PRINT_WITHSIBLINGS,
             "<rpc-reply xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\" message-id=\"55\"/>\n");
@@ -690,8 +690,8 @@
     assert_int_equal(LY_SUCCESS, lyd_parse_op(UTEST_LYCTX, op, in, LYD_XML, LYD_TYPE_REPLY_NETCONF, &tree, NULL));
     ly_in_free(in, 0);
 
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 1, 1, LY_PREF_XML, "rpc-reply", 0, 0, 0, 0, "");
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)lyd_child(tree), 0, 0, LY_PREF_XML, "ok", 0, 0, 0, 0, "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 1, 1, LY_VALUE_XML, "rpc-reply", 0, 0, 0, 0, "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)lyd_child(tree), 0, 0, LY_VALUE_XML, "ok", 0, 0, 0, 0, "");
 
     CHECK_LYD_STRING(tree, LYD_PRINT_WITHSIBLINGS, data);
 
@@ -713,8 +713,8 @@
     assert_int_equal(LY_SUCCESS, lyd_parse_op(UTEST_LYCTX, op, in, LYD_XML, LYD_TYPE_REPLY_NETCONF, &tree, NULL));
     ly_in_free(in, 0);
 
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 1, 1, LY_PREF_XML, "rpc-reply", 0, 0, 0, 0, "");
-    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)lyd_child(tree), 0, 1, LY_PREF_XML, "rpc-error", 0, 0, 0, 0, "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)tree, 1, 1, LY_VALUE_XML, "rpc-reply", 0, 0, 0, 0, "");
+    CHECK_LYD_NODE_OPAQ((struct lyd_node_opaq *)lyd_child(tree), 0, 1, LY_VALUE_XML, "rpc-error", 0, 0, 0, 0, "");
 
     CHECK_LYD_STRING(tree, LYD_PRINT_WITHSIBLINGS, data);
 
diff --git a/tests/utests/data/test_tree_data.c b/tests/utests/data/test_tree_data.c
index f9ff619..43c99da 100644
--- a/tests/utests/data/test_tree_data.c
+++ b/tests/utests/data/test_tree_data.c
@@ -377,7 +377,7 @@
     assert_int_equal(LY_SUCCESS, ly_path_parse(UTEST_LYCTX, NULL, path_str, strlen(path_str), LY_PATH_BEGIN_EITHER, LY_PATH_LREF_FALSE,
             LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &exp));
     assert_int_equal(LY_SUCCESS, ly_path_compile(UTEST_LYCTX, NULL, NULL, NULL, exp, LY_PATH_LREF_FALSE, LY_PATH_OPER_INPUT,
-            LY_PATH_TARGET_SINGLE, LY_PREF_JSON, NULL, NULL, &path));
+            LY_PATH_TARGET_SINGLE, LY_VALUE_JSON, NULL, NULL, &path));
     term = lyd_target(path, tree);
 
     const int unsigned flag = LYS_CONFIG_R | LYS_SET_ENUM | LYS_ORDBY_USER;
diff --git a/tests/utests/data/test_types.c b/tests/utests/data/test_types.c
index 3b5d784..a06445b 100644
--- a/tests/utests/data/test_types.c
+++ b/tests/utests/data/test_types.c
@@ -480,7 +480,7 @@
     tree = tree->next;
     TEST_PATTERN_1(tree, "ident", 1, IDENT, "types:gigabit-ethernet", "gigabit-ethernet");
     leaf = (struct lyd_node_term *)tree;
-    TEST_PRINTED_VALUE(&leaf->value, "t:gigabit-ethernet", LY_PREF_SCHEMA, mod_types->parsed);
+    TEST_PRINTED_VALUE(&leaf->value, "t:gigabit-ethernet", LY_VALUE_SCHEMA, mod_types->parsed);
     lyd_free_all(tree);
 
     CHECK_PARSE_LYD("<ident xmlns=\"urn:tests:types\" xmlns:x=\"urn:tests:defs\">x:fast-ethernet</ident>", tree);
@@ -488,7 +488,7 @@
     tree = tree->next;
     TEST_PATTERN_1(tree, "ident", 1, IDENT, "defs:fast-ethernet", "fast-ethernet");
     leaf = (struct lyd_node_term *)tree;
-    TEST_PRINTED_VALUE(&leaf->value, "d:fast-ethernet", LY_PREF_SCHEMA, mod_defs->parsed);
+    TEST_PRINTED_VALUE(&leaf->value, "d:fast-ethernet", LY_VALUE_SCHEMA, mod_defs->parsed);
     lyd_free_all(tree);
 
     /* invalid value */
@@ -582,8 +582,8 @@
 
     assert_int_equal(1, LY_ARRAY_COUNT(leaf->value.target[0].predicates));
     assert_null(leaf->value.target[1].predicates);
-    TEST_PRINTED_VALUE(&leaf->value, "/t:list_inst[t:id=\"/t:leaflisttarget[.='b']\"]/t:value", LY_PREF_SCHEMA, mod_types->parsed);
-    TEST_PRINTED_VALUE(&leaf->value, "/types:list_inst[id=\"/types:leaflisttarget[.='b']\"]/value", LY_PREF_JSON, NULL);
+    TEST_PRINTED_VALUE(&leaf->value, "/t:list_inst[t:id=\"/t:leaflisttarget[.='b']\"]/t:value", LY_VALUE_SCHEMA, mod_types->parsed);
+    TEST_PRINTED_VALUE(&leaf->value, "/types:list_inst[id=\"/types:leaflisttarget[.='b']\"]/value", LY_VALUE_JSON, NULL);
     lyd_free_all(tree);
 
     data = "<list xmlns=\"urn:tests:types\"><id>a</id></list><list xmlns=\"urn:tests:types\"><id>b</id><value>x</value></list>"
@@ -980,7 +980,7 @@
     TEST_PATTERN_1(tree, "un1", 0, UNION, "12", INT8, "12", 12);
     leaf = (struct lyd_node_term *)tree;
     assert_int_equal(((struct ly_set *)leaf->value.subvalue->prefix_data)->count, 0);
-    TEST_PRINTED_VALUE(&leaf->value, "12", LY_PREF_SCHEMA, NULL);
+    TEST_PRINTED_VALUE(&leaf->value, "12", LY_VALUE_SCHEMA, NULL);
     lyd_free_all(tree);
 
     data = "<int8 xmlns=\"urn:tests:types\">12</int8><un1 xmlns=\"urn:tests:types\">2</un1>";
@@ -989,7 +989,7 @@
     TEST_PATTERN_1(tree, "un1", 0, UNION, "2", STRING, "2");
     leaf = (struct lyd_node_term *)tree;
     assert_int_equal(((struct ly_set *)leaf->value.subvalue->prefix_data)->count, 0);
-    TEST_PRINTED_VALUE(&leaf->value, "2", LY_PREF_SCHEMA, NULL);
+    TEST_PRINTED_VALUE(&leaf->value, "2", LY_VALUE_SCHEMA, NULL);
     lyd_free_all(tree);
 
     data = "<un1 xmlns=\"urn:tests:types\" xmlns:x=\"urn:tests:defs\">x:fast-ethernet</un1>";
@@ -998,8 +998,8 @@
     TEST_PATTERN_1(tree, "un1", 0, UNION, "defs:fast-ethernet", IDENT, "defs:fast-ethernet", "fast-ethernet");
     leaf = (struct lyd_node_term *)tree;
     assert_int_equal(((struct ly_set *)leaf->value.subvalue->prefix_data)->count, 1);
-    TEST_PRINTED_VALUE(&leaf->value, "d:fast-ethernet", LY_PREF_SCHEMA, mod_defs->parsed);
-    TEST_PRINTED_VALUE(&leaf->value.subvalue->value, "d:fast-ethernet", LY_PREF_SCHEMA, mod_defs->parsed);
+    TEST_PRINTED_VALUE(&leaf->value, "d:fast-ethernet", LY_VALUE_SCHEMA, mod_defs->parsed);
+    TEST_PRINTED_VALUE(&leaf->value.subvalue->value, "d:fast-ethernet", LY_VALUE_SCHEMA, mod_defs->parsed);
     lyd_free_all(tree);
 
     data = "<un1 xmlns=\"urn:tests:types\" xmlns:d=\"urn:tests:defs\">d:superfast-ethernet</un1>";
diff --git a/tests/utests/schema/test_parser_yin.c b/tests/utests/schema/test_parser_yin.c
index c283570..d492591 100644
--- a/tests/utests/schema/test_parser_yin.c
+++ b/tests/utests/schema/test_parser_yin.c
@@ -22,6 +22,7 @@
 #include "in.h"
 #include "parser_internal.h"
 #include "schema_compile.h"
+#include "tree.h"
 #include "tree_edit.h"
 #include "tree_schema.h"
 #include "tree_schema_internal.h"
@@ -122,7 +123,7 @@
 #define ELEMENT_WRAPPER_END "</status>"
 
 #define TEST_1_CHECK_LYSP_EXT_INSTANCE(NODE, INSUBSTMT)\
-    CHECK_LYSP_EXT_INSTANCE((NODE), NULL, 1, INSUBSTMT, 0, "myext:c-define", LY_PREF_XML)
+    CHECK_LYSP_EXT_INSTANCE((NODE), NULL, 1, INSUBSTMT, 0, "myext:c-define", LY_VALUE_XML)
 
 struct lys_yin_parser_ctx *YCTX;
 
@@ -336,7 +337,7 @@
 
     ret = yin_parse_extension_instance(YCTX, LY_STMT_CONTACT, 0, &exts);
     assert_int_equal(ret, LY_SUCCESS);
-    CHECK_LYSP_EXT_INSTANCE(exts, NULL, 1, LY_STMT_CONTACT, 0, "myext:ext", LY_PREF_XML);
+    CHECK_LYSP_EXT_INSTANCE(exts, NULL, 1, LY_STMT_CONTACT, 0, "myext:ext", LY_VALUE_XML);
 
     CHECK_LYSP_STMT(exts->child, arg, 0, LYS_YIN_ATTR, 0, 1, stmt);
     stmt = "value";
@@ -356,7 +357,7 @@
 
     ret = yin_parse_extension_instance(YCTX, LY_STMT_CONTACT, 0, &exts);
     assert_int_equal(ret, LY_SUCCESS);
-    CHECK_LYSP_EXT_INSTANCE(exts, NULL, 0, LY_STMT_CONTACT, 0, "myext:extension-elem", LY_PREF_XML);
+    CHECK_LYSP_EXT_INSTANCE(exts, NULL, 0, LY_STMT_CONTACT, 0, "myext:extension-elem", LY_VALUE_XML);
     lysp_ext_instance_free(UTEST_LYCTX, exts);
     LY_ARRAY_FREE(exts);
     exts = NULL;
@@ -378,7 +379,7 @@
     ret = yin_parse_extension_instance(YCTX, LY_STMT_CONTACT, 0, &exts);
     assert_int_equal(ret, LY_SUCCESS);
 
-    CHECK_LYSP_EXT_INSTANCE(exts, NULL, 1, LY_STMT_CONTACT, 0, "myext:ext", LY_PREF_XML);
+    CHECK_LYSP_EXT_INSTANCE(exts, NULL, 1, LY_STMT_CONTACT, 0, "myext:ext", LY_VALUE_XML);
 
     stmt = "attr1";
     arg = "text1";
@@ -545,7 +546,7 @@
     const char *exts_name = "myext:custom";
     const char *exts_arg = "totally amazing extension";
 
-    CHECK_LYSP_EXT_INSTANCE(exts, exts_arg, 0, LY_STMT_PREFIX, 0, exts_name, LY_PREF_XML);
+    CHECK_LYSP_EXT_INSTANCE(exts, exts_arg, 0, LY_STMT_PREFIX, 0, exts_name, LY_VALUE_XML);
     assert_string_equal(value, "wsefsdf");
     assert_string_equal(units, "radians");
     assert_string_equal(when_p->cond, "condition...");
diff --git a/tests/utests/schema/test_tree_schema_compile.c b/tests/utests/schema/test_tree_schema_compile.c
index a8e6de4..3a95fa4 100644
--- a/tests/utests/schema/test_tree_schema_compile.c
+++ b/tests/utests/schema/test_tree_schema_compile.c
@@ -278,16 +278,16 @@
     assert_non_null(ll->dflts);
     assert_int_equal(6, ll->type->refcount); /* 3x type's reference, 3x default value's reference (typedef's default does not reference own type) */
     assert_int_equal(2, LY_ARRAY_COUNT(ll->dflts));
-    assert_string_equal("1", dflt = ll->dflts[0]->realtype->plugin->print(ll->dflts[0], LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("1", dflt = ll->dflts[0]->realtype->plugin->print(ll->dflts[0], LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
-    assert_string_equal("1", dflt = ll->dflts[1]->realtype->plugin->print(ll->dflts[1], LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("1", dflt = ll->dflts[1]->realtype->plugin->print(ll->dflts[1], LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
     assert_int_equal(LYS_CONFIG_R | LYS_STATUS_CURR | LYS_ORDBY_USER | LYS_SET_DFLT | LYS_SET_CONFIG, ll->flags);
     assert_non_null((ll = (struct lysc_node_leaflist *)mod->compiled->data->next));
     assert_non_null(ll->dflts);
     assert_int_equal(6, ll->type->refcount); /* 3x type's reference, 3x default value's reference */
     assert_int_equal(1, LY_ARRAY_COUNT(ll->dflts));
-    assert_string_equal("10", dflt = ll->dflts[0]->realtype->plugin->print(ll->dflts[0], LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("10", dflt = ll->dflts[0]->realtype->plugin->print(ll->dflts[0], LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
     assert_int_equal(LYS_CONFIG_W | LYS_STATUS_CURR | LYS_ORDBY_USER, ll->flags);
 
@@ -1526,7 +1526,7 @@
     assert_non_null(type);
     assert_int_equal(LY_TYPE_LEAFREF, type->basetype);
     assert_string_equal("/a:target1", ((struct lysc_type_leafref *)type)->path->expr);
-    assert_ptr_equal(mod, ly_resolve_prefix(UTEST_LYCTX, "a", 1, LY_PREF_SCHEMA_RESOLVED, ((struct lysc_type_leafref *)type)->prefixes));
+    assert_ptr_equal(mod, ly_resolve_prefix(UTEST_LYCTX, "a", 1, LY_VALUE_SCHEMA_RESOLVED, ((struct lysc_type_leafref *)type)->prefixes));
     assert_non_null(((struct lysc_type_leafref *)type)->realtype);
     assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_leafref *)type)->realtype->basetype);
     assert_int_equal(1, ((struct lysc_type_leafref *)type)->require_instance);
@@ -1547,7 +1547,7 @@
     assert_int_equal(1, type->refcount);
     assert_int_equal(LY_TYPE_LEAFREF, type->basetype);
     assert_string_equal("/b:target", ((struct lysc_type_leafref *)type)->path->expr);
-    assert_ptr_equal(mod, ly_resolve_prefix(UTEST_LYCTX, "b", 1, LY_PREF_SCHEMA_RESOLVED, ((struct lysc_type_leafref *)type)->prefixes));
+    assert_ptr_equal(mod, ly_resolve_prefix(UTEST_LYCTX, "b", 1, LY_VALUE_SCHEMA_RESOLVED, ((struct lysc_type_leafref *)type)->prefixes));
     assert_non_null(((struct lysc_type_leafref *)type)->realtype);
     assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_leafref *)type)->realtype->basetype);
     assert_int_equal(1, ((struct lysc_type_leafref *)type)->require_instance);
@@ -1561,7 +1561,7 @@
     assert_int_equal(1, type->refcount);
     assert_int_equal(LY_TYPE_LEAFREF, type->basetype);
     assert_string_equal("/b:target", ((struct lysc_type_leafref *)type)->path->expr);
-    assert_ptr_not_equal(mod, ly_resolve_prefix(UTEST_LYCTX, "b", 1, LY_PREF_SCHEMA_RESOLVED, ((struct lysc_type_leafref *)type)->prefixes));
+    assert_ptr_not_equal(mod, ly_resolve_prefix(UTEST_LYCTX, "b", 1, LY_VALUE_SCHEMA_RESOLVED, ((struct lysc_type_leafref *)type)->prefixes));
     assert_non_null(((struct lysc_type_leafref *)type)->realtype);
     assert_int_equal(LY_TYPE_STRING, ((struct lysc_type_leafref *)type)->realtype->basetype);
     assert_int_equal(0, ((struct lysc_type_leafref *)type)->require_instance);
@@ -1570,7 +1570,7 @@
     assert_int_equal(1, type->refcount);
     assert_int_equal(LY_TYPE_LEAFREF, type->basetype);
     assert_string_equal("/b:target", ((struct lysc_type_leafref *)type)->path->expr);
-    assert_ptr_not_equal(mod, ly_resolve_prefix(UTEST_LYCTX, "b", 1, LY_PREF_SCHEMA_RESOLVED, ((struct lysc_type_leafref *)type)->prefixes));
+    assert_ptr_not_equal(mod, ly_resolve_prefix(UTEST_LYCTX, "b", 1, LY_VALUE_SCHEMA_RESOLVED, ((struct lysc_type_leafref *)type)->prefixes));
     assert_int_equal(1, ((struct lysc_type_leafref *)type)->require_instance);
 
     /* non-prefixed nodes in path are supposed to be from the module where the leafref type is instantiated */
@@ -1948,7 +1948,7 @@
     assert_int_equal(3, type->refcount);     /* 2x type reference, 1x default value's reference (typedf's default does not reference own type)*/
     assert_int_equal(LY_TYPE_STRING, type->basetype);
     assert_non_null(leaf = (struct lysc_node_leaf *)mod->compiled->data);
-    assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
     assert_string_equal("xxx", leaf->units);
 
@@ -1959,7 +1959,7 @@
     assert_int_equal(3, type->refcount);     /* 2x type reference, 1x default value's reference */
     assert_int_equal(LY_TYPE_STRING, type->basetype);
     leaf = (struct lysc_node_leaf *)mod->compiled->data;
-    assert_string_equal("goodbye", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("goodbye", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
     assert_string_equal("yyy", leaf->units);
 
@@ -1971,7 +1971,7 @@
     assert_int_equal(6, type->refcount);     /* 4x type reference, 2x default value's reference (1 shared compiled type of typedefs which default does not reference own type) */
     assert_int_equal(LY_TYPE_STRING, type->basetype);
     leaf = (struct lysc_node_leaf *)mod->compiled->data;
-    assert_string_equal("goodbye", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("goodbye", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
     assert_string_equal("yyy", leaf->units);
     type = ((struct lysc_node_leaf *)mod->compiled->data->next)->type;
@@ -1979,7 +1979,7 @@
     assert_int_equal(6, type->refcount);     /* 4x type reference, 2x default value's reference (1 shared compiled type of typedefs which default does not reference own type) */
     assert_int_equal(LY_TYPE_STRING, type->basetype);
     leaf = (struct lysc_node_leaf *)mod->compiled->data->next;
-    assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
     assert_string_equal("xxx", leaf->units);
 
@@ -1990,7 +1990,7 @@
     assert_int_equal(4, type->refcount);     /* 3x type reference, 1x default value's reference (typedef's default does not reference own type) */
     assert_int_equal(LY_TYPE_STRING, type->basetype);
     leaf = (struct lysc_node_leaf *)mod->compiled->data;
-    assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
     assert_string_equal("xxx", leaf->units);
 
@@ -2265,16 +2265,16 @@
     assert_non_null((leaf = (struct lysc_node_leaf *)((struct lysc_node_container *)parent)->child));
     assert_int_equal(LYS_LEAF, leaf->nodetype);
     assert_string_equal("l", leaf->name);
-    assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
     assert_int_equal(LYS_CONFIG_R, leaf->flags & LYS_CONFIG_MASK);
     assert_non_null(llist = (struct lysc_node_leaflist *)leaf->next);
     assert_int_equal(LYS_LEAFLIST, llist->nodetype);
     assert_string_equal("ll", llist->name);
     assert_int_equal(2, LY_ARRAY_COUNT(llist->dflts));
-    assert_string_equal("hello", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("hello", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
-    assert_string_equal("world", llist->dflts[1]->realtype->plugin->print(llist->dflts[1], LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("world", llist->dflts[1]->realtype->plugin->print(llist->dflts[1], LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
     assert_int_equal(5, llist->max);
     assert_non_null(child = llist->next);
@@ -2287,7 +2287,7 @@
     assert_int_equal(LYS_LEAF, leaf->nodetype);
     assert_string_equal("x", leaf->name);
     assert_false(LYS_MAND_TRUE & leaf->flags);
-    assert_string_equal("cheers!", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("cheers!", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
     assert_non_null(leaf->musts);
     assert_int_equal(2, LY_ARRAY_COUNT(leaf->musts));
@@ -2314,7 +2314,7 @@
     assert_int_equal(LYS_LEAF, leaf->nodetype);
     assert_string_equal("x", leaf->name);
     assert_false(LYS_MAND_TRUE & leaf->flags);
-    assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
 
     /* invalid */
@@ -2647,15 +2647,15 @@
     assert_null(leaf->dflt);
     assert_non_null(llist = (struct lysc_node_leaflist *)leaf->next);
     assert_int_equal(1, LY_ARRAY_COUNT(llist->dflts));
-    assert_string_equal("hello", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("hello", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
     assert_non_null(leaf = (struct lysc_node_leaf *)llist->next);
-    assert_string_equal("nothing", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("nothing", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
     assert_int_equal(5, leaf->dflt->realtype->refcount);     /* 3x type reference, 2x default value reference (typedef's default does not reference own type) */
     assert_non_null(llist = (struct lysc_node_leaflist *)leaf->next);
     assert_int_equal(1, LY_ARRAY_COUNT(llist->dflts));
-    assert_string_equal("nothing", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("nothing", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
 
     assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module g {yang-version 1.1; namespace urn:g;prefix g;import e {prefix x;}"
@@ -2672,19 +2672,19 @@
     assert_string_equal("ba", ((struct lysc_node_choice *)node)->dflt->name);
     assert_non_null(leaf = (struct lysc_node_leaf *)node->next);
     assert_non_null(leaf->dflt);
-    assert_string_equal("bye", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("bye", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
     assert_non_null(llist = (struct lysc_node_leaflist *)leaf->next);
     assert_int_equal(3, LY_ARRAY_COUNT(llist->dflts));
-    assert_string_equal("hello", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("hello", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
-    assert_string_equal("all", llist->dflts[1]->realtype->plugin->print(llist->dflts[1], LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("all", llist->dflts[1]->realtype->plugin->print(llist->dflts[1], LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
-    assert_string_equal("people", llist->dflts[2]->realtype->plugin->print(llist->dflts[2], LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("people", llist->dflts[2]->realtype->plugin->print(llist->dflts[2], LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
     assert_non_null(leaf = (struct lysc_node_leaf *)llist->next);
     assert_non_null(leaf->dflt);
-    assert_string_equal("hi", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("hi", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
     assert_int_equal(6, leaf->dflt->realtype->refcount);     /* 3x type reference, 3x default value reference
     - previous type's default values were replaced by node's default values where d2 now has 2 default values */
@@ -2692,9 +2692,9 @@
     assert_int_equal(0, LY_ARRAY_COUNT(leaf->musts[0].prefixes));
     assert_non_null(llist = (struct lysc_node_leaflist *)leaf->next);
     assert_int_equal(2, LY_ARRAY_COUNT(llist->dflts));
-    assert_string_equal("hi", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("hi", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
-    assert_string_equal("all", llist->dflts[1]->realtype->plugin->print(llist->dflts[1], LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("all", llist->dflts[1]->realtype->plugin->print(llist->dflts[1], LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
 
     assert_int_equal(LY_SUCCESS, lys_parse_mem(UTEST_LYCTX, "module h {yang-version 1.1; namespace urn:h;prefix h;import e {prefix x;}"
@@ -2708,7 +2708,7 @@
     assert_string_equal("ba", ((struct lysc_node_choice *)node)->dflt->name);
     assert_non_null(leaf = (struct lysc_node_leaf *)node->next);
     assert_non_null(leaf->dflt);
-    assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("hello", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
 
     ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, "module i {namespace urn:i;prefix i;"
@@ -2825,14 +2825,14 @@
     assert_non_null(leaf = (struct lysc_node_leaf *)mod->compiled->data);
     assert_string_equal("a", leaf->name);
     assert_int_equal(LY_TYPE_INT8, leaf->type->basetype);
-    assert_string_equal("10", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("10", leaf->dflt->realtype->plugin->print(leaf->dflt, LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
     assert_int_equal(10, leaf->dflt->uint8);
     assert_non_null(llist = (struct lysc_node_leaflist *)leaf->next);
     assert_string_equal("b", llist->name);
     assert_int_equal(LY_TYPE_INT8, llist->type->basetype);
     assert_int_equal(1, LY_ARRAY_COUNT(llist->dflts));
-    assert_string_equal("1", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LY_PREF_SCHEMA, NULL, &dynamic));
+    assert_string_equal("1", llist->dflts[0]->realtype->plugin->print(llist->dflts[0], LY_VALUE_SCHEMA, NULL, &dynamic));
     assert_int_equal(0, dynamic);
     assert_int_equal(1, llist->dflts[0]->uint8);
 
@@ -2873,7 +2873,7 @@
     assert_non_null(leaf = (struct lysc_node_leaf *)mod->compiled->data);
     assert_string_equal("s", leaf->name);
     assert_non_null(leaf->dflt);
-    assert_non_null(str = leaf->dflt->realtype->plugin->print(leaf->dflt, LY_PREF_SCHEMA, mod->parsed, &dynamic));
+    assert_non_null(str = leaf->dflt->realtype->plugin->print(leaf->dflt, LY_VALUE_SCHEMA, mod->parsed, &dynamic));
     assert_string_equal("/s:y", str);
     if (dynamic) {
         free((char *)str);
diff --git a/tests/utests/types/bits.c b/tests/utests/types/bits.c
index e674ea9..43eeac3 100644
--- a/tests/utests/types/bits.c
+++ b/tests/utests/types/bits.c
@@ -775,28 +775,28 @@
      */
     val_text = "";
     assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err));
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err));
     CHECK_LYD_VALUE(value, BITS, "");
     assert_ptr_equal(value.realtype, lysc_type);
     type->free(UTEST_LYCTX, &value);
 
     val_text = "zero one two";
     assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err));
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err));
     CHECK_LYD_VALUE(value, BITS, "zero one two", "zero", "one", "two");
     assert_ptr_equal(value.realtype, lysc_type);
     type->free(UTEST_LYCTX, &value);
 
     val_text = "zero two";
     assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err));
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err));
     CHECK_LYD_VALUE(value, BITS, "zero two", "zero", "two");
     assert_ptr_equal(value.realtype, lysc_type);
     type->free(UTEST_LYCTX, &value);
 
     val_text = "\n ";
     ly_ret = type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err);
     assert_int_equal(LY_SUCCESS, ly_ret);
     CHECK_LYD_VALUE(value, BITS, "");
     assert_ptr_equal(value.realtype, lysc_type);
@@ -810,7 +810,7 @@
     alloc = (char *)malloc(strlen(val_text) + 1);
     memcpy(alloc, val_text, strlen(val_text) + 1);
     ly_ret = type->store(UTEST_LYCTX, lysc_type, alloc, strlen(val_text),
-            LYPLG_TYPE_STORE_DYNAMIC, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err);
+            LYPLG_TYPE_STORE_DYNAMIC, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err);
     alloc = NULL;
     assert_int_equal(LY_SUCCESS, ly_ret);
     CHECK_LYD_VALUE(value, BITS, "two", "two");
@@ -821,7 +821,7 @@
     lysc_type_test.basetype = LY_TYPE_INT8;
     val_text = "two";
     ly_ret = type->store(UTEST_LYCTX, &lysc_type_test, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err);
     assert_int_equal(LY_EINVAL, ly_ret);
     ly_err_free(err);
 
@@ -831,14 +831,14 @@
     val_text = "two";
     err = NULL;
     ly_ret = type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
     assert_int_equal(LY_EVALID, ly_ret);
     ly_err_free(err);
 
     val_text = "two two";
     err = NULL;
     ly_ret = type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err);
     assert_int_equal(LY_EVALID, ly_ret);
     ly_err_free(err);
 }
@@ -873,7 +873,7 @@
     /* CREATE VALUES */
     for (unsigned int it = 0; it < sizeof(val_init) / sizeof(val_init[0]); it++) {
         ly_ret = type->store(UTEST_LYCTX, lysc_type, val_init[it], strlen(val_init[it]),
-                0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &(values[it]), NULL, &err);
+                0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &(values[it]), NULL, &err);
         assert_int_equal(LY_SUCCESS, ly_ret);
     }
 
@@ -894,7 +894,7 @@
     diff_type_text = val_init[2];
     diff_type = ((struct lysc_node_leaf *)mod->compiled->data->next)->type;
     ly_ret = diff_type->plugin->store(UTEST_LYCTX, diff_type, diff_type_text, strlen(diff_type_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &diff_type_val, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &diff_type_val, NULL, &err);
     assert_int_equal(LY_SUCCESS, ly_ret);
     assert_int_equal(LY_SUCCESS, type->compare(&diff_type_val, &(values[2])));
     assert_int_equal(LY_ENOT,    type->compare(&diff_type_val, &(values[1])));
@@ -906,7 +906,7 @@
     diff_type_text = val_init[2];
     diff_type = ((struct lysc_node_leaf *)mod->compiled->data->next->next)->type;
     ly_ret = diff_type->plugin->store(UTEST_LYCTX, diff_type, diff_type_text, strlen(diff_type_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &diff_type_val, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &diff_type_val, NULL, &err);
     assert_int_equal(LY_SUCCESS, ly_ret);
     assert_int_equal(LY_ENOT, type->compare(&diff_type_val, &(values[2])));
     assert_int_equal(LY_ENOT, type->compare(&diff_type_val, &(values[1])));
@@ -918,7 +918,7 @@
     diff_type_text = val_init[2];
     diff_type = ((struct lysc_node_leaf *)mod->compiled->data->next->next->next)->type;
     ly_ret = diff_type->plugin->store(UTEST_LYCTX, diff_type, diff_type_text, strlen(diff_type_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &diff_type_val, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &diff_type_val, NULL, &err);
     assert_int_equal(LY_SUCCESS, ly_ret);
     assert_int_equal(LY_ENOT, type->compare(&diff_type_val, &(values[2])));
     assert_int_equal(LY_ENOT, type->compare(&diff_type_val, &(values[0])));
@@ -953,19 +953,19 @@
     /* CREATE VALUES */
     for (unsigned int it = 0; it < sizeof(val_init) / sizeof(val_init[0]); it++) {
         ly_ret = type->store(UTEST_LYCTX, lysc_type, val_init[it], strlen(val_init[it]),
-                0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &(values[it]), NULL, &err);
+                0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &(values[it]), NULL, &err);
         assert_int_equal(LY_SUCCESS, ly_ret);
     }
 
     /* print value */
     ly_bool dynamic = 0;
 
-    assert_string_equal("", type->print(&(values[0]), LY_PREF_XML, NULL, &dynamic));
-    assert_string_equal("zero two", type->print(&(values[1]), LY_PREF_XML, NULL, &dynamic));
-    assert_string_equal("three", type->print(&(values[2]), LY_PREF_XML, NULL, &dynamic));
-    assert_string_equal("zero two", type->print(&(values[3]), LY_PREF_XML, NULL, &dynamic));
-    assert_string_equal("zero", type->print(&(values[4]), LY_PREF_XML, NULL, &dynamic));
-    assert_string_equal("three", type->print(&(values[5]), LY_PREF_XML, NULL, &dynamic));
+    assert_string_equal("", type->print(&(values[0]), LY_VALUE_XML, NULL, &dynamic));
+    assert_string_equal("zero two", type->print(&(values[1]), LY_VALUE_XML, NULL, &dynamic));
+    assert_string_equal("three", type->print(&(values[2]), LY_VALUE_XML, NULL, &dynamic));
+    assert_string_equal("zero two", type->print(&(values[3]), LY_VALUE_XML, NULL, &dynamic));
+    assert_string_equal("zero", type->print(&(values[4]), LY_VALUE_XML, NULL, &dynamic));
+    assert_string_equal("three", type->print(&(values[5]), LY_VALUE_XML, NULL, &dynamic));
 
     for (unsigned int it = 0; it < sizeof(val_init) / sizeof(val_init[0]); it++) {
         type->free(UTEST_LYCTX, &(values[it]));
@@ -995,7 +995,7 @@
     /* CREATE VALUES */
     for (unsigned int it = 0; it < sizeof(val_init) / sizeof(val_init[0]); it++) {
         ly_ret = type->store(UTEST_LYCTX, lysc_type, val_init[it], strlen(val_init[it]),
-                0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &(values[it]), NULL, &err);
+                0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &(values[it]), NULL, &err);
         assert_int_equal(LY_SUCCESS, ly_ret);
     }
 
diff --git a/tests/utests/types/int8.c b/tests/utests/types/int8.c
index 0154d4f..05f2009 100644
--- a/tests/utests/types/int8.c
+++ b/tests/utests/types/int8.c
@@ -1401,21 +1401,21 @@
      */
     val_text = "20";
     assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_DECNUM, NULL, &value, NULL, &err));
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_DECNUM, NULL, &value, NULL, &err));
     CHECK_LYD_VALUE(value, INT8, "20", 20);
     assert_ptr_equal(value.realtype, lysc_type);
     type->free(UTEST_LYCTX, &value);
 
     val_text = "-20";
     assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_DECNUM, NULL, &value, NULL, &err));
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_DECNUM, NULL, &value, NULL, &err));
     CHECK_LYD_VALUE(value, INT8, "-20", -20);
     assert_ptr_equal(value.realtype, lysc_type);
     type->free(UTEST_LYCTX, &value);
 
     val_text = "0xf";
     ly_ret = type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
     assert_int_equal(LY_SUCCESS, ly_ret);
     CHECK_LYD_VALUE(value, INT8, "15", 15);
     assert_ptr_equal(value.realtype, lysc_type);
@@ -1423,7 +1423,7 @@
 
     val_text = "1B";
     ly_ret = type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
     assert_int_equal(LY_SUCCESS, ly_ret);
     CHECK_LYD_VALUE(value, INT8, "27", 27);
     assert_ptr_equal(value.realtype, lysc_type);
@@ -1431,7 +1431,7 @@
 
     val_text = "-0xf";
     ly_ret = type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
     assert_int_equal(LY_SUCCESS, ly_ret);
     CHECK_LYD_VALUE(value, INT8, "-15", -15);
     assert_ptr_equal(value.realtype, lysc_type);
@@ -1439,7 +1439,7 @@
 
     val_text = "027";
     ly_ret = type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_OCTNUM, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_OCTNUM, NULL, &value, NULL, &err);
     assert_int_equal(LY_SUCCESS, ly_ret);
     CHECK_LYD_VALUE(value, INT8, "23", 23);
     assert_ptr_equal(value.realtype, lysc_type);
@@ -1447,7 +1447,7 @@
 
     val_text = "-027";
     ly_ret = type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_OCTNUM, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_OCTNUM, NULL, &value, NULL, &err);
     assert_int_equal(LY_SUCCESS, ly_ret);
     CHECK_LYD_VALUE(value, INT8, "-23", -23);
     assert_ptr_equal(value.realtype, lysc_type);
@@ -1462,7 +1462,7 @@
 
     memcpy(alloc, val_text, strlen(val_text) + 1);
     ly_ret = type->store(UTEST_LYCTX, lysc_type, alloc, strlen(val_text),
-            LYPLG_TYPE_STORE_DYNAMIC, LY_PREF_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
+            LYPLG_TYPE_STORE_DYNAMIC, LY_VALUE_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
     alloc = NULL;
     assert_int_equal(LY_SUCCESS, ly_ret);
     CHECK_LYD_VALUE(value, INT8, "10", 10);
@@ -1473,7 +1473,7 @@
     lysc_type_test.basetype = LY_TYPE_UINT8;
     val_text = "20";
     ly_ret = type->store(UTEST_LYCTX, &lysc_type_test, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
     assert_int_equal(LY_EINT, ly_ret);
 
     /*
@@ -1482,28 +1482,28 @@
     val_text = "";
     err = NULL;
     ly_ret = type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
     assert_int_equal(LY_EVALID, ly_ret);
     ly_err_free(err);
 
     val_text = "";
     err = NULL;
     ly_ret = type->store(UTEST_LYCTX, lysc_type, val_text, 1,
-            0, LY_PREF_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
     assert_int_equal(LY_EVALID, ly_ret);
     ly_err_free(err);
 
     val_text = "10 b";
     err = NULL;
     ly_ret = type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &value, NULL, &err);
     assert_int_equal(LY_EVALID, ly_ret);
     ly_err_free(err);
 
     val_text = "a";
     err = NULL;
     ly_ret = type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_DECNUM, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_DECNUM, NULL, &value, NULL, &err);
     assert_int_equal(LY_EVALID, ly_ret);
     ly_err_free(err);
 }
@@ -1537,7 +1537,7 @@
     /* CREATE VALUES */
     for (unsigned int it = 0; it < sizeof(val_init) / sizeof(val_init[0]); it++) {
         ly_ret = type->store(UTEST_LYCTX, lysc_type, val_init[it], strlen(val_init[it]),
-                0, LY_PREF_XML, NULL, LYD_VALHINT_DECNUM, NULL, &(values[it]), NULL, &err);
+                0, LY_VALUE_XML, NULL, LYD_VALHINT_DECNUM, NULL, &(values[it]), NULL, &err);
         assert_int_equal(LY_SUCCESS, ly_ret);
     }
 
@@ -1557,7 +1557,7 @@
     diff_type_text = "20";
     diff_type = ((struct lysc_node_leaf *)mod->compiled->data->next)->type;
     ly_ret = diff_type->plugin->store(UTEST_LYCTX, diff_type, diff_type_text, strlen(diff_type_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_DECNUM, NULL, &diff_type_val, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_DECNUM, NULL, &diff_type_val, NULL, &err);
     assert_int_equal(LY_SUCCESS, ly_ret);
     assert_int_equal(LY_SUCCESS, type->compare(&diff_type_val, &(values[0])));
     assert_int_equal(LY_ENOT, type->compare(&diff_type_val, &(values[1])));
@@ -1569,7 +1569,7 @@
     diff_type_text = "20";
     diff_type = ((struct lysc_node_leaf *)mod->compiled->data->next->next)->type;
     ly_ret = diff_type->plugin->store(UTEST_LYCTX, diff_type, diff_type_text, strlen(diff_type_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_DECNUM, NULL, &diff_type_val, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_DECNUM, NULL, &diff_type_val, NULL, &err);
     assert_int_equal(LY_SUCCESS, ly_ret);
     assert_int_equal(LY_ENOT, type->compare(&diff_type_val, &(values[0])));
     assert_int_equal(LY_ENOT, type->compare(&diff_type_val, &(values[1])));
@@ -1581,7 +1581,7 @@
     diff_type_text = "20";
     diff_type = ((struct lysc_node_leaf *)mod->compiled->data->next->next->next)->type;
     ly_ret = diff_type->plugin->store(UTEST_LYCTX, diff_type, diff_type_text, strlen(diff_type_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_DECNUM, NULL, &diff_type_val, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_DECNUM, NULL, &diff_type_val, NULL, &err);
     assert_int_equal(LY_SUCCESS, ly_ret);
     assert_int_equal(LY_ENOT, type->compare(&diff_type_val, &(values[0])));
     assert_int_equal(LY_ENOT, type->compare(&diff_type_val, &(values[1])));
@@ -1614,19 +1614,19 @@
     /* CREATE VALUES */
     for (unsigned int it = 0; it < sizeof(val_init) / sizeof(val_init[0]); it++) {
         ly_ret = type->store(UTEST_LYCTX, lysc_type, val_init[it], strlen(val_init[it]),
-                0, LY_PREF_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &(values[it]), NULL, &err);
+                0, LY_VALUE_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &(values[it]), NULL, &err);
         assert_int_equal(LY_SUCCESS, ly_ret);
     }
 
     /* print value */
     ly_bool dynamic = 0;
 
-    assert_string_equal("32", type->print(&(values[0]), LY_PREF_XML, NULL, &dynamic));
-    assert_string_equal("74", type->print(&(values[1]), LY_PREF_XML, NULL, &dynamic));
-    assert_string_equal("-15", type->print(&(values[2]), LY_PREF_XML, NULL, &dynamic));
-    assert_string_equal("0", type->print(&(values[3]), LY_PREF_XML, NULL, &dynamic));
-    assert_string_equal("0", type->print(&(values[4]), LY_PREF_XML, NULL, &dynamic));
-    assert_string_equal("-32", type->print(&(values[5]), LY_PREF_XML, NULL, &dynamic));
+    assert_string_equal("32", type->print(&(values[0]), LY_VALUE_XML, NULL, &dynamic));
+    assert_string_equal("74", type->print(&(values[1]), LY_VALUE_XML, NULL, &dynamic));
+    assert_string_equal("-15", type->print(&(values[2]), LY_VALUE_XML, NULL, &dynamic));
+    assert_string_equal("0", type->print(&(values[3]), LY_VALUE_XML, NULL, &dynamic));
+    assert_string_equal("0", type->print(&(values[4]), LY_VALUE_XML, NULL, &dynamic));
+    assert_string_equal("-32", type->print(&(values[5]), LY_VALUE_XML, NULL, &dynamic));
 
     for (unsigned int it = 0; it < sizeof(val_init) / sizeof(val_init[0]); it++) {
         type->free(UTEST_LYCTX, &(values[it]));
@@ -1662,7 +1662,7 @@
     /* CREATE VALUES */
     for (unsigned int it = 0; it < sizeof(val_init) / sizeof(val_init[0]); it++) {
         ly_ret = type->store(UTEST_LYCTX, lysc_type[it % 2], val_init[it], strlen(val_init[it]),
-                0, LY_PREF_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &(values[it]), NULL, &err);
+                0, LY_VALUE_XML, NULL, LYD_VALHINT_HEXNUM, NULL, &(values[it]), NULL, &err);
         assert_int_equal(LY_SUCCESS, ly_ret);
     }
 
diff --git a/tests/utests/types/string.c b/tests/utests/types/string.c
index 8007744..5ddb872 100644
--- a/tests/utests/types/string.c
+++ b/tests/utests/types/string.c
@@ -1059,35 +1059,35 @@
     /* check store */
     val_text = "20";
     assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err));
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err));
     CHECK_LYD_VALUE(value, STRING, "20");
     assert_ptr_equal(value.realtype, lysc_type);
     type->free(UTEST_LYCTX, &value);
 
     val_text = "150\n";
     assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err));
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err));
     CHECK_LYD_VALUE(value, STRING, "150\n");
     assert_ptr_equal(value.realtype, lysc_type);
     type->free(UTEST_LYCTX, &value);
 
     val_text = "<\"150>\n";
     assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err));
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err));
     CHECK_LYD_VALUE(value, STRING, "<\"150>\n");
     assert_ptr_equal(value.realtype, lysc_type);
     type->free(UTEST_LYCTX, &value);
 
     val_text = "<\"150>\n|hi how are you";
     assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, val_text, 8,
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err));
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err));
     CHECK_LYD_VALUE(value, STRING, "<\"150>\n|");
     assert_ptr_equal(value.realtype, lysc_type);
     type->free(UTEST_LYCTX, &value);
 
     val_text = "";
     assert_int_equal(LY_SUCCESS, type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err));
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err));
     CHECK_LYD_VALUE(value, STRING, "");
     assert_ptr_equal(value.realtype, lysc_type);
     type->free(UTEST_LYCTX, &value);
@@ -1102,7 +1102,7 @@
     memcpy(alloc_text, val_text, alloc_text_size + 1);
 
     ly_ret = type->store(UTEST_LYCTX, lysc_type, alloc_text, alloc_text_size,
-            LYPLG_TYPE_STORE_DYNAMIC, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err);
+            LYPLG_TYPE_STORE_DYNAMIC, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err);
     alloc_text = NULL;
     assert_int_equal(LY_SUCCESS, ly_ret);
     CHECK_LYD_VALUE(value, STRING, "<250>");
@@ -1114,7 +1114,7 @@
     lysc_type_test.basetype = LY_TYPE_UINT8;
     val_text = "20";
     ly_ret = type->store(UTEST_LYCTX, &lysc_type_test, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err);
     assert_int_equal(LY_EINVAL, ly_ret);
     ly_err_free(err);
 
@@ -1123,21 +1123,21 @@
     val_text = "10 \"| bcdei";
     err = NULL;
     ly_ret = type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err);
     assert_int_equal(LY_EVALID, ly_ret);
     ly_err_free(err);
 
     val_text = "012345678901";
     err = NULL;
     ly_ret = type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &value, NULL, &err);
     assert_int_equal(LY_EVALID, ly_ret);
     ly_err_free(err);
 
     val_text = "10";
     err = NULL;
     ly_ret = type->store(UTEST_LYCTX, lysc_type, val_text, strlen(val_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_DECNUM, NULL, &value, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_DECNUM, NULL, &value, NULL, &err);
     assert_int_equal(LY_EVALID, ly_ret);
     ly_err_free(err);
 
@@ -1173,7 +1173,7 @@
 
     for (int unsigned it = 0; it < sizeof(val_init) / sizeof(val_init[0]); it++) {
         ly_ret = type->store(UTEST_LYCTX, lysc_type, val_init[it], strlen(val_init[it]),
-                0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &(values[it]), NULL, &err);
+                0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &(values[it]), NULL, &err);
         assert_int_equal(LY_SUCCESS, ly_ret);
     }
 
@@ -1189,7 +1189,7 @@
     diff_type_text = "hi";
     diff_type = ((struct lysc_node_leaf *) mod->compiled->data->next)->type;
     ly_ret = diff_type->plugin->store(UTEST_LYCTX, diff_type, diff_type_text, strlen(diff_type_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &diff_type_val, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &diff_type_val, NULL, &err);
     assert_int_equal(LY_SUCCESS, ly_ret);
     assert_int_equal(LY_SUCCESS, type->compare(&diff_type_val, &(values[0])));
     assert_int_equal(LY_ENOT, type->compare(&diff_type_val, &(values[1])));
@@ -1199,7 +1199,7 @@
     diff_type_text = "hi";
     diff_type = ((struct lysc_node_leaf *) mod->compiled->data->next->next)->type;
     ly_ret = diff_type->plugin->store(UTEST_LYCTX, diff_type, diff_type_text, strlen(diff_type_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &diff_type_val, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &diff_type_val, NULL, &err);
     assert_int_equal(LY_SUCCESS, ly_ret);
     assert_int_equal(LY_ENOT, type->compare(&diff_type_val, &(values[0])));
     assert_int_equal(LY_ENOT, type->compare(&diff_type_val, &(values[1])));
@@ -1209,7 +1209,7 @@
     diff_type_text = "20";
     diff_type = ((struct lysc_node_leaf *) mod->compiled->data->next->next->next)->type;
     ly_ret = diff_type->plugin->store(UTEST_LYCTX, diff_type, diff_type_text, strlen(diff_type_text),
-            0, LY_PREF_XML, NULL, LYD_VALHINT_DECNUM, NULL, &diff_type_val, NULL, &err);
+            0, LY_VALUE_XML, NULL, LYD_VALHINT_DECNUM, NULL, &diff_type_val, NULL, &err);
     assert_int_equal(LY_SUCCESS, ly_ret);
     assert_int_equal(LY_ENOT, type->compare(&diff_type_val, &(values[0])));
     assert_int_equal(LY_ENOT, type->compare(&diff_type_val, &(values[1])));
@@ -1242,17 +1242,17 @@
 
     for (int unsigned it = 0; it < sizeof(val_init) / sizeof(val_init[0]); it++) {
         ly_ret = type->store(UTEST_LYCTX, lysc_type, val_init[it], strlen(val_init[it]),
-                0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &(values[it]), NULL, &err);
+                0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &(values[it]), NULL, &err);
         assert_int_equal(LY_SUCCESS, ly_ret);
     }
 
     /* print value */
     ly_bool dynamic = 0;
 
-    assert_string_equal("20", type->print(&(values[0]), LY_PREF_XML, NULL, &dynamic));
-    assert_string_equal("0x4A", type->print(&(values[1]), LY_PREF_XML, NULL, &dynamic));
-    assert_string_equal("<|>", type->print(&(values[2]), LY_PREF_XML, NULL, &dynamic));
-    assert_string_equal("\"", type->print(&(values[3]), LY_PREF_XML, NULL, &dynamic));
+    assert_string_equal("20", type->print(&(values[0]), LY_VALUE_XML, NULL, &dynamic));
+    assert_string_equal("0x4A", type->print(&(values[1]), LY_VALUE_XML, NULL, &dynamic));
+    assert_string_equal("<|>", type->print(&(values[2]), LY_VALUE_XML, NULL, &dynamic));
+    assert_string_equal("\"", type->print(&(values[3]), LY_VALUE_XML, NULL, &dynamic));
 
     for (int unsigned it = 0; it < sizeof(val_init) / sizeof(val_init[0]); it++) {
         type->free(UTEST_LYCTX, &(values[it]));
@@ -1289,7 +1289,7 @@
 
     for (int unsigned it = 0; it < sizeof(val_init) / sizeof(val_init[0]); it++) {
         ly_ret = type->store(UTEST_LYCTX, lysc_type[it % 2], val_init[it], strlen(val_init[it]),
-                0, LY_PREF_XML, NULL, LYD_VALHINT_STRING, NULL, &(values[it]), NULL, &err);
+                0, LY_VALUE_XML, NULL, LYD_VALHINT_STRING, NULL, &(values[it]), NULL, &err);
         assert_int_equal(LY_SUCCESS, ly_ret);
     }