diff --git a/src/interpreter.cpp b/src/interpreter.cpp
index 5b13337..ca227be 100644
--- a/src/interpreter.cpp
+++ b/src/interpreter.cpp
@@ -95,10 +95,10 @@
         auto leafType = m_datastore.schema()->leafType(path);
         auto typedefName = m_datastore.schema()->leafTypeName(path);
         std::string baseTypeStr;
-        if (leafType == yang::LeafDataTypes::LeafRef) {
+        if (std::holds_alternative<yang::LeafRef>(leafType)) {
             ss << "-> ";
             ss << m_datastore.schema()->leafrefPath(path) << " ";
-            baseTypeStr = leafDataTypeToString(m_datastore.schema()->leafrefBaseType(path));
+            baseTypeStr = leafDataTypeToString(m_datastore.schema()->leafType(std::get<yang::LeafRef>(leafType).m_targetXPath));
         } else {
             baseTypeStr = leafDataTypeToString(leafType);
         }
diff --git a/src/leaf_data.cpp b/src/leaf_data.cpp
deleted file mode 100644
index 0d14fe3..0000000
--- a/src/leaf_data.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-/*
- * Copyright (C) 2020 CESNET, https://photonics.cesnet.cz/
- *
- * Written by Václav Kubernát <kubernat@cesnet.cz>
- *
-*/
-
-#include "leaf_data.hpp"
-template <>
-std::set<std::string> createSetSuggestions_class<yang::LeafDataTypes::Enum>::getSuggestions(const ParserContext& parserContext, const Schema& schema) const
-{
-    return schema.enumValues(parserContext.m_tmpListKeyLeafPath.m_location, parserContext.m_tmpListKeyLeafPath.m_node);
-}
-
-template <>
-std::set<std::string> createSetSuggestions_class<yang::LeafDataTypes::IdentityRef>::getSuggestions(const ParserContext& parserContext, const Schema& schema) const
-{
-    return schema.validIdentities(parserContext.m_tmpListKeyLeafPath.m_location, parserContext.m_tmpListKeyLeafPath.m_node, Prefixes::WhenNeeded);
-}
diff --git a/src/leaf_data.hpp b/src/leaf_data.hpp
index bbacbea..7139fc4 100644
--- a/src/leaf_data.hpp
+++ b/src/leaf_data.hpp
@@ -8,102 +8,34 @@
 #pragma once
 
 #include <boost/spirit/home/x3.hpp>
-#include "ast_values.hpp"
 #include "ast_handlers.hpp"
 #include "common_parsers.hpp"
+#include "leaf_data_type.hpp"
 #include "schema.hpp"
 namespace x3 = boost::spirit::x3;
 
-template <yang::LeafDataTypes TYPE>
+template <typename TYPE>
 struct leaf_data_class;
 
-template <yang::LeafDataTypes TYPE>
-struct createSetSuggestions_class {
-    std::set<std::string> getSuggestions(const ParserContext& ctx, const Schema& schema) const;
-
-    template <typename T, typename Iterator, typename Context>
-    void on_success(Iterator const& begin, Iterator const&, T&, Context const& context)
-    {
-        auto& parserContext = x3::get<parser_context_tag>(context);
-        const Schema& schema = parserContext.m_schema;
-
-        // Only generate completions if the type is correct so that we don't
-        // overwrite some other completions.
-        if (schema.leafType(parserContext.m_tmpListKeyLeafPath.m_location, parserContext.m_tmpListKeyLeafPath.m_node) == TYPE) {
-            parserContext.m_completionIterator = begin;
-            auto suggestions = getSuggestions(parserContext, schema);
-            std::set<Completion> res;
-            std::transform(suggestions.begin(), suggestions.end(), std::inserter(res, res.end()), [](auto it) { return Completion{it}; });
-            parserContext.m_suggestions = res;
-        }
-    }
-};
-
-template <>
-struct leaf_data_class<yang::LeafDataTypes::Enum> {
-    template <typename T, typename Iterator, typename Context>
-    void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
-    {
-        if (_pass(context) == false)
-            return;
-        auto& parserContext = x3::get<parser_context_tag>(context);
-        auto& schema = parserContext.m_schema;
-
-        if (!schema.leafEnumHasValue(parserContext.m_tmpListKeyLeafPath.m_location, parserContext.m_tmpListKeyLeafPath.m_node, ast.m_value)) {
-            _pass(context) = false;
-            parserContext.m_errorMsg = "leaf data type mismatch: Expected an enum here. Allowed values:";
-            for (const auto& it : schema.enumValues(parserContext.m_tmpListKeyLeafPath.m_location, parserContext.m_tmpListKeyLeafPath.m_node)) {
-                parserContext.m_errorMsg += " " + it;
-            }
-        }
-    }
-};
-
-template <>
-struct leaf_data_class<yang::LeafDataTypes::IdentityRef> {
-    template <typename T, typename Iterator, typename Context>
-    void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
-    {
-        auto& parserContext = x3::get<parser_context_tag>(context);
-        auto& schema = parserContext.m_schema;
-
-        ModuleValuePair pair;
-        if (ast.m_prefix) {
-            pair.first = ast.m_prefix.get().m_name;
-        }
-        pair.second = ast.m_value;
-
-        if (!schema.leafIdentityIsValid(parserContext.m_tmpListKeyLeafPath.m_location, parserContext.m_tmpListKeyLeafPath.m_node, pair)) {
-            _pass(context) = false;
-        }
-    }
-};
-
-x3::rule<leaf_data_class<yang::LeafDataTypes::Enum>, enum_> const leaf_data_enum = "leaf_data_enum";
-x3::rule<leaf_data_class<yang::LeafDataTypes::IdentityRef>, identityRef_> const leaf_data_identityRef = "leaf_data_identityRef";
-x3::rule<struct leaf_data_class<yang::LeafDataTypes::Binary>, binary_> const leaf_data_binary = "leaf_data_binary";
-x3::rule<struct leaf_data_class<yang::LeafDataTypes::Decimal>, double> const leaf_data_decimal = "leaf_data_decimal";
-x3::rule<struct leaf_data_class<yang::LeafDataTypes::String>, std::string> const leaf_data_string = "leaf_data_string";
+x3::rule<struct leaf_data_class<yang::Enum>, enum_> const leaf_data_enum = "leaf_data_enum";
+x3::rule<struct leaf_data_class<yang::IdentityRef>, identityRef_> const leaf_data_identityRef = "leaf_data_identityRef";
+x3::rule<struct leaf_data_class<yang::Binary>, binary_> const leaf_data_binary = "leaf_data_binary";
+x3::rule<struct leaf_data_class<yang::Decimal>, double> const leaf_data_decimal = "leaf_data_decimal";
+x3::rule<struct leaf_data_class<yang::String>, std::string> const leaf_data_string = "leaf_data_string";
 x3::rule<struct leaf_data_class_binary, std::string> const leaf_data_binary_data = "leaf_data_binary_data";
 x3::rule<struct leaf_data_identityRef_data_class, identityRef_> const leaf_data_identityRef_data = "leaf_data_identityRef_data";
 
-x3::rule<createSetSuggestions_class<yang::LeafDataTypes::Enum>, x3::unused_type> const createEnumSuggestions = "createEnumSuggestions";
-x3::rule<createSetSuggestions_class<yang::LeafDataTypes::IdentityRef>, x3::unused_type> const createIdentitySuggestions = "createIdentitySuggestions";
-
 using x3::char_;
 
-auto const createEnumSuggestions_def =
-    x3::eps;
-
 auto const leaf_data_enum_def =
-    createEnumSuggestions >> +char_;
+    +char_;
 
 struct bool_symbol_table : x3::symbols<bool> {
     bool_symbol_table()
     {
-    add
-        ("true", true)
-        ("false", false);
+        add
+            ("true", true)
+            ("false", false);
     }
 } const bool_symbols;
 
@@ -124,11 +56,124 @@
 auto const leaf_data_identityRef_data_def =
     -module  >> node_identifier;
 
-auto const createIdentitySuggestions_def =
-    x3::eps;
-
+// TODO: get rid of this and use leaf_data_identityRef_data directly
 auto const leaf_data_identityRef_def =
-    createIdentitySuggestions >> leaf_data_identityRef_data;
+    leaf_data_identityRef_data;
+
+template <typename It, typename Ctx, typename RCtx, typename Attr>
+struct impl_LeafData {
+    It& first;
+    It last;
+    Ctx const& ctx;
+    RCtx& rctx;
+    Attr& attr;
+    ParserContext& parserContext;
+
+    bool operator()(const yang::Binary&) const
+    {
+        return leaf_data_binary.parse(first, last, ctx, rctx, attr);
+    }
+    bool operator()(const yang::Bool&) const
+    {
+        return bool_symbols.parse(first, last, ctx, rctx, attr);
+    }
+    bool operator()(const yang::Decimal&) const
+    {
+        return x3::double_.parse(first, last, ctx, rctx, attr);
+    }
+    bool operator()(const yang::Uint8&) const
+    {
+        return x3::uint8.parse(first, last, ctx, rctx, attr);
+    }
+    bool operator()(const yang::Uint16&) const
+    {
+        return x3::uint16.parse(first, last, ctx, rctx, attr);
+    }
+    bool operator()(const yang::Uint32&) const
+    {
+        return x3::uint32.parse(first, last, ctx, rctx, attr);
+    }
+    bool operator()(const yang::Uint64&) const
+    {
+        return x3::uint64.parse(first, last, ctx, rctx, attr);
+    }
+    bool operator()(const yang::Int8&) const
+    {
+        return x3::int8.parse(first, last, ctx, rctx, attr);
+    }
+    bool operator()(const yang::Int16&) const
+    {
+        return x3::int16.parse(first, last, ctx, rctx, attr);
+    }
+    bool operator()(const yang::Int32&) const
+    {
+        return x3::int32.parse(first, last, ctx, rctx, attr);
+    }
+    bool operator()(const yang::Int64&) const
+    {
+        return x3::int64.parse(first, last, ctx, rctx, attr);
+    }
+    bool operator()(const yang::String&) const
+    {
+        return leaf_data_string.parse(first, last, ctx, rctx, attr);
+    }
+    template <typename Type>
+    void createSetSuggestions(const Type& type) const
+    {
+        parserContext.m_suggestions.clear();
+        std::transform(type.m_allowedValues.begin(),
+                type.m_allowedValues.end(),
+                std::inserter(parserContext.m_suggestions, parserContext.m_suggestions.end()),
+                [](auto it) { return Completion{it.m_value}; });
+        parserContext.m_completionIterator = first;
+    }
+    bool operator()(const yang::Enum& type) const
+    {
+        createSetSuggestions(type);
+        // leaf_data_enum will advance the iterator if it succeeds, so I have
+        // to save the iterator here, to roll it back in case the enum is
+        // invalid.
+        auto saveIter = first;
+        auto pass = leaf_data_enum.parse(first, last, ctx, rctx, attr);
+        if (!pass) {
+            return false;
+        }
+        auto isValidEnum = type.m_allowedValues.count(boost::get<enum_>(attr)) != 0;
+        if (!isValidEnum) {
+            first = saveIter;
+            parserContext.m_errorMsg = "leaf data type mismatch: Expected an enum here. Allowed values:";
+            for (const auto& it : type.m_allowedValues) {
+                parserContext.m_errorMsg += " " + it.m_value;
+            }
+        }
+        return isValidEnum;
+    }
+    bool operator()(const yang::IdentityRef& type) const
+    {
+        createSetSuggestions(type);
+        // leaf_data_identityRef will advance the iterator if it succeeds, so I have
+        // to save the iterator here, to roll it back in case the enum is
+        // invalid.
+        auto saveIter = first;
+        auto pass = leaf_data_identityRef.parse(first, last, ctx, rctx, attr);
+        if (!pass) {
+            return false;
+        }
+        identityRef_ pair{boost::get<identityRef_>(attr)};
+        if (!pair.m_prefix) {
+            pair.m_prefix = module_{parserContext.currentSchemaPath().m_nodes.front().m_prefix.get().m_name};
+        }
+        auto isValidIdentity  = type.m_allowedValues.count(pair) != 0;
+        if (!isValidIdentity) {
+            first = saveIter;
+        }
+        return isValidIdentity;
+    }
+    bool operator()(const yang::LeafRef& leafRef) const
+    {
+        return std::visit(*this, *leafRef.m_targetType);
+    }
+};
 
 struct LeafData : x3::parser<LeafData> {
     using attribute_type = leaf_data_;
@@ -141,43 +186,7 @@
         const Schema& schema = parserContext.m_schema;
         auto type = schema.leafType(parserContext.m_tmpListKeyLeafPath.m_location, parserContext.m_tmpListKeyLeafPath.m_node);
 
-        std::function<bool(yang::LeafDataTypes)> parse_impl = [&](auto type) {
-            switch (type) {
-            case yang::LeafDataTypes::Binary:
-                return leaf_data_binary.parse(first, last, ctx, rctx, attr);
-            case yang::LeafDataTypes::Bool:
-                return bool_symbols.parse(first, last, ctx, rctx, attr);
-            case yang::LeafDataTypes::Decimal:
-                return x3::double_.parse(first, last, ctx, rctx, attr);
-            case yang::LeafDataTypes::Uint8:
-                return x3::uint8.parse(first, last, ctx, rctx, attr);
-            case yang::LeafDataTypes::Uint16:
-                return x3::uint16.parse(first, last, ctx, rctx, attr);
-            case yang::LeafDataTypes::Uint32:
-                return x3::uint32.parse(first, last, ctx, rctx, attr);
-            case yang::LeafDataTypes::Uint64:
-                return x3::uint64.parse(first, last, ctx, rctx, attr);
-            case yang::LeafDataTypes::Int8:
-                return x3::int8.parse(first, last, ctx, rctx, attr);
-            case yang::LeafDataTypes::Int16:
-                return x3::int16.parse(first, last, ctx, rctx, attr);
-            case yang::LeafDataTypes::Int32:
-                return x3::int32.parse(first, last, ctx, rctx, attr);
-            case yang::LeafDataTypes::Int64:
-                return x3::int64.parse(first, last, ctx, rctx, attr);
-            case yang::LeafDataTypes::String:
-                return leaf_data_string.parse(first, last, ctx, rctx, attr);
-            case yang::LeafDataTypes::Enum:
-                return leaf_data_enum.parse(first, last, ctx, rctx, attr);
-            case yang::LeafDataTypes::IdentityRef:
-                return leaf_data_identityRef.parse(first, last, ctx, rctx, attr);
-            case yang::LeafDataTypes::LeafRef:
-                auto actualType = schema.leafrefBaseType(parserContext.m_tmpListKeyLeafPath.m_location, parserContext.m_tmpListKeyLeafPath.m_node);
-                return parse_impl(actualType);
-            }
-            __builtin_unreachable();
-        };
-        auto pass = parse_impl(type);
+        auto pass = std::visit(impl_LeafData<It, Ctx, RCtx, Attr>{first, last, ctx, rctx, attr, parserContext}, type);
 
         if (!pass) {
             if (parserContext.m_errorMsg.empty()) {
@@ -197,5 +206,3 @@
 BOOST_SPIRIT_DEFINE(leaf_data_binary)
 BOOST_SPIRIT_DEFINE(leaf_data_identityRef_data)
 BOOST_SPIRIT_DEFINE(leaf_data_identityRef)
-BOOST_SPIRIT_DEFINE(createEnumSuggestions)
-BOOST_SPIRIT_DEFINE(createIdentitySuggestions)
diff --git a/src/leaf_data_type.cpp b/src/leaf_data_type.cpp
new file mode 100644
index 0000000..815d0aa
--- /dev/null
+++ b/src/leaf_data_type.cpp
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2020 CESNET, https://photonics.cesnet.cz/
+ *
+ * Written by Václav Kubernát <kubernat@cesnet.cz>
+ *
+*/
+#include "ast_values.hpp"
+#include "leaf_data_type.hpp"
+
+namespace yang {
+Enum::Enum(std::set<enum_>&& values)
+    : m_allowedValues(std::move(values))
+{
+}
+bool Enum::operator==(const Enum& other) const
+{
+    return this->m_allowedValues == other.m_allowedValues;
+}
+IdentityRef::IdentityRef(std::set<identityRef_>&& values)
+    : m_allowedValues(std::move(values))
+{
+}
+bool IdentityRef::operator==(const IdentityRef& other) const
+{
+    return this->m_allowedValues == other.m_allowedValues;
+}
+// Copy constructor needed, because unique_ptr is not copy-constructible
+LeafRef::LeafRef(const LeafRef& src)
+    : m_targetXPath(src.m_targetXPath)
+    , m_targetType(std::make_unique<LeafDataType>(*src.m_targetType))
+{
+}
+LeafRef::LeafRef(const std::string& xpath, std::unique_ptr<LeafDataType>&& type)
+    : m_targetXPath(xpath)
+    , m_targetType(std::move(type))
+{
+}
+bool LeafRef::operator==(const LeafRef& other) const
+{
+    return this->m_targetXPath == other.m_targetXPath && *this->m_targetType == *other.m_targetType;
+}
+bool String::operator==(const String&) const
+{
+    return true;
+}
+bool Decimal::operator==(const Decimal&) const
+{
+    return true;
+}
+bool Bool::operator==(const Bool&) const
+{
+    return true;
+}
+bool Int8::operator==(const Int8&) const
+{
+    return true;
+}
+bool Uint8::operator==(const Uint8&) const
+{
+    return true;
+}
+bool Int16::operator==(const Int16&) const
+{
+    return true;
+}
+bool Uint16::operator==(const Uint16&) const
+{
+    return true;
+}
+bool Int32::operator==(const Int32&) const
+{
+    return true;
+}
+bool Uint32::operator==(const Uint32&) const
+{
+    return true;
+}
+bool Int64::operator==(const Int64&) const
+{
+    return true;
+}
+bool Uint64::operator==(const Uint64&) const
+{
+    return true;
+}
+bool Binary::operator==(const Binary&) const
+{
+    return true;
+}
+}
diff --git a/src/leaf_data_type.hpp b/src/leaf_data_type.hpp
new file mode 100644
index 0000000..66f4522
--- /dev/null
+++ b/src/leaf_data_type.hpp
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2020 CESNET, https://photonics.cesnet.cz/
+ *
+ * Written by Václav Kubernát <kubernat@cesnet.cz>
+ *
+*/
+
+#pragma once
+#include <memory>
+#include <set>
+#include <string>
+#include <variant>
+
+struct enum_;
+struct identityRef_;
+
+namespace yang {
+struct String {
+    bool operator==(const String&) const;
+};
+struct Decimal {
+    bool operator==(const Decimal&) const;
+};
+struct Bool {
+    bool operator==(const Bool&) const;
+};
+struct Int8 {
+    bool operator==(const Int8&) const;
+};
+struct Uint8 {
+    bool operator==(const Uint8&) const;
+};
+struct Int16 {
+    bool operator==(const Int16&) const;
+};
+struct Uint16 {
+    bool operator==(const Uint16&) const;
+};
+struct Int32 {
+    bool operator==(const Int32&) const;
+};
+struct Uint32 {
+    bool operator==(const Uint32&) const;
+};
+struct Int64 {
+    bool operator==(const Int64&) const;
+};
+struct Uint64 {
+    bool operator==(const Uint64&) const;
+};
+struct Binary {
+    bool operator==(const Binary&) const;
+};
+struct Enum {
+    Enum(std::set<enum_>&& values);
+    bool operator==(const Enum& other) const;
+    std::set<enum_> m_allowedValues;
+};
+struct IdentityRef {
+    IdentityRef(std::set<identityRef_>&& list);
+    bool operator==(const IdentityRef& other) const;
+    std::set<identityRef_> m_allowedValues;
+};
+struct LeafRef;
+using LeafDataType = std::variant<
+    yang::String,
+    yang::Decimal,
+    yang::Bool,
+    yang::Int8,
+    yang::Uint8,
+    yang::Int16,
+    yang::Uint16,
+    yang::Int32,
+    yang::Uint32,
+    yang::Int64,
+    yang::Uint64,
+    yang::Enum,
+    yang::Binary,
+    yang::IdentityRef,
+    yang::LeafRef
+>;
+struct LeafRef {
+    LeafRef(const LeafRef& src);
+    LeafRef(const std::string& xpath, std::unique_ptr<LeafDataType>&& type);
+    bool operator==(const LeafRef& other) const;
+    std::string m_targetXPath;
+    std::unique_ptr<LeafDataType> m_targetType;
+};
+}
diff --git a/src/parser_context.hpp b/src/parser_context.hpp
index 3ad0179..f837934 100644
--- a/src/parser_context.hpp
+++ b/src/parser_context.hpp
@@ -31,6 +31,7 @@
         schemaPath_ m_location;
         ModuleNodePair m_node;
     } m_tmpListKeyLeafPath;
+
     std::map<std::string, leaf_data_> m_tmpListKeys;
     bool m_errorHandled = false;
     bool m_completing = false;
diff --git a/src/schema.hpp b/src/schema.hpp
index ea0deba..9a86045 100644
--- a/src/schema.hpp
+++ b/src/schema.hpp
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (C) 2018 CESNET, https://photonics.cesnet.cz/
  * Copyright (C) 2018 FIT CVUT, https://fit.cvut.cz/
@@ -14,28 +13,11 @@
 #include <stdexcept>
 #include <unordered_map>
 #include "ast_path.hpp"
+#include "leaf_data_type.hpp"
 
 using ModuleValuePair = std::pair<boost::optional<std::string>, std::string>;
 
 namespace yang {
-enum class LeafDataTypes {
-    String,
-    Decimal,
-    Bool,
-    Int8,
-    Uint8,
-    Int16,
-    Uint16,
-    Int32,
-    Uint32,
-    Int64,
-    Uint64,
-    Enum,
-    Binary,
-    IdentityRef,
-    LeafRef,
-};
-
 enum class NodeTypes {
     Container,
     PresenceContainer,
@@ -70,22 +52,16 @@
     virtual yang::NodeTypes nodeType(const std::string& path) const = 0;
     virtual yang::NodeTypes nodeType(const schemaPath_& location, const ModuleNodePair& node) const = 0;
     virtual bool isModule(const std::string& name) const = 0;
-    virtual bool leafEnumHasValue(const schemaPath_& location, const ModuleNodePair& node, const std::string& value) const = 0;
-    virtual bool leafIdentityIsValid(const schemaPath_& location, const ModuleNodePair& node, const ModuleValuePair& value) const = 0;
     virtual bool listHasKey(const schemaPath_& location, const ModuleNodePair& node, const std::string& key) const = 0;
     virtual bool leafIsKey(const std::string& leafPath) const = 0;
     virtual const std::set<std::string> listKeys(const schemaPath_& location, const ModuleNodePair& node) const = 0;
-    virtual yang::LeafDataTypes leafType(const schemaPath_& location, const ModuleNodePair& node) const = 0;
-    virtual yang::LeafDataTypes leafType(const std::string& path) const = 0;
+    virtual yang::LeafDataType leafType(const schemaPath_& location, const ModuleNodePair& node) const = 0;
+    virtual yang::LeafDataType leafType(const std::string& path) const = 0;
     virtual std::optional<std::string> leafTypeName(const std::string& path) const = 0;
-    virtual yang::LeafDataTypes leafrefBaseType(const schemaPath_& location, const ModuleNodePair& node) const = 0;
-    virtual yang::LeafDataTypes leafrefBaseType(const std::string& path) const = 0;
     virtual std::string leafrefPath(const std::string& leafrefPath) const = 0;
     virtual std::optional<std::string> description(const std::string& location) const = 0;
     virtual std::optional<std::string> units(const std::string& location) const = 0;
 
-    virtual const std::set<std::string> validIdentities(const schemaPath_& location, const ModuleNodePair& node, const Prefixes prefixes) const = 0;
-    virtual const std::set<std::string> enumValues(const schemaPath_& location, const ModuleNodePair& node) const = 0;
     virtual std::set<std::string> childNodes(const schemaPath_& path, const Recursion recursion) const = 0;
     virtual std::set<std::string> moduleNodes(const module_& module, const Recursion recursion) const = 0;
 };
diff --git a/src/static_schema.cpp b/src/static_schema.cpp
index 87d190a..4964e8e 100644
--- a/src/static_schema.cpp
+++ b/src/static_schema.cpp
@@ -71,40 +71,22 @@
     m_nodes.emplace(key, std::unordered_map<std::string, NodeType>());
 }
 
-void StaticSchema::addLeaf(const std::string& location, const std::string& name, const yang::LeafDataTypes& type)
+std::set<identityRef_> StaticSchema::validIdentities(std::string_view module, std::string_view value)
 {
-    m_nodes.at(location).emplace(name, yang::leaf{type, {}, {}, {}});
-    std::string key = joinPaths(location, name);
-    m_nodes.emplace(key, std::unordered_map<std::string, NodeType>());
+    std::set<ModuleValuePair> identities;
+    getIdentSet(ModuleNodePair{boost::optional<std::string>{module}, value}, identities);
+    std::set<identityRef_> res;
+
+    std::transform(identities.begin(), identities.end(), std::inserter(res, res.end()), [](const auto& identity) {
+        return identityRef_{*identity.first, identity.second};
+    });
+
+    return res;
 }
 
-void StaticSchema::addLeafEnum(const std::string& location, const std::string& name, std::set<std::string> enumValues)
+void StaticSchema::addLeaf(const std::string& location, const std::string& name, const yang::LeafDataType& type)
 {
-    yang::leaf toAdd;
-    toAdd.m_type = yang::LeafDataTypes::Enum;
-    toAdd.m_enumValues = enumValues;
-    m_nodes.at(location).emplace(name, toAdd);
-    std::string key = joinPaths(location, name);
-    m_nodes.emplace(key, std::unordered_map<std::string, NodeType>());
-}
-
-void StaticSchema::addLeafIdentityRef(const std::string& location, const std::string& name, const ModuleValuePair& base)
-{
-    assert(base.first); // base identity cannot have an empty module
-    yang::leaf toAdd;
-    toAdd.m_type = yang::LeafDataTypes::IdentityRef;
-    toAdd.m_identBase = base;
-    m_nodes.at(location).emplace(name, toAdd);
-    std::string key = joinPaths(location, name);
-    m_nodes.emplace(key, std::unordered_map<std::string, NodeType>());
-}
-
-void StaticSchema::addLeafRef(const std::string& location, const std::string& name, const std::string& source)
-{
-    yang::leaf toAdd;
-    toAdd.m_type = yang::LeafDataTypes::LeafRef;
-    toAdd.m_leafRefSource = source;
-    m_nodes.at(location).emplace(name, toAdd);
+    m_nodes.at(location).emplace(name, yang::leaf{type});
     std::string key = joinPaths(location, name);
     m_nodes.emplace(key, std::unordered_map<std::string, NodeType>());
 }
@@ -122,12 +104,6 @@
     m_identities.emplace(name, std::set<ModuleValuePair>());
 }
 
-bool StaticSchema::leafEnumHasValue(const schemaPath_& location, const ModuleNodePair& node, const std::string& value) const
-{
-    auto enums = enumValues(location, node);
-    return enums.find(value) != enums.end();
-}
-
 void StaticSchema::getIdentSet(const ModuleValuePair& ident, std::set<ModuleValuePair>& res) const
 {
     res.insert(ident);
@@ -137,41 +113,6 @@
     }
 }
 
-const std::set<std::string> StaticSchema::validIdentities(const schemaPath_& location, const ModuleNodePair& node, const Prefixes prefixes) const
-{
-    std::string locationString = pathToSchemaString(location, Prefixes::Always);
-    assert(isLeaf(location, node));
-
-    const auto& child = children(locationString).at(fullNodeName(location, node));
-    const auto& leaf = boost::get<yang::leaf>(child);
-
-    std::set<ModuleValuePair> identSet;
-    getIdentSet(leaf.m_identBase, identSet);
-
-    std::set<std::string> res;
-    std::transform(identSet.begin(), identSet.end(), std::inserter(res, res.end()), [location, node, prefixes](const auto& it) {
-        auto topLevelModule = location.m_nodes.empty() ? node.first.get() : location.m_nodes.front().m_prefix.get().m_name;
-        std::string stringIdent;
-        if (prefixes == Prefixes::Always || (it.first && it.first.value() != topLevelModule)) {
-            stringIdent += it.first ? it.first.value() : topLevelModule;
-            stringIdent += ":";
-        }
-        stringIdent += it.second;
-        return stringIdent;
-    });
-
-    return res;
-}
-
-bool StaticSchema::leafIdentityIsValid(const schemaPath_& location, const ModuleNodePair& node, const ModuleValuePair& value) const
-{
-    auto identities = validIdentities(location, node, Prefixes::Always);
-
-    auto topLevelModule = location.m_nodes.empty() ? node.first.get() : location.m_nodes.front().m_prefix.get().m_name;
-    auto identModule = value.first ? value.first.value() : topLevelModule;
-    return std::any_of(identities.begin(), identities.end(), [toFind = identModule + ":" + value.second](const auto& x) { return x == toFind; });
-}
-
 std::string lastNodeOfSchemaPath(const std::string& path)
 {
     std::string res = path;
@@ -189,34 +130,17 @@
     return res;
 }
 
-yang::LeafDataTypes StaticSchema::leafrefBaseType(const schemaPath_& location, const ModuleNodePair& node) const
-{
-    std::string locationString = pathToSchemaString(location, Prefixes::Always);
-    auto leaf{boost::get<yang::leaf>(children(locationString).at(fullNodeName(location, node)))};
-    auto locationOfSource = stripLastNodeFromPath(leaf.m_leafRefSource);
-    auto nameOfSource = lastNodeOfSchemaPath(leaf.m_leafRefSource);
-    return boost::get<yang::leaf>(children(locationOfSource).at(nameOfSource)).m_type;
-}
-
-yang::LeafDataTypes StaticSchema::leafType(const schemaPath_& location, const ModuleNodePair& node) const
+yang::LeafDataType StaticSchema::leafType(const schemaPath_& location, const ModuleNodePair& node) const
 {
     std::string locationString = pathToSchemaString(location, Prefixes::Always);
     return boost::get<yang::leaf>(children(locationString).at(fullNodeName(location, node))).m_type;
 }
 
-yang::LeafDataTypes StaticSchema::leafType([[maybe_unused]] const std::string& path) const
+yang::LeafDataType StaticSchema::leafType(const std::string& path) const
 {
-    throw std::runtime_error{"StaticSchema::leafType not implemented"};
-}
-
-const std::set<std::string> StaticSchema::enumValues(const schemaPath_& location, const ModuleNodePair& node) const
-{
-    std::string locationString = pathToSchemaString(location, Prefixes::Always);
-    assert(isLeaf(location, node));
-
-    const auto& child = children(locationString).at(fullNodeName(location, node));
-    const auto& leaf = boost::get<yang::leaf>(child);
-    return leaf.m_enumValues;
+    auto locationString = stripLastNodeFromPath(path);
+    auto node = lastNodeOfSchemaPath(path);
+    return boost::get<yang::leaf>(children(locationString).at(node)).m_type;
 }
 
 // We do not test StaticSchema, so we don't need to implement recursive childNodes
@@ -291,11 +215,6 @@
     throw std::runtime_error{"Internal error: StaticSchema::nodeType(std::string) not implemented. The tests should not have called this overload."};
 }
 
