diff --git a/src/Assert/AnyURITrait.php b/src/Assert/AnyURITrait.php
new file mode 100644
index 0000000..c358c89
--- /dev/null
+++ b/src/Assert/AnyURITrait.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Assert;
+
+use InvalidArgumentException;
+
+/**
+ * @package simplesamlphp/xml-common
+ */
+trait AnyURITrait
+{
+    /***********************************************************************************
+     *  NOTE:  Custom assertions may be added below this line.                         *
+     *         They SHOULD be marked as `protected` to ensure the call is forced       *
+     *          through __callStatic().                                                *
+     *         Assertions marked `public` are called directly and will                 *
+     *          not handle any custom exception passed to it.                          *
+     ***********************************************************************************/
+
+
+    /**
+     * @param string $value
+     * @param string $message
+     */
+    protected static function validURI(string $value, string $message = ''): void
+    {
+        parent::validURI(
+            $value,
+            $message ?: '\'%s\' is not a valid anyURI',
+            InvalidArgumentException::class,
+        );
+    }
+}
diff --git a/src/Assert/Assert.php b/src/Assert/Assert.php
index fcaf71f..ceacfb0 100644
--- a/src/Assert/Assert.php
+++ b/src/Assert/Assert.php
@@ -9,33 +9,64 @@
 /**
  * @package simplesamlphp/xml-common
  *
+ * @method static void validDateTime(mixed $value, string $message = '', string $exception = '')
+ * @method static void validDuration(mixed $value, string $message = '', string $exception = '')
+ * @method static void validEntity(mixed $value, string $message = '', string $exception = '')
+ * @method static void validEntities(mixed $value, string $message = '', string $exception = '')
  * @method static void validHexBinary(mixed $value, string $message = '', string $exception = '')
+ * @method static void validID(mixed $value, string $message = '', string $exception = '')
+ * @method static void validIDRef(mixed $value, string $message = '', string $exception = '')
+ * @method static void validIDRefs(mixed $value, string $message = '', string $exception = '')
+ * @method static void validLang(mixed $value, string $message = '', string $exception = '')
+ * @method static void validName(mixed $value, string $message = '', string $exception = '')
+ * @method static void validNCName(mixed $value, string $message = '', string $exception = '')
  * @method static void validNMToken(mixed $value, string $message = '', string $exception = '')
  * @method static void validNMTokens(mixed $value, string $message = '', string $exception = '')
- * @method static void validDuration(mixed $value, string $message = '', string $exception = '')
- * @method static void validDateTime(mixed $value, string $message = '', string $exception = '')
- * @method static void validNCName(mixed $value, string $message = '', string $exception = '')
  * @method static void validQName(mixed $value, string $message = '', string $exception = '')
+ * @method static void nullOrValidDateTime(mixed $value, string $message = '', string $exception = '')
+ * @method static void nullOrValidDuration(mixed $value, string $message = '', string $exception = '')
+ * @method static void nullOrValidEntity(mixed $value, string $message = '', string $exception = '')
+ * @method static void nullOrValidEntities(mixed $value, string $message = '', string $exception = '')
  * @method static void nullOrValidHexBinary(mixed $value, string $message = '', string $exception = '')
+ * @method static void nullOrValidID(mixed $value, string $message = '', string $exception = '')
+ * @method static void nullOrValidIDRef(mixed $value, string $message = '', string $exception = '')
+ * @method static void nullOrValidIDRefs(mixed $value, string $message = '', string $exception = '')
+ * @method static void nullOrValidLang(mixed $value, string $message = '', string $exception = '')
+ * @method static void nullOrValidName(mixed $value, string $message = '', string $exception = '')
+ * @method static void nullOrValidNCName(mixed $value, string $message = '', string $exception = '')
  * @method static void nullOrValidNMToken(mixed $value, string $message = '', string $exception = '')
  * @method static void nullOrValidNMTokens(mixed $value, string $message = '', string $exception = '')
- * @method static void nullOrValidDuration(mixed $value, string $message = '', string $exception = '')
- * @method static void nullOrValidDateTime(mixed $value, string $message = '', string $exception = '')
- * @method static void nullOrValidNCName(mixed $value, string $message = '', string $exception = '')
  * @method static void nullOrValidQName(mixed $value, string $message = '', string $exception = '')
+ * @method static void allValidDateTime(mixed $value, string $message = '', string $exception = '')
+ * @method static void allValidDuration(mixed $value, string $message = '', string $exception = '')
+ * @method static void allValidEntity(mixed $value, string $message = '', string $exception = '')
+ * @method static void allValidEntities(mixed $value, string $message = '', string $exception = '')
  * @method static void allValidHexBinary(mixed $value, string $message = '', string $exception = '')
+ * @method static void allValidID(mixed $value, string $message = '', string $exception = '')
+ * @method static void allValidIDRef(mixed $value, string $message = '', string $exception = '')
+ * @method static void allValidIDRefs(mixed $value, string $message = '', string $exception = '')
+ * @method static void allValidLang(mixed $value, string $message = '', string $exception = '')
+ * @method static void allValidName(mixed $value, string $message = '', string $exception = '')
+ * @method static void allValidNCName(mixed $value, string $message = '', string $exception = '')
  * @method static void allValidNMToken(mixed $value, string $message = '', string $exception = '')
  * @method static void allValidNMTokens(mixed $value, string $message = '', string $exception = '')
- * @method static void allValidDuration(mixed $value, string $message = '', string $exception = '')
- * @method static void allValidDateTime(mixed $value, string $message = '', string $exception = '')
- * @method static void allValidNCName(mixed $value, string $message = '', string $exception = '')
  * @method static void allValidQName(mixed $value, string $message = '', string $exception = '')
  */
 class Assert extends BaseAssert
 {
+    use AnyURITrait;
     use DateTimeTrait;
     use DurationTrait;
-    use HexBinTrait;
-    use NamesTrait;
-    use TokensTrait;
+    use HexBinaryTrait;
+    use EntitiesTrait;
+    use EntityTrait;
+    use IDTrait;
+    use IDRefTrait;
+    use IDRefsTrait;
+    use LangTrait;
+    use NameTrait;
+    use NCNameTrait;
+    use NMTokenTrait;
+    use NMTokensTrait;
+    use QNameTrait;
 }
diff --git a/src/Assert/EntitiesTrait.php b/src/Assert/EntitiesTrait.php
new file mode 100644
index 0000000..76568bb
--- /dev/null
+++ b/src/Assert/EntitiesTrait.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Assert;
+
+use InvalidArgumentException;
+
+use function filter_var;
+use function sprintf;
+
+/**
+ * @package simplesamlphp/xml-common
+ */
+trait EntitiesTrait
+{
+    /** @var string */
+    private static string $entities_regex = '/^([\p{L}a-zA-Z-][\w.-]*)([\s][\p{L}a-zA-Z-][\w.-]*)*$/Du';
+
+    /***********************************************************************************
+     *  NOTE:  Custom assertions may be added below this line.                         *
+     *         They SHOULD be marked as `protected` to ensure the call is forced       *
+     *          through __callStatic().                                                *
+     *         Assertions marked `public` are called directly and will                 *
+     *          not handle any custom exception passed to it.                          *
+     ***********************************************************************************/
+
+
+    /**
+     * @param string $value
+     * @param string $message
+     */
+    protected static function validEntities(string $value, string $message = ''): void
+    {
+        if (filter_var($value, FILTER_VALIDATE_REGEXP, ['options' => ['regexp' => self::$entities_regex]]) === false) {
+            throw new InvalidArgumentException(sprintf(
+                $message ?: '\'%s\' is not a valid xs:ENTITIES',
+                $value,
+            ));
+        }
+    }
+}
diff --git a/src/Assert/EntityTrait.php b/src/Assert/EntityTrait.php
new file mode 100644
index 0000000..3c5b5eb
--- /dev/null
+++ b/src/Assert/EntityTrait.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Assert;
+
+use InvalidArgumentException;
+
+/**
+ * @package simplesamlphp/xml-common
+ */
+trait EntityTrait
+{
+    /***********************************************************************************
+     *  NOTE:  Custom assertions may be added below this line.                         *
+     *         They SHOULD be marked as `protected` to ensure the call is forced       *
+     *          through __callStatic().                                                *
+     *         Assertions marked `public` are called directly and will                 *
+     *          not handle any custom exception passed to it.                          *
+     ***********************************************************************************/
+
+
+    /**
+     * @param string $value
+     * @param string $message
+     */
+    protected static function validEntity(string $value, string $message = ''): void
+    {
+        Assert::validNCName(
+            $value,
+            $message ?: '\'%s\' is not a valid xs:Entity',
+            InvalidArgumentException::class,
+        );
+    }
+}
diff --git a/src/Assert/HexBinTrait.php b/src/Assert/HexBinaryTrait.php
similarity index 98%
rename from src/Assert/HexBinTrait.php
rename to src/Assert/HexBinaryTrait.php
index 68ca51a..2e36488 100644
--- a/src/Assert/HexBinTrait.php
+++ b/src/Assert/HexBinaryTrait.php
@@ -12,7 +12,7 @@
 /**
  * @package simplesamlphp/xml-common
  */
