diff --git a/src/Entity.jl b/src/Entity.jl
index 22cf0813e290134f95fa6452fd86b01859667b4c..ee18834d9d4a9273e53cddfd4eb8b2cb56cd9a4d 100644
--- a/src/Entity.jl
+++ b/src/Entity.jl
@@ -490,7 +490,30 @@ function create_atomic_datatype(name::AbstractString)
         Cint,
         (Ref{_DataType}, Cstring),
         datatype,
-        name
+        name,
+    )
+
+    CaosDB.Exceptions.evaluate_return_code(err_code)
+
+    return datatype
+end
+
+"""
+    function create_reference_datatype(name::AbstractString)
+
+Create and return a DataType object with a reference datatype specified by
+`name`.
+"""
+function create_reference_datatype(name::AbstractString)
+
+    datatype = Ref{_DataType}(_DataType(true))
+
+    err_code = ccall(
+        (:caosdb_entity_create_reference_datatype, CaosDB.library_name),
+        Cint,
+        (Ref{_DataType}, Cstring),
+        datatype,
+        name,
     )
 
     CaosDB.Exceptions.evaluate_return_code(err_code)
@@ -498,11 +521,137 @@ function create_atomic_datatype(name::AbstractString)
     return datatype
 end
 
-function create_reference_datatype(name::AbstractString) end
+"""
+    function create_atomic_list_datatype(name::AbstractString)
+
+Create and return a DataType object which is a list of atomics specified by
+`name`.
+"""
+function create_atomic_list_datatype(name::AbstractString)
+
+    datatype = Ref{_DataType}(_DataType(true))
 
-function create_list_of_atomic_datatype(name::AbstractString) end
+    err_code = ccall(
+        (:caosdb_entity_create_atomic_list_datatype, CaosDB.library_name),
+        Cint,
+        (Ref{_DataType}, Cstring),
+        datatype,
+        name,
+    )
+
+    CaosDB.Exceptions.evaluate_return_code(err_code)
+
+    return datatype
+end
+
+"""
+    function create_list_of_reference_datatype(name::AbstractString)
+
+Create and return a DataType object which is a list of references specified by
+`name`.
+"""
+function create_list_of_reference_datatype(name::AbstractString)
+
+    datatype = Ref{_DataType}(_DataType(true))
+
+    err_code = ccall(
+        (:caosdb_entity_create_reference_list_datatype, CaosDB.library_name),
+        Cint,
+        (Ref{_DataType}, Cstring),
+        datatype,
+        name,
+    )
 
-function create_list_of_reference_datatype(name::AbstractString) end
+    CaosDB.Exceptions.evaluate_return_code(err_code)
+
+    return datatype
+end
+
+function create_value(
+    value::Union{AbstractString,Number,Bool,Vactor{T}},
+) where {T<:Union{AbstractString,Number,Bool}}
+
+    in_type = typeof(value)
+    out = Ref{_Value}(_Value(true))
+    if in_type <: AbstractString
+        err_code = ccall(
+            (:caosdb_entity_create_string_value, CaosDB.library_name),
+            Cint,
+            (Ref{_Value}, Cstring),
+            out,
+            value,
+        )
+    elseif in_type <: Bool
+        err_code = ccall(
+            (:caosdb_entity_create_bool_value, CaosDB.library_name),
+            Cint,
+            (Ref{_Value}, Bool),
+            out,
+            value,
+        )
+    elseif in_type <: Integer
+        err_code = ccall(
+            (:caosdb_entity_create_bool_value, CaosDB.library_name),
+            Cint,
+            (Ref{_Value}, Clong),
+            out,
+            Clong(value),
+        )
+    elseif in_type <: Number
+        err_code = ccall(
+            (:caosdb_entity_create_bool_value, CaosDB.library_name),
+            Cint,
+            (Ref{_Value}, Cdouble),
+            out,
+            Cdouble(value),
+        )
+    elseif in_type <: Vector{T} where {T<:AbstractString}
+        err_code = ccall(
+            (:caosdb_entity_create_string_vector_value, CaosDB.library_name),
+            Cint,
+            (Ref{_Value}, Ptr{Ptr{Cchar}}, Cint),
+            out,
+            value,
+            Cint(length(value)),
+        )
+    elseif in_type <: Vector{T} where {T<:Bool}
+        err_code = ccall(
+            (:caosdb_entity_create_bool_vector_value, CaosDB.library_name),
+            Cint,
+            (Ref{_Value}, Ptr{Bool}, Cint),
+            out,
+            value,
+            Cint(length(value)),
+        )
+    elseif in_type <: Vector{T} where {T<:Integer}
+        err_code = ccall(
+            (:caosdb_entity_create_int_vector_value, CaosDB.library_name),
+            Cint,
+            (Ref{_Value}, Ptr{Clong}, Cint),
+            out,
+            Vector{Clong}(value),
+            Cint(length(value)),
+        )
+    elseif in_type <: Vector{T} where {T<:Number}
+        err_code = ccall(
+            (:caosdb_entity_create_double_vector_value, CaosDB.library_name),
+            Cint,
+            (Ref{_Value}, Ptr{Cdouble}, Cint),
+            out,
+            Vector{Cdouble}(value),
+            Cint(length(value)),
+        )
+    else
+        # Should never enter here but treat it just in case
+        @throw ArgumentError(
+            "The argument of type $in_type couldn't be converted into a valid CaosDB value object.",
+        )
+    end
+
+    CaosDB.Exceptions.evaluate_return_code(err_code)
+
+    return out
+end
 
 """
     function get_id(entity::Ref{_Entity})