-yang::LeafDataTypes StaticSchema::leafrefBaseType([[maybe_unused]] const std::string& path) const
-{
-    throw std::runtime_error{"Internal error: StaticSchema::leafrefBaseType(std::string) not implemented. The tests should not have called this overload."};
-}
-
 std::string StaticSchema::leafrefPath([[maybe_unused]] const std::string& leafrefPath) const
 {
     throw std::runtime_error{"Internal error: StaticSchema::leafrefPath(std::string) not implemented. The tests should not have called this overload."};
diff --git a/src/static_schema.hpp b/src/static_schema.hpp
index 97f1e7e..a94c78d 100644
--- a/src/static_schema.hpp
+++ b/src/static_schema.hpp
@@ -27,10 +27,7 @@
 };
 
 struct leaf {
-    yang::LeafDataTypes m_type;
-    std::set<std::string> m_enumValues;
-    ModuleValuePair m_identBase;
-    std::string m_leafRefSource;
+    yang::LeafDataType m_type;
 };
 
 struct module {
@@ -51,29 +48,24 @@
     yang::NodeTypes nodeType(const std::string& path) const override;
     yang::NodeTypes nodeType(const schemaPath_& location, const ModuleNodePair& node) const override;
     bool isModule(const std::string& name) const override;
-    bool leafEnumHasValue(const schemaPath_& location, const ModuleNodePair& node, const std::string& value) const override;
-    bool leafIdentityIsValid(const schemaPath_& location, const ModuleNodePair& node, const ModuleValuePair& value) const override;
     bool listHasKey(const schemaPath_& location, const ModuleNodePair& node, const std::string& key) const override;
     bool leafIsKey(const std::string& leafPath) const override;
     const std::set<std::string> listKeys(const schemaPath_& location, const ModuleNodePair& node) const override;
-    yang::LeafDataTypes leafType(const schemaPath_& location, const ModuleNodePair& node) const override;
-    yang::LeafDataTypes leafType(const std::string& path) const override;
+    yang::LeafDataType leafType(const schemaPath_& location, const ModuleNodePair& node) const override;
+    yang::LeafDataType leafType(const std::string& path) const override;
     std::optional<std::string> leafTypeName(const std::string& path) const override;
-    yang::LeafDataTypes leafrefBaseType(const schemaPath_& location, const ModuleNodePair& node) const override;
-    yang::LeafDataTypes leafrefBaseType(const std::string& path) const override;
     std::string leafrefPath(const std::string& leafrefPath) const override;
-    const std::set<std::string> enumValues(const schemaPath_& location, const ModuleNodePair& node) const override;
-    const std::set<std::string> validIdentities(const schemaPath_& location, const ModuleNodePair& node, const Prefixes prefixes) const override;
     std::set<std::string> childNodes(const schemaPath_& path, const Recursion) const override;
     std::set<std::string> moduleNodes(const module_& module, const Recursion recursion) const override;
     std::optional<std::string> description(const std::string& path) const override;
     std::optional<std::string> units(const std::string& path) const override;
 
+    /** A helper for making tests a little bit easier. It returns all
+     * identities which are based on the argument passed and which can then be
+     * used in addLeaf for the `type` argument */
+    std::set<identityRef_> validIdentities(std::string_view module, std::string_view value);
     void addContainer(const std::string& location, const std::string& name, yang::ContainerTraits isPresence = yang::ContainerTraits::None);
-    void addLeaf(const std::string& location, const std::string& name, const yang::LeafDataTypes& type);
-    void addLeafEnum(const std::string& location, const std::string& name, std::set<std::string> enumValues);
-    void addLeafIdentityRef(const std::string& location, const std::string& name, const ModuleValuePair& base);
-    void addLeafRef(const std::string& location, const std::string& name, const std::string& source);
+    void addLeaf(const std::string& location, const std::string& name, const yang::LeafDataType& type);
     void addList(const std::string& location, const std::string& name, const std::set<std::string>& keys);
     void addModule(const std::string& name);
     void addIdentity(const std::optional<ModuleValuePair>& base, const ModuleValuePair& name);
@@ -85,5 +77,7 @@
 
     std::unordered_map<std::string, std::unordered_map<std::string, NodeType>> m_nodes;
     std::set<std::string> m_modules;
+
+    // FIXME: Change the template arguments to identityRef_
     std::map<ModuleValuePair, std::set<ModuleValuePair>> m_identities;
 };