-trait HexBinTrait
+trait HexBinaryTrait
 {
     /** @var string */
     private static string $hexbin_regex = '/^([0-9a-fA-F]{2})+$/D';
diff --git a/src/Assert/IDRefTrait.php b/src/Assert/IDRefTrait.php
new file mode 100644
index 0000000..efbb963
--- /dev/null
+++ b/src/Assert/IDRefTrait.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Assert;
+
+use InvalidArgumentException;
+
+/**
+ * @package simplesamlphp/xml-common
+ */
+trait IDRefTrait
+{
+    /***********************************************************************************
+     *  NOTE:  Custom assertions may be added below this line.                         *
+     *         They SHOULD be marked as `protected` to ensure the call is forced       *
+     *          through __callStatic().                                                *
+     *         Assertions marked `public` are called directly and will                 *
+     *          not handle any custom exception passed to it.                          *
+     ***********************************************************************************/
+
+
+    /**
+     * @param string $value
+     * @param string $message
+     */
+    protected static function validIDRef(string $value, string $message = ''): void
+    {
+        Assert::validNCName(
+            $value,
+            $message ?: '\'%s\' is not a xs:IDREF',
+            InvalidArgumentException::class,
+        );
+    }
+}
diff --git a/src/Assert/IDRefsTrait.php b/src/Assert/IDRefsTrait.php
new file mode 100644
index 0000000..dcf6638
--- /dev/null
+++ b/src/Assert/IDRefsTrait.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Assert;
+
+use InvalidArgumentException;
+
+use function filter_var;
+use function sprintf;
+
+/**
+ * @package simplesamlphp/xml-common
+ */
+trait IDRefsTrait
+{
+    /** @var string */
+    private static string $idrefs_regex = '/^([\p{L}a-zA-Z-][\w.-]*)([\s][\p{L}a-zA-Z-][\w.-]*)*$/Du';
+
+    /***********************************************************************************
+     *  NOTE:  Custom assertions may be added below this line.                         *
+     *         They SHOULD be marked as `protected` to ensure the call is forced       *
+     *          through __callStatic().                                                *
+     *         Assertions marked `public` are called directly and will                 *
+     *          not handle any custom exception passed to it.                          *
+     ***********************************************************************************/
+
+
+    /**
+     * @param string $value
+     * @param string $message
+     */
+    protected static function validIDRefs(string $value, string $message = ''): void
+    {
+        if (filter_var($value, FILTER_VALIDATE_REGEXP, ['options' => ['regexp' => self::$idrefs_regex]]) === false) {
+            throw new InvalidArgumentException(sprintf(
+                $message ?: '\'%s\' is not a valid xs:IDREFS',
+                $value,
+            ));
+        }
+    }
+}
diff --git a/src/Assert/IDTrait.php b/src/Assert/IDTrait.php
new file mode 100644
index 0000000..2c98c6a
--- /dev/null
+++ b/src/Assert/IDTrait.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Assert;
+
+use InvalidArgumentException;
+
+/**
+ * @package simplesamlphp/xml-common
+ */
+trait IDTrait
+{
+    /***********************************************************************************
+     *  NOTE:  Custom assertions may be added below this line.                         *
+     *         They SHOULD be marked as `protected` to ensure the call is forced       *
+     *          through __callStatic().                                                *
+     *         Assertions marked `public` are called directly and will                 *
+     *          not handle any custom exception passed to it.                          *
+     ***********************************************************************************/
+
+
+    /**
+     * @param string $value
+     * @param string $message
+     */
+    protected static function validID(string $value, string $message = ''): void
+    {
+        Assert::validNCName(
+            $value,
+            $message ?: '\'%s\' is not a valid xs:ID',
+            InvalidArgumentException::class,
+        );
+    }
+}
diff --git a/src/Assert/LangTrait.php b/src/Assert/LangTrait.php
new file mode 100644
index 0000000..c98ffdd
--- /dev/null
+++ b/src/Assert/LangTrait.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Assert;
+
+use InvalidArgumentException;
+
+use function filter_var;
+use function sprintf;
+
+/**
+ * @package simplesamlphp/xml-common
+ */
+trait LangTrait
+{
+    /** @var string */
+    private static string $lang_regex = '/^(i[-]|x[-])?([a-z]{1,8})([-][a-z]{1,8})?$/Di';
+
+    /***********************************************************************************
+     *  NOTE:  Custom assertions may be added below this line.                         *
+     *         They SHOULD be marked as `protected` to ensure the call is forced       *
+     *          through __callStatic().                                                *
+     *         Assertions marked `public` are called directly and will                 *
+     *          not handle any custom exception passed to it.                          *
+     ***********************************************************************************/
+
+
+    /**
+     * @param string $value
+     * @param string $message
+     */
+    protected static function validLang(string $value, string $message = ''): void
+    {
+        if (filter_var($value, FILTER_VALIDATE_REGEXP, ['options' => ['regexp' => self::$lang_regex]]) === false) {
+            throw new InvalidArgumentException(sprintf(
+                $message ?: '\'%s\' is not a valid xs:language',
+                $value,
+            ));
+        }
+    }
+}
diff --git a/src/Assert/NamesTrait.php b/src/Assert/NCNameTrait.php
similarity index 62%
rename from src/Assert/NamesTrait.php
rename to src/Assert/NCNameTrait.php
index 3254913..474edee 100644
--- a/src/Assert/NamesTrait.php
+++ b/src/Assert/NCNameTrait.php
@@ -12,13 +12,10 @@
 /**
  * @package simplesamlphp/xml-common
  */
-trait NamesTrait
+trait NCNameTrait
 {
     /** @var string */
-    private static string $ncname_regex = '/^[a-zA-Z_][\w.-]*$/D';
-
-    /** @var string */
-    private static string $qname_regex = '/^[a-zA-Z_][\w.-]*:[a-zA-Z_][\w.-]*$/D';
+    private static string $ncname_regex = '/^[\p{L}a-zA-Z-][\w.-]+$/Du';
 
     /***********************************************************************************
      *  NOTE:  Custom assertions may be added below this line.                         *
@@ -42,22 +39,4 @@ protected static function validNCName(string $value, string $message = ''): void
             ));
         }
     }
-
-
-    /**
-     * @param string $value
-     * @param string $message
-     */
-    protected static function validQName(string $value, string $message = ''): void
-    {
-        if (
-            filter_var($value, FILTER_VALIDATE_REGEXP, ['options' => ['regexp' => self::$qname_regex]]) === false &&
-            filter_var($value, FILTER_VALIDATE_REGEXP, ['options' => ['regexp' => self::$ncname_regex]]) === false
-        ) {
-            throw new InvalidArgumentException(sprintf(
-                $message ?: '\'%s\' is not a valid qualified name (QName)',
-                $value,
-            ));
-        }
-    }
 }
diff --git a/src/Assert/NMTokenTrait.php b/src/Assert/NMTokenTrait.php
new file mode 100644
index 0000000..a0c2e9d
--- /dev/null
+++ b/src/Assert/NMTokenTrait.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Assert;
+
+use InvalidArgumentException;
+
+use function filter_var;
+use function sprintf;
+
+/**
+ * @package simplesamlphp/xml-common
+ */
+trait NMTokenTrait
+{
+    /** @var string */
+    private static string $nmtoken_regex = '/^[\w.:-]+$/Du';
+
+    /***********************************************************************************
+     *  NOTE:  Custom assertions may be added below this line.                         *
+     *         They SHOULD be marked as `protected` to ensure the call is forced       *
+     *          through __callStatic().                                                *
+     *         Assertions marked `public` are called directly and will                 *
+     *          not handle any custom exception passed to it.                          *
+     ***********************************************************************************/
+
+
+    /**
+     * @param string $value
+     * @param string $message
+     */
+    protected static function validNMToken(string $value, string $message = ''): void
+    {
+        if (filter_var($value, FILTER_VALIDATE_REGEXP, ['options' => ['regexp' => self::$nmtoken_regex]]) === false) {
+            throw new InvalidArgumentException(sprintf(
+                $message ?: '\'%s\' is not a valid xs:NMTOKEN',
+                $value,
+            ));
+        }
+    }
+}
diff --git a/src/Assert/TokensTrait.php b/src/Assert/NMTokensTrait.php
similarity index 71%
rename from src/Assert/TokensTrait.php
rename to src/Assert/NMTokensTrait.php
index 9ea6b1e..b1cc459 100644
--- a/src/Assert/TokensTrait.php
+++ b/src/Assert/NMTokensTrait.php
@@ -12,11 +12,8 @@
 /**
  * @package simplesamlphp/xml-common
  */
-trait TokensTrait
+trait NMTokensTrait
 {
-    /** @var string */
-    private static string $nmtoken_regex = '/^[\w.:-]+$/Du';
-
     /** @var string */
     private static string $nmtokens_regex = '/^([\w.:-]+)([\s][\w.:-]+)*$/Du';
 
@@ -29,21 +26,6 @@ trait TokensTrait
      ***********************************************************************************/
 
 
-    /**
-     * @param string $value
-     * @param string $message
-     */
-    protected static function validNMToken(string $value, string $message = ''): void
-    {
-        if (filter_var($value, FILTER_VALIDATE_REGEXP, ['options' => ['regexp' => self::$nmtoken_regex]]) === false) {
-            throw new InvalidArgumentException(sprintf(
-                $message ?: '\'%s\' is not a valid xs:NMTOKEN',
-                $value,
-            ));
-        }
-    }
-
-
     /**
      * @param string $value
      * @param string $message
diff --git a/src/Assert/NameTrait.php b/src/Assert/NameTrait.php
new file mode 100644
index 0000000..1a7d997
--- /dev/null
+++ b/src/Assert/NameTrait.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Assert;
+
+use InvalidArgumentException;
+
+use function filter_var;
+use function sprintf;
+
+/**
+ * @package simplesamlphp/xml-common
+ */
+trait NameTrait
+{
+    /** @var string */
+    private static string $name_regex = '/^[a-zA-Z:-][\w.:-]+$/Du';
+
+    /***********************************************************************************
+     *  NOTE:  Custom assertions may be added below this line.                         *
+     *         They SHOULD be marked as `protected` to ensure the call is forced       *
+     *          through __callStatic().                                                *
+     *         Assertions marked `public` are called directly and will                 *
+     *          not handle any custom exception passed to it.                          *
+     ***********************************************************************************/
+
+
+    /**
+     * @param string $value
+     * @param string $message
+     */
+    protected static function validName(string $value, string $message = ''): void
+    {
+        if (filter_var($value, FILTER_VALIDATE_REGEXP, ['options' => ['regexp' => self::$name_regex]]) === false) {
+            throw new InvalidArgumentException(sprintf(
+                $message ?: '\'%s\' is not a valid xs:Name',
+                $value,
+            ));
+        }
+    }
+}
diff --git a/src/Assert/QNameTrait.php b/src/Assert/QNameTrait.php
new file mode 100644
index 0000000..58a47df
--- /dev/null
+++ b/src/Assert/QNameTrait.php
@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Assert;
+
+use InvalidArgumentException;
+
+use function filter_var;
+
+/**
+ * @package simplesamlphp/xml-common
+ */
+trait QNameTrait
+{
+    /** @var string */
+    private static string $qname_regex = '/^([\p{L}a-zA-Z-][\w.-]*)(:[\p{L}a-zA-Z-][\w.-]*)$/Du';
+
+    /***********************************************************************************
+     *  NOTE:  Custom assertions may be added below this line.                         *
+     *         They SHOULD be marked as `protected` to ensure the call is forced       *
+     *          through __callStatic().                                                *
+     *         Assertions marked `public` are called directly and will                 *
+     *          not handle any custom exception passed to it.                          *
+     ***********************************************************************************/
+
+
+    /**
+     * @param string $value
+     * @param string $message
+     */
+    protected static function validQName(string $value, string $message = ''): void
+    {
+        if (
+            filter_var($value, FILTER_VALIDATE_REGEXP, ['options' => ['regexp' => self::$qname_regex]]) === false
+        ) {
+            Assert::validNCName(
+                $value,
+                $message ?: '\'%s\' is not a valid qualified name (QName)',
+                InvalidArgumentException::class,
+            );
+        }
+    }
+}
diff --git a/src/Type/AbstractValueType.php b/src/Type/AbstractValueType.php
new file mode 100644
index 0000000..3ced6c3
--- /dev/null
+++ b/src/Type/AbstractValueType.php
@@ -0,0 +1,100 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+/**
+ * Abstract class to be implemented by all types
+ *
+ * @package simplesamlphp/xml-common
+ */
+abstract class AbstractValueType implements ValueTypeInterface
+{
+    /**
+     * Set the value for this type.
+     *
+     * @param string $value
+     */
+    final protected function __construct(
+        protected string $value,
+    ) {
+        $this->validateValue($value);
+    }
+
+
+    /**
+     * Get the value.
+     *
+     * @return string
+     */
+    public function getValue(): string
+    {
+        return $this->sanitizeValue($this->getRawValue());
+    }
+
+
+    /**
+     * Get the raw unsanitized value.
+     *
+     * @return string
+     */
+    public function getRawValue(): string
+    {
+        return $this->value;
+    }
+
+
+    /**
+     * Sanitize the value.
+     *
+     * @param string $value  The value
+     * @throws \Exception on failure
+     * @return string
+     */
+    protected function sanitizeValue(string $value): string
+    {
+        /**
+         * Perform no sanitation by default.
+         * Override this method on the implementing class to perform content sanitation.
+         */
+        return $value;
+    }
+
+
+    /**
+     * Validate the value.
+     *
+     * @param string $value  The value
+     * @throws \Exception on failure
+     * @return void
+     */
+    protected function validateValue(/** @scrutinizer ignore-unused */ string $value): void
+    {
+        /**
+         * Perform no validation by default.
+         * Override this method on the implementing class to perform validation.
+         */
+    }
+
+
+    /**
+     * @param string $value
+     * @return \SimpleSAML\XML\Type\ValueTypeInterface
+     */
+    public static function fromString(string $value): ValueTypeInterface
+    {
+        return new static($value);
+    }
+
+
+    /**
+     * Output the value as a string
+     *
+     * @return string
+     */
+    public function __toString(): string
+    {
+        return $this->getValue();
+    }
+}
diff --git a/src/Type/AnyURIValue.php b/src/Type/AnyURIValue.php
new file mode 100644
index 0000000..8d31657
--- /dev/null
+++ b/src/Type/AnyURIValue.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+use SimpleSAML\XML\Assert\Assert;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class AnyURIValue extends AbstractValueType
+{
+    /**
+     * Validate the value.
+     *
+     * @param string $value
+     * @throws \SimpleSAML\XML\Exception\SchemaViolationException on failure
+     * @return void
+     */
+    protected function validateValue(string $value): void
+    {
+        Assert::validURI($value, SchemaViolationException::class);
+    }
+}
diff --git a/src/Type/Base64Value.php b/src/Type/Base64Value.php
new file mode 100644
index 0000000..d9e7f1a
--- /dev/null
+++ b/src/Type/Base64Value.php
@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+use SimpleSAML\XML\Assert\Assert;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+use function str_replace;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class Base64Value extends AbstractValueType
+{
+    /**
+     * Sanitize the value.
+     *
+     * Note:  There are no processing rules for xs:base64 regarding whitespace. General consensus is to strip them
+     *
+     * @param string $value  The unsanitized value
+     * @return string
+     */
+    protected function sanitizeValue(string $value): string
+    {
+        return str_replace(["\f", "\r", "\n", "\t", "\v", ' '], '', $value);
+    }
+
+
+    /**
+     * Validate the value.
+     *
+     * @param string $value
+     * @throws \SimpleSAML\XML\Exception\SchemaViolationException on failure
+     * @return void
+     */
+    protected function validateValue(string $value): void
+    {
+        // Note: value must already be sanitized before validating
+        Assert::validBase64($this->sanitizeValue($value), SchemaViolationException::class);
+    }
+}
diff --git a/src/Type/DateTimeValue.php b/src/Type/DateTimeValue.php
new file mode 100644
index 0000000..783d442
--- /dev/null
+++ b/src/Type/DateTimeValue.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+use SimpleSAML\XML\Assert\Assert;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class DateTimeValue extends AbstractValueType
+{
+    /**
+     * Validate the value.
+     *
+     * @param string $value
+     * @throws \SimpleSAML\XML\Exception\SchemaViolationException on failure
+     * @return void
+     */
+    protected function validateValue(string $value): void
+    {
+        Assert::validDateTime($value, SchemaViolationException::class);
+    }
+}
diff --git a/src/Type/DurationValue.php b/src/Type/DurationValue.php
new file mode 100644
index 0000000..8b4d388
--- /dev/null
+++ b/src/Type/DurationValue.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+use SimpleSAML\XML\Assert\Assert;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class DurationValue extends AbstractValueType
+{
+    /**
+     * Validate the value.
+     *
+     * @param string $value
+     * @throws \SimpleSAML\XML\Exception\SchemaViolationException on failure
+     * @return void
+     */
+    protected function validateValue(string $value): void
+    {
+        Assert::validDuration($value, SchemaViolationException::class);
+    }
+}
diff --git a/src/Type/EntitiesValue.php b/src/Type/EntitiesValue.php
new file mode 100644
index 0000000..05c0014
--- /dev/null
+++ b/src/Type/EntitiesValue.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+use SimpleSAML\XML\Assert\Assert;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class EntitiesValue extends TokenValue
+{
+    /**
+     * Validate the value.
+     *
+     * @param string $value
+     * @throws \SimpleSAML\XML\Exception\SchemaViolationException on failure
+     * @return void
+     */
+    protected function validateValue(string $value): void
+    {
+        // Note: value must already be sanitized before validating
+        Assert::validEntities($this->sanitizeValue($value), SchemaViolationException::class);
+    }
+}
diff --git a/src/Type/EntityValue.php b/src/Type/EntityValue.php
new file mode 100644
index 0000000..6970a3e
--- /dev/null
+++ b/src/Type/EntityValue.php
@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class EntityValue extends NCNameValue
+{
+}
diff --git a/src/Type/HexBinaryValue.php b/src/Type/HexBinaryValue.php
new file mode 100644
index 0000000..744d7f6
--- /dev/null
+++ b/src/Type/HexBinaryValue.php
@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+use SimpleSAML\XML\Assert\Assert;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+use function str_replace;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class HexBinaryValue extends AbstractValueType
+{
+    /**
+     * Sanitize the value.
+     *
+     * Note:  There are no processing rules for xs:hexBinary regarding whitespace. General consensus is to strip them
+     *
+     * @param string $value  The unsanitized value
+     * @return string
+     */
+    protected function sanitizeValue(string $value): string
+    {
+        return str_replace(["\f", "\r", "\n", "\t", "\v", ' '], '', $value);
+    }
+
+
+    /**
+     * Validate the value.
+     *
+     * @param string $value
+     * @throws \SimpleSAML\XML\Exception\SchemaViolationException on failure
+     * @return void
+     */
+    protected function validateValue(string $value): void
+    {
+        // Note: value must already be sanitized before validating
+        Assert::regex(
+            $this->sanitizeValue($value),
+            '/([0-9A-F]{2})*/i',
+            SchemaViolationException::class,
+        );
+    }
+}
diff --git a/src/Type/IDRefValue.php b/src/Type/IDRefValue.php
new file mode 100644
index 0000000..bc4ebe8
--- /dev/null
+++ b/src/Type/IDRefValue.php
@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class IDRefValue extends NCNameValue
+{
+}
diff --git a/src/Type/IDRefsValue.php b/src/Type/IDRefsValue.php
new file mode 100644
index 0000000..b489181
--- /dev/null
+++ b/src/Type/IDRefsValue.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+use SimpleSAML\XML\Assert\Assert;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class IDRefsValue extends TokenValue
+{
+    /**
+     * Validate the value.
+     *
+     * @param string $value
+     * @throws \SimpleSAML\XML\Exception\SchemaViolationException on failure
+     * @return void
+     */
+    protected function validateValue(string $value): void
+    {
+        // Note: value must already be sanitized before validating
+        Assert::validIDRefs($this->sanitizeValue($value), SchemaViolationException::class);
+    }
+}
diff --git a/src/Type/IDValue.php b/src/Type/IDValue.php
new file mode 100644
index 0000000..1863014
--- /dev/null
+++ b/src/Type/IDValue.php
@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class IDValue extends NCNameValue
+{
+}
diff --git a/src/Type/IntegerValue.php b/src/Type/IntegerValue.php
new file mode 100644
index 0000000..e24ff85
--- /dev/null
+++ b/src/Type/IntegerValue.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+use SimpleSAML\XML\Assert\Assert;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class IntegerValue extends AbstractValueType
+{
+    /**
+     * Validate the value.
+     *
+     * @param string $value
+     * @throws \SimpleSAML\XML\Exception\SchemaViolationException on failure
+     * @return void
+     */
+    protected function validateValue(string $value): void
+    {
+        Assert::numeric($value, SchemaViolationException::class);
+    }
+}
diff --git a/src/Type/LangValue.php b/src/Type/LangValue.php
new file mode 100644
index 0000000..d4046c3
--- /dev/null
+++ b/src/Type/LangValue.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+use SimpleSAML\XML\Assert\Assert;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class LangValue extends TokenValue
+{
+    /**
+     * Validate the value.
+     *
+     * @param string $value
+     * @throws \SimpleSAML\XML\Exception\SchemaViolationException on failure
+     * @return void
+     */
+    protected function validateValue(string $value): void
+    {
+        // Note: content must already be sanitized before validating
+        Assert::validLang($this->sanitizeValue($value), SchemaViolationException::class);
+    }
+}
diff --git a/src/Type/NCNameValue.php b/src/Type/NCNameValue.php
new file mode 100644
index 0000000..8571249
--- /dev/null
+++ b/src/Type/NCNameValue.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+use SimpleSAML\XML\Assert\Assert;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class NCNameValue extends TokenValue
+{
+    /**
+     * Validate the value.
+     *
+     * @param string $value
+     * @throws \SimpleSAML\XML\Exception\SchemaViolationException on failure
+     * @return void
+     */
+    protected function validateValue(string $value): void
+    {
+        // Note: value must already be sanitized before validating
+        Assert::validNCName($this->sanitizeValue($value), SchemaViolationException::class);
+    }
+}
diff --git a/src/Type/NMTokenValue.php b/src/Type/NMTokenValue.php
new file mode 100644
index 0000000..704f66d
--- /dev/null
+++ b/src/Type/NMTokenValue.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+use SimpleSAML\XML\Assert\Assert;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class NMTokenValue extends TokenValue
+{
+    /**
+     * Validate the value.
+     *
+     * @param string $value
+     * @throws \SimpleSAML\XML\Exception\SchemaViolationException on failure
+     * @return void
+     */
+    protected function validateValue(string $value): void
+    {
+        // Note: value must already be sanitized before validating
+        Assert::validNMToken($this->sanitizeValue($value), SchemaViolationException::class);
+    }
+}
diff --git a/src/Type/NMTokensValue.php b/src/Type/NMTokensValue.php
new file mode 100644
index 0000000..71c8394
--- /dev/null
+++ b/src/Type/NMTokensValue.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+use SimpleSAML\XML\Assert\Assert;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class NMTokensValue extends TokenValue
+{
+    /**
+     * Validate the value.
+     *
+     * @param string $value
+     * @throws \SimpleSAML\XML\Exception\SchemaViolationException on failure
+     * @return void
+     */
+    protected function validateValue(string $value): void
+    {
+        // Note: value must already be sanitized before validating
+        Assert::validNMTokens($this->sanitizeValue($value), SchemaViolationException::class);
+    }
+}
diff --git a/src/Type/NameValue.php b/src/Type/NameValue.php
new file mode 100644
index 0000000..6e8a8ae
--- /dev/null
+++ b/src/Type/NameValue.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+use SimpleSAML\XML\Assert\Assert;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class NameValue extends TokenValue
+{
+    /**
+     * Validate the value.
+     *
+     * @param string $value
+     * @throws \SimpleSAML\XML\Exception\SchemaViolationException on failure
+     * @return void
+     */
+    protected function validateValue(string $value): void
+    {
+        // Note: value must already be sanitized before validating
+        Assert::validName($this->sanitizeValue($value), SchemaViolationException::class);
+    }
+}
diff --git a/src/Type/NormalizedStringValue.php b/src/Type/NormalizedStringValue.php
new file mode 100644
index 0000000..1aa1ee8
--- /dev/null
+++ b/src/Type/NormalizedStringValue.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+use function str_replace;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class NormalizedStringValue extends StringValue
+{
+    /**
+     * Sanitize the value.
+     *
+     * @param string $value  The unsanitized value
+     * @return string
+     */
+    protected function sanitizeValue(string $value): string
+    {
+        return str_replace(["\f", "\r", "\n", "\t", "\v"], ' ', $value);
+    }
+}
diff --git a/src/Type/QNameValue.php b/src/Type/QNameValue.php
new file mode 100644
index 0000000..a4434bc
--- /dev/null
+++ b/src/Type/QNameValue.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+use SimpleSAML\XML\Assert\Assert;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class QNameValue extends AbstractValueType
+{
+    /**
+     * Validate the value.
+     *
+     * @param string $value
+     * @throws \SimpleSAML\XML\Exception\SchemaViolationException on failure
+     * @return void
+     */
+    protected function validateValue(string $value): void
+    {
+        // Note: value must already be sanitized before validating
+        Assert::validQName($this->sanitizeValue($value), SchemaViolationException::class);
+    }
+}
diff --git a/src/Type/StringValue.php b/src/Type/StringValue.php
new file mode 100644
index 0000000..b4bf799
--- /dev/null
+++ b/src/Type/StringValue.php
@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class StringValue extends AbstractValueType
+{
+}
diff --git a/src/Type/TokenValue.php b/src/Type/TokenValue.php
new file mode 100644
index 0000000..2c2595d
--- /dev/null
+++ b/src/Type/TokenValue.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+use function preg_replace;
+use function trim;
+
+/**
+ * @package simplesaml/xml-common
+ */
+class TokenValue extends NormalizedStringValue
+{
+    /**
+     * Sanitize the value.
+     *
+     * @param string $value  The unsanitized value
+     * @return string
+     */
+    protected function sanitizeValue(string $value): string
+    {
+        $content = parent::sanitizeValue($value);
+        return trim(preg_replace('/\s+/', ' ', $value));
+    }
+}
diff --git a/src/Type/ValueTypeInterface.php b/src/Type/ValueTypeInterface.php
new file mode 100644
index 0000000..baf981f
--- /dev/null
+++ b/src/Type/ValueTypeInterface.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XML\Type;
+
+/**
+ * interface class to be implemented by all the classes that represent a value type
+ *
+ * @package simplesamlphp/xml-common
+ */
+interface ValueTypeInterface
+{
+    /**
+     * @return string
+     */
+    public function getValue(): string;
+
+
+    /**
+     * @param string $value
+     * @return \SimpleSAML\XML\Type\ValueTypeInterface
+     */
+    public static function fromString(string $value): ValueTypeInterface;
+}
diff --git a/src/Utils.php b/src/Utils.php
index 2c00961..40e592c 100644
--- a/src/Utils.php
+++ b/src/Utils.php
@@ -7,7 +7,7 @@
 use DateTimeImmutable;
 use DateTimeInterface;
 use DOMElement;
-use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Assert\Assert;
 
 use function trim;
 
diff --git a/tests/Assert/EntitiesTest.php b/tests/Assert/EntitiesTest.php
new file mode 100644
index 0000000..0005bf8
--- /dev/null
+++ b/tests/Assert/EntitiesTest.php
@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Assert;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\Assert\AssertionFailedException;
+use SimpleSAML\XML\Assert\Assert;
+
+/**
+ * Class \SimpleSAML\Test\XML\Assert\EntitiesTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(Assert::class)]
+final class EntitiesTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $entities
+     */
+    #[DataProvider('provideEntities')]
+    public function testValidEntities(bool $shouldPass, string $entities): void
+    {
+        try {
+            Assert::validEntities($entities);
+            $this->assertTrue($shouldPass);
+        } catch (AssertionFailedException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<int, array{0: bool, 1: string}>
+     */
+    public static function provideEntities(): array
+    {
+        return [
+            [true, 'Snoopy'],
+            [true, 'CMS'],
+            [true, 'fööbár'],
+            [true, '-1950-10-04'],
+            [false, '0836217462 0836217463'],
+            [true, 'foo bar'],
+            // Quotes are forbidden
+            [false, 'foo "bar" baz'],
+            // Commas are forbidden
+            [false, 'foo,bar'],
+            // Trailing newlines are forbidden
+            [false, "foobar\n"],
+        ];
+    }
+}
diff --git a/tests/Assert/EntityTest.php b/tests/Assert/EntityTest.php
new file mode 100644
index 0000000..b7488f8
--- /dev/null
+++ b/tests/Assert/EntityTest.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Assert;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\Assert\AssertionFailedException;
+use SimpleSAML\XML\Assert\Assert;
+
+/**
+ * Class \SimpleSAML\Test\XML\Assert\EntityTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(Assert::class)]
+final class EntityTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $entity
+     */
+    #[DataProvider('provideEntity')]
+    public function testValidEntity(bool $shouldPass, string $entity): void
+    {
+        try {
+            Assert::validEntity($entity);
+            $this->assertTrue($shouldPass);
+        } catch (AssertionFailedException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<int, array{0: bool, 1: string}>
+     */
+    public static function provideEntity(): array
+    {
+        return [
+            [true, 'Snoopy'],
+            [true, 'CMS'],
+            [true, 'fööbár'],
+            [true, '-1950-10-04'],
+            [false, '0836217462'],
+            // Spaces are forbidden
+            [false, 'foo bar'],
+            // Commas are forbidden
+            [false, 'foo,bar'],
+            // Trailing newlines are forbidden
+            [false, "foobar\n"],
+        ];
+    }
+}
diff --git a/tests/Assert/HexBinTest.php b/tests/Assert/HexBinaryTest.php
similarity index 97%
rename from tests/Assert/HexBinTest.php
rename to tests/Assert/HexBinaryTest.php
index 042e7ce..76deff6 100644
--- a/tests/Assert/HexBinTest.php
+++ b/tests/Assert/HexBinaryTest.php
@@ -7,8 +7,8 @@
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
-use SimpleSAML\Assert\Assert;
 use SimpleSAML\Assert\AssertionFailedException;
+use SimpleSAML\XML\Assert\Assert;
 
 /**
  * Class \SimpleSAML\Test\Assert\HexBinaryTest
diff --git a/tests/Assert/IDRefTest.php b/tests/Assert/IDRefTest.php
new file mode 100644
index 0000000..c5c25cf
--- /dev/null
+++ b/tests/Assert/IDRefTest.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Assert;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\Assert\AssertionFailedException;
+use SimpleSAML\XML\Assert\Assert;
+
+/**
+ * Class \SimpleSAML\Test\XML\Assert\IDRefTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(Assert::class)]
+final class IDRefTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $idref
+     */
+    #[DataProvider('provideIDRef')]
+    public function testValidIDRef(bool $shouldPass, string $idref): void
+    {
+        try {
+            Assert::validIDRef($idref);
+            $this->assertTrue($shouldPass);
+        } catch (AssertionFailedException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<int, array{0: bool, 1: string}>
+     */
+    public static function provideIDRef(): array
+    {
+        return [
+            [true, 'Snoopy'],
+            [true, 'CMS'],
+            [true, 'fööbár'],
+            [true, '-1950-10-04'],
+            [false, '0836217462'],
+            // Spaces are forbidden
+            [false, 'foo bar'],
+            // Commas are forbidden
+            [false, 'foo,bar'],
+            // Trailing newlines are forbidden
+            [false, "foobar\n"],
+        ];
+    }
+}
diff --git a/tests/Assert/IDRefsTest.php b/tests/Assert/IDRefsTest.php
new file mode 100644
index 0000000..d12cc73
--- /dev/null
+++ b/tests/Assert/IDRefsTest.php
@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Assert;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\Assert\AssertionFailedException;
+use SimpleSAML\XML\Assert\Assert;
+
+/**
+ * Class \SimpleSAML\Test\XML\Assert\IDRefsTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(Assert::class)]
+final class IDRefsTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $idrefs
+     */
+    #[DataProvider('provideIDRefs')]
+    public function testValidIDRefs(bool $shouldPass, string $idrefs): void
+    {
+        try {
+            Assert::validIDRefs($idrefs);
+            $this->assertTrue($shouldPass);
+        } catch (AssertionFailedException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<int, array{0: bool, 1: string}>
+     */
+    public static function provideIDRefs(): array
+    {
+        return [
+            [true, 'Snoopy'],
+            [true, 'CMS'],
+            [true, 'fööbár'],
+            [true, '-1950-10-04'],
+            [false, '0836217462 0836217463'],
+            [true, 'foo bar'],
+            // Quotes are forbidden
+            [false, 'foo "bar" baz'],
+            // Commas are forbidden
+            [false, 'foo,bar'],
+            // Trailing newlines are forbidden
+            [false, "foobar\n"],
+        ];
+    }
+}
diff --git a/tests/Assert/IDTest.php b/tests/Assert/IDTest.php
new file mode 100644
index 0000000..d333c2e
--- /dev/null
+++ b/tests/Assert/IDTest.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Assert;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\Assert\AssertionFailedException;
+use SimpleSAML\XML\Assert\Assert;
+
+/**
+ * Class \SimpleSAML\Test\XML\Assert\IDTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(Assert::class)]
+final class IDTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $id
+     */
+    #[DataProvider('provideID')]
+    public function testValidID(bool $shouldPass, string $id): void
+    {
+        try {
+            Assert::validID($id);
+            $this->assertTrue($shouldPass);
+        } catch (AssertionFailedException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<int, array{0: bool, 1: string}>
+     */
+    public static function provideID(): array
+    {
+        return [
+            [true, 'Snoopy'],
+            [true, 'CMS'],
+            [true, 'fööbár'],
+            [true, '-1950-10-04'],
+            [false, '0836217462'],
+            // Spaces are forbidden
+            [false, 'foo bar'],
+            // Commas are forbidden
+            [false, 'foo,bar'],
+            // Trailing newlines are forbidden
+            [false, "foobar\n"],
+        ];
+    }
+}
diff --git a/tests/Assert/LangTest.php b/tests/Assert/LangTest.php
new file mode 100644
index 0000000..25468a6
--- /dev/null
+++ b/tests/Assert/LangTest.php
@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Assert;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\Assert\AssertionFailedException;
+use SimpleSAML\XML\Assert\Assert;
+
+/**
+ * Class \SimpleSAML\Test\XML\Assert\LangTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(Assert::class)]
+final class LangTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $lang
+     */
+    #[DataProvider('provideLang')]
+    public function testValidLang(bool $shouldPass, string $lang): void
+    {
+        try {
+            Assert::validLang($lang);
+            $this->assertTrue($shouldPass);
+        } catch (AssertionFailedException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<string, array{0: bool, 1: string}>
+     */
+    public static function provideLang(): array
+    {
+        return [
+            'one part' => [true, 'lang'],
+            'two parts' => [true, 'en-US'],
+            'too many parts' => [false, 'not-a-lang'],
+            'too long' => [false, 'toolonglanguage'],
+            'x-case' => [true, 'x-klingon'],
+            'i-case' => [true, 'i-sami-no'],
+        ];
+    }
+}
diff --git a/tests/Assert/NCNameTest.php b/tests/Assert/NCNameTest.php
index f3df64e..3d81db4 100644
--- a/tests/Assert/NCNameTest.php
+++ b/tests/Assert/NCNameTest.php
@@ -41,9 +41,12 @@ public static function provideNCName(): array
     {
         return [
             [true, 'Test'],
-            [true, '_Test'],
+            [true, 'Te.st'],
+            [false, '_Test'],
+            [true, '-1950-10-04-10-00'],
+            [true, 'fööbár'],
             // Prefixed v4 UUID
-            [true, '_5425e58e-e799-4884-92cc-ca64ecede32f'],
+            [false, '_5425e58e-e799-4884-92cc-ca64ecede32f'],
             // An empty value is not valid, unless xsi:nil is used
             [false, ''],
             [false, 'Te*st'],
diff --git a/tests/Assert/NMTokensTest.php b/tests/Assert/NMTokensTest.php
index f943be7..e74fea9 100644
--- a/tests/Assert/NMTokensTest.php
+++ b/tests/Assert/NMTokensTest.php
@@ -50,7 +50,7 @@ public static function provideNMTokens(): array
             [false, 'foo "bar" baz'],
             // Commas are forbidden
             [false, 'foo,bar'],
-            // Trailing newlines are forbidden
+            // Trailing whitespace is forbidden
             [false, "foobar\n"],
         ];
     }
diff --git a/tests/Assert/NameTest.php b/tests/Assert/NameTest.php
new file mode 100644
index 0000000..6f3adbc
--- /dev/null
+++ b/tests/Assert/NameTest.php
@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Assert;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\Assert\AssertionFailedException;
+use SimpleSAML\XML\Assert\Assert;
+
+/**
+ * Class \SimpleSAML\Test\XML\Assert\NameTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(Assert::class)]
+final class NameTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $name
+     */
+    #[DataProvider('provideName')]
+    public function testValidToken(bool $shouldPass, string $name): void
+    {
+        try {
+            Assert::validName($name);
+            $this->assertTrue($shouldPass);
+        } catch (AssertionFailedException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<int, array{0: bool, 1: string}>
+     */
+    public static function provideName(): array
+    {
+        return [
+            [true, 'Snoopy'],
+            [true, ':CMS'],
+            [true, 'fööbár'],
+            [true, '-1950-10-04'],
+            // Must start with a letter, a dash or a colon
+            [false, '0836217462'],
+            // Spaces are forbidden
+            [false, 'foo bar'],
+            // Commas are forbidden
+            [false, 'foo,bar'],
+            // Trailing newlines are forbidden
+            [false, "foobar\n"],
+        ];
+    }
+}
diff --git a/tests/Assert/QNameTest.php b/tests/Assert/QNameTest.php
index bf69747..344dc79 100644
--- a/tests/Assert/QNameTest.php
+++ b/tests/Assert/QNameTest.php
@@ -41,8 +41,8 @@ public static function provideQName(): array
     {
         return [
             [true, 'some:Test'],
-            [true, 'some:_Test'],
-            [true, '_some:_Test'],
+            [true, 'some:-Test'],
+            [true, '-some:-Test'],
             [true, 'Test'],
             // Cannot start with a colon
             [false, ':test'],
diff --git a/tests/Type/DateTimeValueTest.php b/tests/Type/DateTimeValueTest.php
new file mode 100644
index 0000000..cf49024
--- /dev/null
+++ b/tests/Type/DateTimeValueTest.php
@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+use SimpleSAML\XML\Type\DateTimeValue;
+
+/**
+ * Class \SimpleSAML\Test\Type\DateTimeValueTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(DateTimeValue::class)]
+final class DateTimeValueTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $dateTime
+     */
+    #[DataProvider('provideDateTime')]
+    public function testQName(bool $shouldPass, string $dateTime): void
+    {
+        try {
+            DateTimeValue::fromString($dateTime);
+            $this->assertTrue($shouldPass);
+        } catch (SchemaViolationException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<string, array{0: bool, 1: string}>
+     */
+    public static function provideDateTime(): array
+    {
+        return [
+            'datetime' => [true, '2001-10-26T21:32:52'],
+            'datetime with numeric difference' => [true, '2001-10-26T21:32:52+02:00'],
+            'datetime with Zulu' => [true, '2001-10-26T19:32:52Z'],
+            'datetime with 00:00 difference' => [true, '2001-10-26T19:32:52+00:00'],
+            'datetime with negative value' => [true, '-2001-10-26T21:32:52'],
+            'datetime with subseconds' => [true, '2001-10-26T21:32:52.12679'],
+            'date' => [false, '2001-10-26'],
+            'datetime without seconds' => [false, '2001-10-26T21:32'],
+            'datetime with invalid hour'  => [false, '2001-10-26T25:32:52+02:00'],
+            'invalid date format' => [false, '01-10-26T21:32'],
+        ];
+    }
+}
diff --git a/tests/Type/DurationValueTest.php b/tests/Type/DurationValueTest.php
new file mode 100644
index 0000000..0548847
--- /dev/null
+++ b/tests/Type/DurationValueTest.php
@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+use SimpleSAML\XML\Type\DurationValue;
+
+/**
+ * Class \SimpleSAML\Test\Type\DurationValueTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(DurationValue::class)]
+final class DurationValueTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $duration
+     */
+    #[DataProvider('provideDuration')]
+    public function testQName(bool $shouldPass, string $duration): void
+    {
+        try {
+            DurationValue::fromString($duration);
+            $this->assertTrue($shouldPass);
+        } catch (SchemaViolationException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<int, array{0: bool, 1: string}>
+     */
+    public static function provideDuration(): array
+    {
+        return [
+            [true, 'P2Y6M5DT12H35M30S'],
+            [true, 'P1DT2H'],
+            [true, 'P1W'],
+            [true, 'P20M'],
+            [true, 'PT20M'],
+            [true, 'P0Y20M0D'],
+            [true, 'P0Y'],
+            [true, '-P60D'],
+            [true, 'PT1M30.5S'],
+            [true, 'P15.5Y'],
+            [true, 'P15,5Y'],
+            [false, 'P-20M'],
+            [false, 'P20MT'],
+            [false, 'P1YM5D'],
+            [false, 'P1D2H'],
+            [false, '1Y2M'],
+            [false, 'P2M1Y'],
+            [false, 'P'],
+            [false, 'PT15.S'],
+            // Trailing newlines are forbidden
+            [false, "P20M\n"],
+        ];
+    }
+}
diff --git a/tests/Type/EntitiesValueTest.php b/tests/Type/EntitiesValueTest.php
new file mode 100644
index 0000000..b7a4101
--- /dev/null
+++ b/tests/Type/EntitiesValueTest.php
@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+use SimpleSAML\XML\Type\EntitiesValue;
+
+/**
+ * Class \SimpleSAML\Test\Type\EntitiesValueTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(EntitiesValue::class)]
+final class EntitiesValueTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $entities
+     */
+    #[DataProvider('provideEntities')]
+    public function testIDRefs(bool $shouldPass, string $entities): void
+    {
+        try {
+            EntitiesValue::fromString($entities);
+            $this->assertTrue($shouldPass);
+        } catch (SchemaViolationException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<string, array{0: bool, 1: string}>
+     */
+    public static function provideEntities(): array
+    {
+        return [
+            'valid' => [true, 'Snoopy foobar'],
+            'diacritical' => [true, 'Snööpy fööbár'],
+            'start with colon' => [false, 'foobar :CMS'],
+            'start with dash' => [true, '-1950-10-04 foobar'],
+            'invalid first char' => [false, '0836217462 1378943'],
+            'space' => [true, 'foo bar'],
+            'colon' => [false, 'foo:bar'],
+            'comma' => [false, 'foo,bar'],
+            'whitespace collapse' => [true, "foobar\n"],
+            'normalization' => [true, ' foobar '],
+        ];
+    }
+}
diff --git a/tests/Type/EntityValueTest.php b/tests/Type/EntityValueTest.php
new file mode 100644
index 0000000..50f78a7
--- /dev/null
+++ b/tests/Type/EntityValueTest.php
@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+use SimpleSAML\XML\Type\EntityValue;
+
+/**
+ * Class \SimpleSAML\Test\Type\EntityValueTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(EntityValue::class)]
+final class EntityValueTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $entity
+     */
+    #[DataProvider('provideEntity')]
+    public function testIDRef(bool $shouldPass, string $entity): void
+    {
+        try {
+            EntityValue::fromString($entity);
+            $this->assertTrue($shouldPass);
+        } catch (SchemaViolationException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<string, array{0: bool, 1: string}>
+     */
+    public static function provideEntity(): array
+    {
+        return [
+            'valid' => [true, 'Snoopy'],
+            'diacritical' => [true, 'fööbár'],
+            'start with colon' => [false, ':CMS'],
+            'start with dash' => [true, '-1950-10-04'],
+            'invalid first char' => [false, '0836217462'],
+            'space' => [false, 'foo bar'],
+            'colon' => [false, 'foo:bar'],
+            'comma' => [false, 'foo,bar'],
+            'whitespace collapse' => [true, "foobar\n"],
+            'normalization' => [true, ' foobar '],
+        ];
+    }
+}
diff --git a/tests/Type/IDRefValueTest.php b/tests/Type/IDRefValueTest.php
new file mode 100644
index 0000000..2865b7d
--- /dev/null
+++ b/tests/Type/IDRefValueTest.php
@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+use SimpleSAML\XML\Type\IDRefValue;
+
+/**
+ * Class \SimpleSAML\Test\Type\IDRefValueTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(IDRefValue::class)]
+final class IDRefValueTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $idref
+     */
+    #[DataProvider('provideIDRef')]
+    public function testIDRef(bool $shouldPass, string $idref): void
+    {
+        try {
+            IDRefValue::fromString($idref);
+            $this->assertTrue($shouldPass);
+        } catch (SchemaViolationException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<string, array{0: bool, 1: string}>
+     */
+    public static function provideIDRef(): array
+    {
+        return [
+            'valid' => [true, 'Snoopy'],
+            'diacritical' => [true, 'fööbár'],
+            'start with colon' => [false, ':CMS'],
+            'start with dash' => [true, '-1950-10-04'],
+            'invalid first char' => [false, '0836217462'],
+            'space' => [false, 'foo bar'],
+            'colon' => [false, 'foo:bar'],
+            'comma' => [false, 'foo,bar'],
+            'whitespace collapse' => [true, "foobar\n"],
+            'normalization' => [true, ' foobar '],
+        ];
+    }
+}
diff --git a/tests/Type/IDRefsValueTest.php b/tests/Type/IDRefsValueTest.php
new file mode 100644
index 0000000..8c8d8d4
--- /dev/null
+++ b/tests/Type/IDRefsValueTest.php
@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+use SimpleSAML\XML\Type\IDRefsValue;
+
+/**
+ * Class \SimpleSAML\Test\Type\IDRefsValueTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(IDRefsValue::class)]
+final class IDRefsValueTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $idrefs
+     */
+    #[DataProvider('provideIDRefs')]
+    public function testIDRefs(bool $shouldPass, string $idrefs): void
+    {
+        try {
+            IDRefsValue::fromString($idrefs);
+            $this->assertTrue($shouldPass);
+        } catch (SchemaViolationException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<string, array{0: bool, 1: string}>
+     */
+    public static function provideIDRefs(): array
+    {
+        return [
+            'valid' => [true, 'Snoopy foobar'],
+            'diacritical' => [true, 'Snööpy fööbár'],
+            'start with colon' => [false, 'foobar :CMS'],
+            'start with dash' => [true, '-1950-10-04 foobar'],
+            'invalid first char' => [false, '0836217462 1378943'],
+            'space' => [true, 'foo bar'],
+            'colon' => [false, 'foo:bar'],
+            'comma' => [false, 'foo,bar'],
+            'whitespace collapse' => [true, "foobar\n"],
+            'normalization' => [true, ' foobar '],
+        ];
+    }
+}
diff --git a/tests/Type/IDValueTest.php b/tests/Type/IDValueTest.php
new file mode 100644
index 0000000..b8745d1
--- /dev/null
+++ b/tests/Type/IDValueTest.php
@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+use SimpleSAML\XML\Type\IDValue;
+
+/**
+ * Class \SimpleSAML\Test\Type\IDValueTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(IDValue::class)]
+final class IDValueTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $id
+     */
+    #[DataProvider('provideID')]
+    public function testID(bool $shouldPass, string $id): void
+    {
+        try {
+            IDValue::fromString($id);
+            $this->assertTrue($shouldPass);
+        } catch (SchemaViolationException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<string, array{0: bool, 1: string}>
+     */
+    public static function provideID(): array
+    {
+        return [
+            'valid' => [true, 'Snoopy'],
+            'diacritical' => [true, 'fööbár'],
+            'start with colon' => [false, ':CMS'],
+            'start with dash' => [true, '-1950-10-04'],
+            'invalid first char' => [false, '0836217462'],
+            'space' => [false, 'foo bar'],
+            'colon' => [false, 'foo:bar'],
+            'comma' => [false, 'foo,bar'],
+            'whitespace collapse' => [true, "foobar\n"],
+            'normalization' => [true, ' foobar '],
+        ];
+    }
+}
diff --git a/tests/Type/LangValueTest.php b/tests/Type/LangValueTest.php
new file mode 100644
index 0000000..7333dd5
--- /dev/null
+++ b/tests/Type/LangValueTest.php
@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+use SimpleSAML\XML\Type\LangValue;
+
+/**
+ * Class \SimpleSAML\Test\Type\LangValueTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(LangValue::class)]
+final class LangValueTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $lang
+     */
+    #[DataProvider('provideLang')]
+    public function testLang(bool $shouldPass, string $lang): void
+    {
+        try {
+            LangValue::fromString($lang);
+            $this->assertTrue($shouldPass);
+        } catch (SchemaViolationException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<string, array{0: bool, 1: string}>
+     */
+    public static function provideLang(): array
+    {
+        return [
+            'one part' => [true, 'lang'],
+            'two parts' => [true, 'en-US'],
+            'too many parts' => [false, 'not-a-lang'],
+            'too long' => [false, 'toolonglanguage'],
+            'x-case' => [true, 'x-klingon'],
+            'i-case' => [true, 'i-sami-no'],
+            'normalization' => [true, ' en-US '],
+        ];
+    }
+}
diff --git a/tests/Type/NCNameValueTest.php b/tests/Type/NCNameValueTest.php
new file mode 100644
index 0000000..4097abc
--- /dev/null
+++ b/tests/Type/NCNameValueTest.php
@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+use SimpleSAML\XML\Type\NCNameValue;
+
+/**
+ * Class \SimpleSAML\Test\Type\NCNameValueTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(NCNameValue::class)]
+final class NCNameValueTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $ncname
+     */
+    #[DataProvider('provideNCName')]
+    public function testNCName(bool $shouldPass, string $ncname): void
+    {
+        try {
+            NCNameValue::fromString($ncname);
+            $this->assertTrue($shouldPass);
+        } catch (SchemaViolationException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<string, array{0: bool, 1: string}>
+     */
+    public static function provideNCName(): array
+    {
+        return [
+            'valid' => [true, 'Snoopy'],
+            'diacritical' => [true, 'fööbár'],
+            'start with colon' => [false, ':CMS'],
+            'start with dash' => [true, '-1950-10-04'],
+            'invalid first char' => [false, '0836217462'],
+            'space' => [false, 'foo bar'],
+            'colon' => [false, 'foo:bar'],
+            'comma' => [false, 'foo,bar'],
+            'whitespace collapse' => [true, "foobar\n"],
+            'normalization' => [true, ' foobar '],
+        ];
+    }
+}
diff --git a/tests/Type/NMTokenValueTest.php b/tests/Type/NMTokenValueTest.php
new file mode 100644
index 0000000..bff0fcd
--- /dev/null
+++ b/tests/Type/NMTokenValueTest.php
@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+use SimpleSAML\XML\Type\NMTokenValue;
+
+/**
+ * Class \SimpleSAML\Test\Type\NMTokenValueTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(NMTokenValue::class)]
+final class NMTokenValueTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $nmtoken
+     */
+    #[DataProvider('provideNMToken')]
+    public function testName(bool $shouldPass, string $nmtoken): void
+    {
+        try {
+            NMTokenValue::fromString($nmtoken);
+            $this->assertTrue($shouldPass);
+        } catch (SchemaViolationException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<string, array{0: bool, 1: string}>
+     */
+    public static function provideNMToken(): array
+    {
+        return [
+            'valid' => [true, 'Snoopy'],
+            'diacritical' => [true, 'fööbár'],
+            'start with colon' => [true, ':CMS'],
+            'start with dash' => [true, '-1950-10-04'],
+            'numeric first char' => [true, '0836217462'],
+            'space' => [false, 'foo bar'],
+            'comma' => [false, 'foo,bar'],
+            'whitespace collapse' => [true, "foobar\n"],
+            'normalization' => [true, ' foobar '],
+        ];
+    }
+}
diff --git a/tests/Type/NMTokensValueTest.php b/tests/Type/NMTokensValueTest.php
new file mode 100644
index 0000000..be055f0
--- /dev/null
+++ b/tests/Type/NMTokensValueTest.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+use SimpleSAML\XML\Type\NMTokensValue;
+
+/**
+ * Class \SimpleSAML\Test\Type\NMTokensValueTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(NMTokensValue::class)]
+final class NMTokensValueTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $nmtokens
+     */
+    #[DataProvider('provideNMTokens')]
+    public function testName(bool $shouldPass, string $nmtokens): void
+    {
+        try {
+            NMTokensValue::fromString($nmtokens);
+            $this->assertTrue($shouldPass);
+        } catch (SchemaViolationException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<string, array{0: bool, 1: string}>
+     */
+    public static function provideNMTokens(): array
+    {
+        return [
+            'valid' => [true, 'Snoopy foobar'],
+            'diacritical' => [true, 'Snoopy fööbár'],
+            'start with colon' => [true, ':CMS :ABC'],
+            'start with dash' => [true, '-1950-10-04 -1984-11-07'],
+            'numeric first char' => [true, '0836217462'],
+            'comma' => [false, 'foo,bar'],
+            'whitespace collapse' => [true, "foobar\n"],
+            'normalization' => [true, ' foobar   nmtoken '],
+        ];
+    }
+}
diff --git a/tests/Type/NameValueTest.php b/tests/Type/NameValueTest.php
new file mode 100644
index 0000000..ce3fdb2
--- /dev/null
+++ b/tests/Type/NameValueTest.php
@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+use SimpleSAML\XML\Type\NameValue;
+
+/**
+ * Class \SimpleSAML\Test\Type\NameValueTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(NameValue::class)]
+final class NameValueTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $name
+     */
+    #[DataProvider('provideName')]
+    public function testName(bool $shouldPass, string $name): void
+    {
+        try {
+            NameValue::fromString($name);
+            $this->assertTrue($shouldPass);
+        } catch (SchemaViolationException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<string, array{0: bool, 1: string}>
+     */
+    public static function provideName(): array
+    {
+        return [
+            'valid' => [true, 'Snoopy'],
+            'diacritical' => [true, 'fööbár'],
+            'start with colon' => [true, ':CMS'],
+            'start with dash' => [true, '-1950-10-04'],
+            'invalid first char' => [false, '0836217462'],
+            'space' => [false, 'foo bar'],
+            'comma' => [false, 'foo,bar'],
+            'whitespace collapse' => [true, "foobar\n"],
+            'normalization' => [true, ' foobar '],
+        ];
+    }
+}
diff --git a/tests/Type/NormalizedStringValueTest.php b/tests/Type/NormalizedStringValueTest.php
new file mode 100644
index 0000000..b0e6781
--- /dev/null
+++ b/tests/Type/NormalizedStringValueTest.php
@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\Type\NormalizedStringValue;
+
+/**
+ * Class \SimpleSAML\Test\Type\NormalizedStringValueTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(NormalizedStringValue::class)]
+final class NormalizedStringValueTest extends TestCase
+{
+    /**
+     * @param string $str
+     * @param string $normalizedString
+     */
+    #[DataProvider('provideString')]
+    public function testNormalizedString(string $str, string $normalizedString): void
+    {
+        $value = NormalizedStringValue::fromString($str);
+        $this->assertEquals($normalizedString, $value->getValue());
+        $this->assertEquals($str, $value->getRawValue());
+    }
+
+
+    /**
+     * @return array<string, array{0: string, 1: string}>
+     */
+    public static function provideString(): array
+    {
+        return [
+            'preserve spaces' => ['  Snoopy  ', '  Snoopy  '],
+            'replace whitespace' => ["  Snoopy\t\n\rrulez  ", '  Snoopy   rulez  '],
+        ];
+    }
+}
diff --git a/tests/Type/QNameValueTest.php b/tests/Type/QNameValueTest.php
new file mode 100644
index 0000000..527b9ad
--- /dev/null
+++ b/tests/Type/QNameValueTest.php
@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+use SimpleSAML\XML\Type\QNameValue;
+
+/**
+ * Class \SimpleSAML\Test\Type\QNameValueTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(QNameValue::class)]
+final class QNameValueTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $qname
+     */
+    #[DataProvider('provideQName')]
+    public function testQName(bool $shouldPass, string $qname): void
+    {
+        try {
+            QNameValue::fromString($qname);
+            $this->assertTrue($shouldPass);
+        } catch (SchemaViolationException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<string, array{0: bool, 1: string}>
+     */
+    public static function provideQName(): array
+    {
+        return [
+            'valid' => [true, 'some:Test'],
+            'start 2nd part with dash' => [true, 'some:-Test'],
+            'start both parts with dash' => [true, '-some:-Test'],
+            'no colon' => [true, 'Test'],
+            'start with colon' => [false, ':test'],
+            'multiple colons' => [false, 'test:test:test'],
+            'start with digit' => [false, '1Test'],
+            'wildcard' => [false, 'Te*st'],
+            'prefixed newline' => [false, "\nsome:Test"],
+            'trailing newline' => [false, "some:Test\n"],
+        ];
+    }
+}
diff --git a/tests/Type/TokenValueTest.php b/tests/Type/TokenValueTest.php
new file mode 100644
index 0000000..bf01ca5
--- /dev/null
+++ b/tests/Type/TokenValueTest.php
@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\Type\TokenValue;
+
+/**
+ * Class \SimpleSAML\Test\Type\TokenValueTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(TokenValue::class)]
+final class TokenValueTest extends TestCase
+{
+    /**
+     * @param string $str
+     * @param string $normalizedString
+     */
+    #[DataProvider('provideString')]
+    public function testToken(string $str, string $normalizedString): void
+    {
+        $value = TokenValue::fromString($str);
+        $this->assertEquals($normalizedString, $value->getValue());
+        $this->assertEquals($str, $value->getRawValue());
+    }
+
+
+    /**
+     * @return array<string, array{0: string, 1: string}>
+     */
+    public static function provideString(): array
+    {
+        return [
+            'trim' => ['  Snoopy  ', 'Snoopy'],
+            'replace whitespace' => ["Snoopy\trulez", 'Snoopy rulez'],
+            'collapse' => ["Snoopy\t\n\rrulez", 'Snoopy rulez'],
+        ];
+    }
+}
diff --git a/tests/Type/URIValueTest.php b/tests/Type/URIValueTest.php
new file mode 100644
index 0000000..ae7549b
--- /dev/null
+++ b/tests/Type/URIValueTest.php
@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\XML\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+use SimpleSAML\XML\Type\AnyURIValue;
+
+/**
+ * Class \SimpleSAML\Test\Type\AnyURIValueTest
+ *
+ * @package simplesamlphp/xml-common
+ */
+#[CoversClass(AnyURIValue::class)]
+final class AnyURIValueTest extends TestCase
+{
+    /**
+     * @param boolean $shouldPass
+     * @param string $uri
+     */
+    #[DataProvider('provideURI')]
+    public function testAnyURI(bool $shouldPass, string $uri): void
+    {
+        try {
+            AnyURIValue::fromString($uri);
+            $this->assertTrue($shouldPass);
+        } catch (SchemaViolationException $e) {
+            $this->assertFalse($shouldPass);
+        }
+    }
+
+
+    /**
+     * @return array<string, array{0: bool, 1: string}>
+     */
+    public static function provideURI(): array
+    {
+        return [
+            'urn' => [true, 'urn:x-simplesamlphp:phpunit'],
+            'same-doc' => [true, '#_53d830ab1be17291a546c95c7f1cdf8d3d23c959e6'],
+            'url' => [true, 'https://www.simplesamlphp.org'],
+            'diacritical' => [true, 'https://aä.com'],
+            'spn' => [true, 'spn:a4cf592f-a64c-46ff-a788-b260f474525b'],
+            'typos' => [true, 'https//www.uni.l/en/'],
+            'spaces' => [true, 'this is silly'],
+            'empty' => [true, ''],
+            'azure-common' => [true, 'https://sts.windows.net/{tenantid}/'],
+        ];
+    }
+}