diff --git a/src/utils.cpp b/src/utils.cpp
index fcbe0d0..719f28b 100644
--- a/src/utils.cpp
+++ b/src/utils.cpp
@@ -52,42 +52,72 @@
     return schemaPath_{path.m_scope, decltype(schemaPath_::m_nodes)(path.m_nodes.begin(), path.m_nodes.end() - 1)};
 }
 
-std::string leafDataTypeToString(yang::LeafDataTypes type)
-{
-    switch (type) {
-    case yang::LeafDataTypes::String:
+struct impl_leafDataTypeToString {
+    std::string operator()(const yang::String)
+    {
         return "a string";
-    case yang::LeafDataTypes::Decimal:
-        return "a decimal";
-    case yang::LeafDataTypes::Bool:
-        return "a boolean";
-    case yang::LeafDataTypes::Int8:
-        return "an 8-bit integer";
-    case yang::LeafDataTypes::Uint8:
-        return "an 8-bit unsigned integer";
-    case yang::LeafDataTypes::Int16:
-        return "a 16-bit integer";
-    case yang::LeafDataTypes::Uint16:
-        return "a 16-bit unsigned integer";
-    case yang::LeafDataTypes::Int32:
-        return "a 32-bit integer";
-    case yang::LeafDataTypes::Uint32:
-        return "a 32-bit unsigned integer";
-    case yang::LeafDataTypes::Int64:
-        return "a 64-bit integer";
-    case yang::LeafDataTypes::Uint64:
-        return "a 64-bit unsigned integer";
-    case yang::LeafDataTypes::Enum:
-        return "an enum";
-    case yang::LeafDataTypes::IdentityRef:
-        return "an identity";
-    case yang::LeafDataTypes::LeafRef:
-        return "a leafref";
-    case yang::LeafDataTypes::Binary:
-        return "a base64-encoded binary value";
-    default:
-        throw std::runtime_error("leafDataTypeToString: unsupported leaf data type");
     }
+    std::string operator()(const yang::Decimal)
+    {
+        return "a decimal";
+    }
+    std::string operator()(const yang::Bool)
+    {
+        return "a boolean";
+    }
+    std::string operator()(const yang::Int8)
+    {
+        return "an 8-bit integer";
+    }
+    std::string operator()(const yang::Uint8)
+    {
+        return "an 8-bit unsigned integer";
+    }
+    std::string operator()(const yang::Int16)
+    {
+        return "a 16-bit integer";
+    }
+    std::string operator()(const yang::Uint16)
+    {
+        return "a 16-bit unsigned integer";
+    }
+    std::string operator()(const yang::Int32)
+    {
+        return "a 32-bit integer";
+    }
+    std::string operator()(const yang::Uint32)
+    {
+        return "a 32-bit unsigned integer";
+    }
+    std::string operator()(const yang::Int64)
+    {
+        return "a 64-bit integer";
+    }
+    std::string operator()(const yang::Uint64)
+    {
+        return "a 64-bit unsigned integer";
+    }
+    std::string operator()(const yang::Binary)
+    {
+        return "a base64-encoded binary value";
+    }
+    std::string operator()(const yang::Enum&)
+    {
+        return "an enum";
+    }
+    std::string operator()(const yang::IdentityRef&)
+    {
+        return "an identity";
+    }
+    std::string operator()(const yang::LeafRef&)
+    {
+        return "a leafref";
+    }
+};
+
+std::string leafDataTypeToString(const yang::LeafDataType& type)
+{
+    return std::visit(impl_leafDataTypeToString{}, type);
 }
 
 std::string fullNodeName(const schemaPath_& location, const ModuleNodePair& pair)
diff --git a/src/utils.hpp b/src/utils.hpp
index f0f7ae5..2f93bfb 100644
--- a/src/utils.hpp
+++ b/src/utils.hpp
@@ -17,7 +17,7 @@
 std::string stripLastNodeFromPath(const std::string& path);
 schemaPath_ pathWithoutLastNode(const schemaPath_& path);
 dataPath_ pathWithoutLastNode(const dataPath_& path);
-std::string leafDataTypeToString(yang::LeafDataTypes type);
+std::string leafDataTypeToString(const yang::LeafDataType& type);
 std::string fullNodeName(const schemaPath_& location, const ModuleNodePair& pair);
 std::string fullNodeName(const dataPath_& location, const ModuleNodePair& pair);
 std::string leafDataToString(const leaf_data_ value);
diff --git a/src/yang_schema.cpp b/src/yang_schema.cpp
index e18c780..0f1a3fd 100644
--- a/src/yang_schema.cpp
+++ b/src/yang_schema.cpp
@@ -93,80 +93,6 @@
     return set.find(name) != set.end();
 }
 
-bool YangSchema::leafEnumHasValue(const schemaPath_& location, const ModuleNodePair& node, const std::string& value) const
-{
-    auto enums = enumValues(location, node);
-
-    return std::any_of(enums.begin(), enums.end(), [=](const auto& x) { return x == value; });
-}
-
-const std::set<std::string> YangSchema::enumValues(const schemaPath_& location, const ModuleNodePair& node) const
-{
-    if (!isLeaf(location, node) || leafType(location, node) != yang::LeafDataTypes::Enum)
-        return {};
-
-    libyang::Schema_Node_Leaf leaf(getSchemaNode(location, node));
-    auto type = leaf.type();
-    auto enm = type->info()->enums()->enm();
-    // The enum can be a derived type and enm() only returns values,
-    // if that specific typedef changed the possible values. So we go
-    // up the hierarchy until we find a typedef that defined these values.
-    while (enm.empty()) {
-        type = type->der()->type();
-        enm = type->info()->enums()->enm();
-    }
-
-    std::vector<libyang::S_Type_Enum> enabled;
-    std::copy_if(enm.begin(), enm.end(), std::back_inserter(enabled), [](const libyang::S_Type_Enum& it) {
-        auto iffeatures = it->iffeature();
-        return std::all_of(iffeatures.begin(), iffeatures.end(), [](auto it) { return it->value(); });
-    });
-
-    std::set<std::string> enumSet;
-    std::transform(enabled.begin(), enabled.end(), std::inserter(enumSet, enumSet.end()), [](auto it) { return it->name(); });
-    return enumSet;
-}
-
-const std::set<std::string> YangSchema::validIdentities(const schemaPath_& location, const ModuleNodePair& node, const Prefixes prefixes) const
-{
-    if (!isLeaf(location, node) || leafType(location, node) != yang::LeafDataTypes::IdentityRef)
-        return {};
-
-    std::set<std::string> identSet;
-
-    auto topLevelModule = location.m_nodes.empty() ? node.first.get() : location.m_nodes.front().m_prefix.get().m_name;
-    auto insertToSet = [&identSet, prefixes, topLevelModule](auto module, auto name) {
-        std::string stringIdent;
-        if (prefixes == Prefixes::Always || topLevelModule != module) {
-            stringIdent += module;
-            stringIdent += ":";
-        }
-        stringIdent += name;
-        identSet.emplace(stringIdent);
-    };
-
-    auto leaf = std::make_shared<libyang::Schema_Node_Leaf>(getSchemaNode(location, node));
-    auto info = leaf->type()->info();
-    for (auto base : info->ident()->ref()) { // Iterate over all bases
-        insertToSet(base->module()->name(), base->name());
-        // Iterate over derived identities (this is recursive!)
-        for (auto derived : base->der()->schema()) {
-            insertToSet(derived->module()->name(), derived->name());
-        }
-    }
-
-    return identSet;
-}
-
-bool YangSchema::leafIdentityIsValid(const schemaPath_& location, const ModuleNodePair& node, const ModuleValuePair& value) const
-{
-    auto identities = validIdentities(location, node, Prefixes::Always);
-
-    auto topLevelModule = location.m_nodes.empty() ? node.first.get() : location.m_nodes.front().m_prefix.get().m_name;
-    auto identModule = value.first ? value.first.value() : topLevelModule;
-    return std::any_of(identities.begin(), identities.end(), [toFind = identModule + ":" + value.second](const auto& x) { return x == toFind; });
-}
-
 bool YangSchema::listHasKey(const schemaPath_& location, const ModuleNodePair& node, const std::string& key) const
 {
     if (!isList(location, node))
@@ -227,65 +153,102 @@
     return keys;
 }
 
-yang::LeafDataTypes lyTypeToLeafDataTypes(LY_DATA_TYPE type)
+namespace {
+std::set<enum_> enumValues(const libyang::S_Schema_Node_Leaf& leaf)
 {
-    switch (type) {
-    case LY_TYPE_STRING:
-        return yang::LeafDataTypes::String;
-    case LY_TYPE_DEC64:
-        return yang::LeafDataTypes::Decimal;
-    case LY_TYPE_BOOL:
-        return yang::LeafDataTypes::Bool;
-    case LY_TYPE_INT8:
-        return yang::LeafDataTypes::Int8;
-    case LY_TYPE_INT16:
-        return yang::LeafDataTypes::Int16;
-    case LY_TYPE_INT32:
-        return yang::LeafDataTypes::Int32;
-    case LY_TYPE_INT64:
-        return yang::LeafDataTypes::Int64;
-    case LY_TYPE_UINT8:
-        return yang::LeafDataTypes::Uint8;
-    case LY_TYPE_UINT16:
-        return yang::LeafDataTypes::Uint16;
-    case LY_TYPE_UINT32:
-        return yang::LeafDataTypes::Uint32;
-    case LY_TYPE_UINT64:
-        return yang::LeafDataTypes::Uint64;
-    case LY_TYPE_ENUM:
-        return yang::LeafDataTypes::Enum;
-    case LY_TYPE_BINARY:
-        return yang::LeafDataTypes::Binary;
-    case LY_TYPE_IDENT:
-        return yang::LeafDataTypes::IdentityRef;
-    case LY_TYPE_LEAFREF:
-        return yang::LeafDataTypes::LeafRef;
-    default:
-        using namespace std::string_literals;
-        throw std::logic_error{"internal error: unsupported libyang data type "s + std::to_string(type)};
+    auto type = leaf->type();
+    auto enm = type->info()->enums()->enm();
+    // The enum can be a derived type and enm() only returns values,
+    // if that specific typedef changed the possible values. So we go
+    // up the hierarchy until we find a typedef that defined these values.
+    while (enm.empty()) {
+        type = type->der()->type();
+        enm = type->info()->enums()->enm();
     }
+
+    std::vector<libyang::S_Type_Enum> enabled;
+    std::copy_if(enm.begin(), enm.end(), std::back_inserter(enabled), [](const libyang::S_Type_Enum& it) {
+        auto iffeatures = it->iffeature();
+        return std::all_of(iffeatures.begin(), iffeatures.end(), [](auto it) { return it->value(); });
+    });
+
+    std::set<enum_> enumSet;
+    std::transform(enabled.begin(), enabled.end(), std::inserter(enumSet, enumSet.end()), [](auto it) { return enum_{it->name()}; });
+    return enumSet;
 }
 
-namespace {
-yang::LeafDataTypes impl_leafType(const libyang::S_Schema_Node& node)
+std::set<identityRef_> validIdentities(const libyang::S_Schema_Node_Leaf& leaf)
+{
+    std::set<identityRef_> identSet;
+
+    // auto topLevelModule = leaf->module();
+
+    auto info = leaf->type()->info();
+    for (auto base : info->ident()->ref()) { // Iterate over all bases
+        identSet.emplace(base->module()->name(), base->name());
+        // Iterate over derived identities (this is recursive!)
+        for (auto derived : base->der()->schema()) {
+            identSet.emplace(derived->module()->name(), derived->name());
+        }
+    }
+
+    return identSet;
+}
+
+std::string leafrefPath(const libyang::S_Schema_Node_Leaf& leaf)
+{
+    return leaf->type()->info()->lref()->target()->path(LYS_PATH_FIRST_PREFIX);
+}
+}
+
+yang::LeafDataType YangSchema::impl_leafType(const libyang::S_Schema_Node& node) const
 {
     using namespace std::string_literals;
-    libyang::Schema_Node_Leaf leaf(node);
-    auto baseType{leaf.type()->base()};
-    try {
-        return lyTypeToLeafDataTypes(baseType);
-    } catch (std::logic_error& ex) {
-        throw UnsupportedYangTypeException("the type of "s + node->name() + " is not supported: " + ex.what());
+    auto leaf = std::make_shared<libyang::Schema_Node_Leaf>(node);
+    auto baseType{leaf->type()->base()};
+    switch (baseType) {
+    case LY_TYPE_STRING:
+        return yang::String{};
+    case LY_TYPE_DEC64:
+        return yang::Decimal{};
+    case LY_TYPE_BOOL:
+        return yang::Bool{};
+    case LY_TYPE_INT8:
+        return yang::Int8{};
+    case LY_TYPE_INT16:
+        return yang::Int16{};
+    case LY_TYPE_INT32:
+        return yang::Int32{};
+    case LY_TYPE_INT64:
+        return yang::Int64{};
+    case LY_TYPE_UINT8:
+        return yang::Uint8{};
+    case LY_TYPE_UINT16:
+        return yang::Uint16{};
+    case LY_TYPE_UINT32:
+        return yang::Uint32{};
+    case LY_TYPE_UINT64:
+        return yang::Uint64{};
+    case LY_TYPE_BINARY:
+        return yang::Binary{};
+    case LY_TYPE_ENUM:
+        return yang::Enum{enumValues(leaf)};
+    case LY_TYPE_IDENT:
+        return yang::IdentityRef{validIdentities(leaf)};
+    case LY_TYPE_LEAFREF:
+        return yang::LeafRef{::leafrefPath(leaf), std::make_unique<yang::LeafDataType>(leafType(::leafrefPath(leaf)))};
+    default:
+        using namespace std::string_literals;
+        throw UnsupportedYangTypeException("the type of "s + node->name() + " is not supported: " + std::to_string(baseType));
     }
 }
-}
 
-yang::LeafDataTypes YangSchema::leafType(const schemaPath_& location, const ModuleNodePair& node) const
+yang::LeafDataType YangSchema::leafType(const schemaPath_& location, const ModuleNodePair& node) const
 {
     return impl_leafType(getSchemaNode(location, node));
 }
 
-yang::LeafDataTypes YangSchema::leafType(const std::string& path) const
+yang::LeafDataType YangSchema::leafType(const std::string& path) const
 {
     return impl_leafType(getSchemaNode(path));
 }
@@ -296,29 +259,6 @@
     return leaf.type()->der().get() ? std::optional{leaf.type()->der()->name()} : std::nullopt;
 }
 
-namespace {
-yang::LeafDataTypes impl_leafrefBaseType(const libyang::S_Schema_Node& node)
-{
-    using namespace std::string_literals;
-    libyang::Schema_Node_Leaf leaf(node);
-    try {
-        return lyTypeToLeafDataTypes(leaf.type()->info()->lref()->target()->type()->base());
-    } catch (std::logic_error& ex) {
-        throw UnsupportedYangTypeException("the type of "s + node->name() + " is not supported: " + ex.what());
-    }
-}
-}
-
-yang::LeafDataTypes YangSchema::leafrefBaseType(const schemaPath_& location, const ModuleNodePair& node) const
-{
-    return impl_leafrefBaseType(getSchemaNode(location, node));
-}
-
-yang::LeafDataTypes YangSchema::leafrefBaseType(const std::string& path) const
-{
-    return impl_leafrefBaseType(getSchemaNode(path));
-}
-
 std::string YangSchema::leafrefPath(const std::string& leafrefPath) const
 {
     using namespace std::string_literals;
diff --git a/src/yang_schema.hpp b/src/yang_schema.hpp
index c763ea6..e3a9025 100644
--- a/src/yang_schema.hpp
+++ b/src/yang_schema.hpp
@@ -17,6 +17,7 @@
 namespace libyang {
 class Context;
 class Schema_Node;
+class Schema_Node_Leaf;
 class Data_Node;
 class Module;
 }
@@ -33,19 +34,13 @@
     yang::NodeTypes nodeType(const std::string& path) const override;
     yang::NodeTypes nodeType(const schemaPath_& location, const ModuleNodePair& node) const override;
     bool isModule(const std::string& name) const override;
-    bool leafEnumHasValue(const schemaPath_& location, const ModuleNodePair& node, const std::string& value) const override;
-    bool leafIdentityIsValid(const schemaPath_& location, const ModuleNodePair& node, const ModuleValuePair& value) const override;
     bool listHasKey(const schemaPath_& location, const ModuleNodePair& node, const std::string& key) const override;
     bool leafIsKey(const std::string& leafPath) const override;
     const std::set<std::string> listKeys(const schemaPath_& location, const ModuleNodePair& node) const override;
-    yang::LeafDataTypes leafType(const schemaPath_& location, const ModuleNodePair& node) const override;
-    yang::LeafDataTypes leafType(const std::string& path) const override;
+    yang::LeafDataType leafType(const schemaPath_& location, const ModuleNodePair& node) const override;
+    yang::LeafDataType leafType(const std::string& path) const override;
     std::optional<std::string> leafTypeName(const std::string& path) const override;
-    yang::LeafDataTypes leafrefBaseType(const schemaPath_& location, const ModuleNodePair& node) const override;
-    yang::LeafDataTypes leafrefBaseType(const std::string& path) const override;
     std::string leafrefPath(const std::string& leafrefPath) const override;
-    const std::set<std::string> validIdentities(const schemaPath_& location, const ModuleNodePair& node, const Prefixes prefixes) const override;
-    const std::set<std::string> enumValues(const schemaPath_& location, const ModuleNodePair& node) const override;
     std::set<std::string> childNodes(const schemaPath_& path, const Recursion recursion) const override;
     std::set<std::string> moduleNodes(const module_& module, const Recursion recursion) const override;
     std::optional<std::string> description(const std::string& path) const override;
@@ -73,6 +68,7 @@
     std::shared_ptr<libyang::Module> getYangModule(const std::string& name);
 
 private:
+    yang::LeafDataType impl_leafType(const std::shared_ptr<libyang::Schema_Node>& node) const;
     std::set<std::string> modules() const;
 
     /** @short Returns a set of nodes, that match the location and name criteria. */