diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
index 3a9251f..ff81655 100644
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1,3 +1 @@
-# These are supported funding model platforms
-
 github: byjg
diff --git a/.github/workflows/phpunit.yml b/.github/workflows/phpunit.yml
index 402fee8..c2f2580 100644
--- a/.github/workflows/phpunit.yml
+++ b/.github/workflows/phpunit.yml
@@ -16,6 +16,7 @@ jobs:
     strategy:
       matrix:
         php-version:
+          - "8.4"
           - "8.3"
           - "8.2"
           - "8.1"
@@ -23,8 +24,8 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - run: composer install
-      - run: ./vendor/bin/phpunit --stderr
       - run: ./vendor/bin/psalm
+      - run: ./vendor/bin/phpunit
 
   Documentation:
     if: github.ref == 'refs/heads/master'
diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 0000000..6bcabfb
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,35 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {  
+      "name": "Debug current Script in Console",  
+      "type": "php",  
+      "request": "launch",  
+      "program": "${file}",  
+      "cwd": "${fileDirname}",  
+      "port": 9003,  
+      "runtimeArgs": [  
+        "-dxdebug.start_with_request=yes"  
+      ],  
+      "env": {  
+        "XDEBUG_MODE": "debug,develop",  
+        "XDEBUG_CONFIG": "client_port=${port}"  
+      }  
+    },
+    {
+      "name": "PHPUnit Debug",
+      "type": "php",
+      "request": "launch",
+      "program": "${workspaceFolder}/vendor/bin/phpunit",
+      "cwd": "${workspaceFolder}",
+      "port": 9003,
+      "runtimeArgs": [
+        "-dxdebug.start_with_request=yes"
+      ],
+      "env": {
+        "XDEBUG_MODE": "debug,develop",
+        "XDEBUG_CONFIG": "client_port=${port}"
+      }
+    }
+  ]
+} 
\ No newline at end of file
diff --git a/README.md b/README.md
index b1e2cd1..a9ac0ad 100644
--- a/README.md
+++ b/README.md
@@ -1,34 +1,95 @@
-# XmlUtil
-
 [![Build Status](https://github.com/byjg/php-xmlutil/actions/workflows/phpunit.yml/badge.svg?branch=master)](https://github.com/byjg/php-xmlutil/actions/workflows/phpunit.yml)
 [![Opensource ByJG](https://img.shields.io/badge/opensource-byjg-success.svg)](http://opensource.byjg.com)
 [![GitHub source](https://img.shields.io/badge/Github-source-informational?logo=github)](https://github.com/byjg/php-xmlutil/)
 [![GitHub license](https://img.shields.io/github/license/byjg/php-xmlutil.svg)](https://opensource.byjg.com/opensource/licensing.html)
 [![GitHub release](https://img.shields.io/github/release/byjg/php-xmlutil.svg)](https://github.com/byjg/php-xmlutil/releases/)
 
-A utility class to make it easy work with XML in PHP
+# PHP XML Util
+
+A powerful and intuitive PHP library for working with XML documents. This utility makes XML manipulation, querying,
+and conversion simple and straightforward in PHP.
+
+## Overview
+
+PHP XML Util provides a comprehensive set of tools for XML manipulation in PHP applications. It simplifies common 
+XML operations with an intuitive API, allowing developers to create, modify, query, and validate XML documents
+with minimal code.
+
+The library is designed to be lightweight yet powerful, offering features that go beyond 
+PHP's built-in XML functionality while maintaining a clean and easy-to-use interface.
 
-## Examples
+## Key Features
 
-- [Create a new XML Document using the API](docs/using-api.md)
-- [Working with namespaces](docs/namespaces.md)
-- [Query a XMLDocument](docs/query-document.md)
-- [Convert any model to XML](docs/convert-model-xml.md)
-- [Use Attributes to help in the conversion](docs/convert-model-xml-withattributes.md)
-- [Clean an XML document removing specific tags](docs/clean-document.md)
+- **Simple XML Creation API** - Create and manipulate XML documents programmatically with an intuitive API
+- **XPath Querying** - Easily query and navigate XML documents using XPath expressions
+- **PHP Model ↔ XML Conversion** - Seamlessly convert between PHP objects and XML representations
+- **Attribute-Based Mapping** - Use PHP attributes to control XML serialization behavior
+- **Namespace Support** - Full support for XML namespaces in all operations
+- **Document Cleaning** - Selectively remove specific tags from XML documents
+- **XML Validation** - Validate XML documents against schemas
+- **File Handling** - Convenient methods for loading and saving XML from/to files
 
-## Install
+## Quick Example
+
+```php
+<?php
+use ByJG\XmlUtil\XmlDocument;
+
+// Create a new XML document
+$xml = new XmlDocument('<root />');
+
+// Build the document structure
+$myNode = $xml->appendChild('mynode');
+$myNode->appendChild('subnode', 'text');
+$myNode->appendChild('subnode', 'more text');
+$otherNode = $myNode->appendChild('othersubnode', 'other text');
+$otherNode->addAttribute('attr', 'value');
+
+// Output formatted XML
+echo $xml->toString(format: true);
+```
+
+Output:
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <mynode>
+    <subnode>text</subnode>
+    <subnode>more text</subnode>
+    <othersubnode attr="value">other text</othersubnode>
+  </mynode>
+</root>
+```
+
+## Documentation
+
+The library is fully documented with detailed guides and examples for each feature:
+
+- [Creating XML Documents](docs/using-api.md): Learn how to create and manipulate XML documents using the API
+- [Working with Namespaces](docs/namespaces.md): Guide to handling XML namespaces properly
+- [Querying with XPath](docs/query-document.md): How to use XPath expressions to query XML documents
+- [PHP Models to XML](docs/convert-model-xml.md): Converting PHP objects to XML and vice versa
+- [Attribute-Based Mapping](docs/convert-model-xml-withattributes.md): Using PHP attributes to control XML serialization
+- [Cleaning Documents](docs/clean-document.md): Removing specific tags from XML documents
+- [File Operations](docs/file-handling.md): Loading and saving XML from/to files
+- [XML Validation](docs/validate-document.md): Validating XML documents against schemas
+
+## Installation
 
 ```bash
 composer require "byjg/xmlutil"
 ```
 
-## Running the Tests
+## Running Tests
 
 ```bash
 vendor/bin/phpunit
 ```
 
+## License
+
+MIT
+
 ## Dependencies
 
 ```mermaid
@@ -38,6 +99,5 @@ flowchart TD
     byjg/xmlutil --> byjg/serializer
 ```
 
-
 ----
 [Open source ByJG](http://opensource.byjg.com)
\ No newline at end of file
diff --git a/composer.json b/composer.json
index 6fecd5b..e9d9545 100644
--- a/composer.json
+++ b/composer.json
@@ -14,15 +14,15 @@
   "minimum-stability": "dev",
   "prefer-stable": true,
   "require": {
-    "php": ">=8.1 <8.4",
+    "php": ">=8.1 <8.5",
     "ext-dom": "*",
     "ext-libxml": "*",
     "ext-simplexml": "*",
-    "byjg/serializer": "^5.0"
+    "byjg/serializer": "^5.1"
   },
   "require-dev": {
-    "phpunit/phpunit": "^9.6",
-    "vimeo/psalm": "^5.20"
+    "phpunit/phpunit": "^10.5|^11.5",
+    "vimeo/psalm": "^5.9|^6.2"
   },
   "license": "MIT"
 }
diff --git a/docs/clean-document.md b/docs/clean-document.md
index e85995e..8f07ce4 100644
--- a/docs/clean-document.md
+++ b/docs/clean-document.md
@@ -4,10 +4,9 @@ sidebar_position: 6
 
 # Clean Document
 
-XmlUtil have a class for selectively remove specific marks (tags)
-from the document or remove all marks.
+XmlUtil provides a dedicated `CleanDocument` class for selectively removing specific tags or content from XML or HTML documents. This is useful for cleaning up documents before processing or display.
 
-Example:
+## Basic Usage
 
 ```php
 <?php
@@ -20,3 +19,68 @@ $document
     ->stripTagsExcept(['img'])
     ->get();
 ```
+
+## Available Methods
+
+### stripAllTags()
+
+Removes all HTML/XML tags from the document.
+
+```php
+$document = new \ByJG\XmlUtil\CleanDocument($html);
+$plainText = $document->stripAllTags();
+```
+
+### stripTagsExcept(array $allowedTags)
+
+Strips all HTML/XML tags except those specified in the array.
+
+```php
+$document = new \ByJG\XmlUtil\CleanDocument($html);
+$cleanHtml = $document->stripTagsExcept(['p', 'div', 'span'])->get();
+```
+
+### removeContentByProperty(string $property)
+
+Removes content from any tag that contains the specified property.
+
+```php
+$document = new \ByJG\XmlUtil\CleanDocument($html);
+// Removes all tags containing the "style" property and their content
+$cleanHtml = $document->removeContentByProperty('style')->get();
+```
+
+### removeContentByTag(string $tag, string $property = '')
+
+Removes content from the specified tag, optionally filtering by a property.
+
+```php
+$document = new \ByJG\XmlUtil\CleanDocument($html);
+// Removes all <script> tags and their content
+$cleanHtml = $document->removeContentByTag('script')->get();
+
+// Removes all <a> tags that have an "onclick" property
+$cleanHtml = $document->removeContentByTag('a', 'onclick')->get();
+```
+
+### removeContentByTagWithoutProperty(string $tag, string $property)
+
+Removes content from the specified tag that does NOT have the specified property.
+
+```php
+$document = new \ByJG\XmlUtil\CleanDocument($html);
+// Removes all <a> tags that don't have an "href" property
+$cleanHtml = $document->removeContentByTagWithoutProperty('a', 'href')->get();
+```
+
+### get()
+
+Returns the cleaned document as a string.
+
+```php
+$document = new \ByJG\XmlUtil\CleanDocument($html);
+// Apply cleaning operations
+$document->removeContentByTag('script');
+// Get the final result
+$cleanHtml = $document->get();
+```
diff --git a/docs/convert-model-xml-withattributes.md b/docs/convert-model-xml-withattributes.md
index 72213bc..85a7b76 100644
--- a/docs/convert-model-xml-withattributes.md
+++ b/docs/convert-model-xml-withattributes.md
@@ -4,15 +4,15 @@ sidebar_position: 5
 
 # Convert a model to XML with Attributes
 
-You can add PHP attributes to your model to help the EntityParser to convert the model to XML. 
+You can add PHP attributes to your model to help the EntityParser to convert the model to XML. This provides precise control over the XML serialization process.
 
 Example:
 ```php
 <?php
 
 use ByJG\XmlUtil\EntityParser;
-use ByJG\XmlUtil\XmlMapping\XmlEntity;
-use ByJG\XmlUtil\XmlMapping\XmlProperty;
+use ByJG\XmlUtil\Attributes\XmlEntity;
+use ByJG\XmlUtil\Attributes\XmlProperty;
 
 #[XmlEntity(
     rootElementName: 'Person',
@@ -67,6 +67,40 @@ The output will be:
 </Person>
 ```
 
+## Attributes as XML Attributes
+
+You can also map properties to XML attributes instead of elements:
+
+```php
+#[XmlEntity(rootElementName: 'Person', preserveCaseName: true)]
+class PersonWithAttributes
+{
+    #[XmlProperty(elementName: 'Name', preserveCaseName: true)]
+    public $name;
+    
+    #[XmlProperty(isAttribute: true)]
+    public $id;
+    
+    #[XmlProperty(isAttributeOf: 'Name')]
+    public $type;
+}
+
+$person = new PersonWithAttributes();
+$person->name = 'John Doe';
+$person->id = '12345';
+$person->type = 'full';
+
+$xml = (new EntityParser())->parse($person);
+```
+
+Output:
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<Person id="12345">
+  <Name type="full">John Doe</Name>
+</Person>
+```
+
 ## The XmlEntity Attribute
 
 Properties:
@@ -84,13 +118,13 @@ Properties:
 
 Properties:
 
-| Property        | Description                                                                                              | Default           |
-|-----------------|----------------------------------------------------------------------------------------------------------|-------------------|
-| `elementName`   | The name of the element different from the property name.                                                | The property name |
-| `preserveCase`  | Preserve the case of the element name, if false, all elements will be lowercase.                         | false             |
-| `namespaces`    | The namespace of the element. Need to be an associative array with prefix as key and namespace as value. | empty             |
-| `isAttribute`   | If the element is an attribute of the parent node instead of a node.                                     | false             |
-| `isAttributeOf` | The name of the sibling node that will receive the attribute.                                            | empty             |
-| `isChildOf`     | The name of the sibling node that will receive the child node.                                           | empty             |
-| `ignore`        | If true, the property will not be parsed.                                                                | false             | 
-| `ignoreEmpty`   | If true will ignore empty strings                                                                        | empty             |
+| Property           | Description                                                                                              | Default           |
+|--------------------|----------------------------------------------------------------------------------------------------------|-------------------|
+| `elementName`      | The name of the element different from the property name.                                                | The property name |
+| `preserveCaseName` | Preserve the case of the element name, if false, all elements will be lowercase.                         | false             |
+| `namespaces`       | The namespace of the element. Need to be an associative array with prefix as key and namespace as value. | empty             |
+| `isAttribute`      | If the element is an attribute of the parent node instead of a node.                                     | false             |
+| `isAttributeOf`    | The name of the sibling node that will receive the attribute.                                            | empty             |
+| `isChildOf`        | The name of the sibling node that will receive the child node.                                           | empty             |
+| `ignore`           | If true, the property will not be parsed.                                                                | false             | 
+| `ignoreEmpty`      | If true will ignore empty strings                                                                        | false             |
diff --git a/docs/file-handling.md b/docs/file-handling.md
new file mode 100644
index 0000000..4b01ff5
--- /dev/null
+++ b/docs/file-handling.md
@@ -0,0 +1,65 @@
+---
+sidebar_position: 7
+---
+
+# File Handling
+
+XmlUtil provides a simple File class for handling XML files.
+
+## Creating a File instance
+
+```php
+<?php
+use ByJG\XmlUtil\File;
+
+// Create a File instance for an existing file
+$file = new File('/path/to/file.xml');
+
+// Create a File instance for a new file (that doesn't exist yet)
+$file = new File('/path/to/newfile.xml', true);
+```
+
+## Reading a file
+
+```php
+<?php
+use ByJG\XmlUtil\File;
+use ByJG\XmlUtil\XmlDocument;
+
+$file = new File('/path/to/file.xml');
+
+// Get the file contents (returns string|bool)
+$contents = $file->getContents();
+if ($contents === false) {
+    // Handle error
+}
+
+// Create an XmlDocument from the file
+$xml = new XmlDocument($file);
+```
+
+## Saving a file
+
+```php
+<?php
+use ByJG\XmlUtil\File;
+use ByJG\XmlUtil\XmlDocument;
+
+// Save XML to a file
+$xml = new XmlDocument('<root><node>value</node></root>');
+$xml->save('/path/to/file.xml');
+
+// Or use the File class directly
+$file = new File('/path/to/file.xml', true);
+$file->save($xml->toString());
+```
+
+## Getting the filename
+
+```php
+<?php
+use ByJG\XmlUtil\File;
+
+$file = new File('/path/to/file.xml');
+$filename = $file->getFilename();
+``` 
\ No newline at end of file
diff --git a/docs/query-document.md b/docs/query-document.md
index 4b2432b..50c4e8e 100644
--- a/docs/query-document.md
+++ b/docs/query-document.md
@@ -4,6 +4,8 @@ sidebar_position: 3
 
 # Querying a Document
 
+XmlUtil provides powerful XPath functionality to query XML documents.
+
 ## Select a single node based on XPath
 
 ```php
@@ -13,5 +15,75 @@ $node = $xml->selectSingleNode('//subnode');
 ## Select all nodes based on XPath
 
 ```php
-$nodeList = $xml->selectNodes($myNode, '//subnode');
+$nodeList = $xml->selectNodes('//subnode');
+
+// Iterate through the results
+foreach ($nodeList as $node) {
+    // Create an XmlNode instance from each DOMNode
+    $xmlNode = new \ByJG\XmlUtil\XmlNode($node);
+    
+    // Now you can use all XmlNode methods
+    echo $xmlNode->innerText();
+}
+```
+
+## Working with namespaces in XPath queries
+
+If your XML document uses namespaces, you can include them in your XPath queries:
+
+```php
+// Create a namespace array
+$namespaces = [
+    'ns1' => 'http://www.example.com/namespace1',
+    'ns2' => 'http://www.example.com/namespace2'
+];
+
+// Query using namespaces
+$node = $xml->selectSingleNode('//ns1:element', $namespaces);
+$nodeList = $xml->selectNodes('//ns2:element', $namespaces);
+```
+
+## Working with selected nodes
+
+After selecting a node, you can manipulate it using all XmlNode methods:
+
+```php
+// Get a node
+$node = $xml->selectSingleNode('//element');
+
+// Get text content
+$text = $node->innerText();
+
+// Add a child node to the selected node
+$node->appendChild('child', 'text content');
+
+// Add an attribute
+$node->addAttribute('name', 'value');
+
+// Convert the node to array
+$array = $node->toArray();
+
+// Remove the node
+$node->removeNode();
+
+// Rename the node
+$node->renameNode('newName');
+```
+
+## Complex queries
+
+You can create more complex XPath queries:
+
+```php
+// Find all elements with a specific attribute
+$nodes = $xml->selectNodes('//element[@attr="value"]');
+
+// Find elements with specific text
+$nodes = $xml->selectNodes('//element[text()="specific text"]');
+
+// Find the first child element
+$node = $xml->selectSingleNode('./child::*[1]');
+
+// Combine conditions
+$nodes = $xml->selectNodes('//element[@attr1="value1" and @attr2="value2"]');
 ```
diff --git a/docs/using-api.md b/docs/using-api.md
index 5fe4881..83cd87f 100644
--- a/docs/using-api.md
+++ b/docs/using-api.md
@@ -4,7 +4,46 @@ sidebar_position: 1
 
 # Using the API
 
-## Example
+The XmlUtil library provides a simple but powerful API for working with XML documents. Here's how to get started.
+
+## Creating XML Documents
+
+### From a string
+
+```php
+<?php
+use ByJG\XmlUtil\XmlDocument;
+
+// Create from an XML string
+$xml = new XmlDocument('<root />');
+```
+
+### From a file
+
+```php
+<?php
+use ByJG\XmlUtil\XmlDocument;
+use ByJG\XmlUtil\File;
+
+// Create from a file
+$file = new File('/path/to/file.xml');
+$xml = new XmlDocument($file);
+```
+
+### Create an empty document
+
+```php
+<?php
+use ByJG\XmlUtil\XmlDocument;
+
+// Create an empty document with a specific root element
+$xml = XmlDocument::emptyDocument('root');
+
+// Create with a namespace
+$xml = XmlDocument::emptyDocument('root', 'http://www.example.com/ns');
+```
+
+## Building XML Structure
 
 ```php
 <?php
@@ -12,16 +51,20 @@ use ByJG\XmlUtil\XmlDocument;
 
 $xml = new XmlDocument('<root />');
 
+// Add child nodes
 $myNode = $xml->appendChild('mynode');
 $myNode->appendChild('subnode', 'text');
 $myNode->appendChild('subnode', 'more text');
 $otherNode = $myNode->appendChild('othersubnode', 'other text');
+
+// Add attributes
 $otherNode->addAttribute('attr', 'value');
 
+// Output formatted XML
 echo $xml->toString(format: true);
 ```
 
-will produce the follow xml
+Output:
 
 ```xml
 <?xml version="1.0" encoding="utf-8"?>
@@ -34,20 +77,112 @@ will produce the follow xml
 </root>
 ```
 
-## Convert to array
+## Working with Nodes
+
+### Adding Text
+
+```php
+$node = $xml->appendChild('node');
+$node->addText('Some text');
+
+// Add CDATA section
+$node->addText('This is <CDATA> content', true);
+```
+
+### Inserting Nodes
+
+```php
+// Insert a node before the current node
+$newNode = $node->insertBefore('newnode', 'new node text');
+```
+
+### Getting the Parent Node
+
+```php
+$parent = $node->parentNode();
+```
+
+### Renaming Nodes
+
+```php
+// Rename the current node
+$node->renameNode('newName');
+
+// Rename with namespace prefix
+$node->renameNode('prefix:newName');
+```
+
+### Removing Nodes
+
+```php
+// Remove the current node
+$node->removeNode();
+
+// Remove all nodes with a specific tag name
+$xml->removeTagName('tagToRemove');
+```
+
+### Adding objects
+
+```php
+// Add a PHP object or array to the XML structure
+$object = new stdClass();
+$object->property = 'value';
+$node->appendObject($object);
+```
+
+### Importing nodes from another document
+
+```php
+// Import nodes from another document or file
+$node->importNodes($otherXmlNode, 'nodeToImport');
+```
+
+## Converting to Other Formats
+
+### Convert to Array
 
 ```php
 $array = $xml->toArray();
 ```
 
-## Convert to String
+### Convert to String
+
+```php
+// Default output
+$string = $xml->toString();
+
+// Formatted output
+$string = $xml->toString(format: true);
+
+// Without XML header
+$string = $xml->toString(noHeader: true);
+```
+
+## Accessing DOM Objects
 
 ```php
-$array = $xml->toString();
+// Get the underlying DOMNode
+$domNode = $xml->DOMNode();
+
+// Get the underlying DOMDocument
+$domDocument = $xml->DOMDocument();
 ```
 
+## Saving XML
+
+```php
+// Save to a file
+$xml->save('/path/to/output.xml');
 
-## Diagram
+// Save with formatting
+$xml->save('/path/to/output.xml', format: true);
+
+// Save without XML header
+$xml->save('/path/to/output.xml', format: true, noHeader: true);
+```
+
+## Class Diagram
 
 ```mermaid
 classDiagram
@@ -66,13 +201,13 @@ classDiagram
         toArray()
         addNamespace()
         importNodes()
+        renameNode()
         DOMNode()
         DOMDocument()
         toString()
     }
     class XmlDocument{
         save()
-        getRootNode()
+        validate()
     }
-
 ```
diff --git a/docs/validate-document.md b/docs/validate-document.md
new file mode 100644
index 0000000..aa11367
--- /dev/null
+++ b/docs/validate-document.md
@@ -0,0 +1,45 @@
+---
+sidebar_position: 8
+---
+
+# Validating XML Documents
+
+XmlUtil provides a way to validate XML documents against XSD schemas.
+
+## Validating an XML document
+
+```php
+<?php
+use ByJG\XmlUtil\XmlDocument;
+
+$xml = new XmlDocument('<root><node>value</node></root>');
+
+// Validate against an XSD schema
+try {
+    $xml->validate('/path/to/schema.xsd');
+    echo "Document is valid!";
+} catch (\ByJG\XmlUtil\Exception\XmlUtilException $e) {
+    echo "Document is not valid: " . $e->getMessage();
+}
+```
+
+## Getting validation errors without throwing exceptions
+
+```php
+<?php
+use ByJG\XmlUtil\XmlDocument;
+
+$xml = new XmlDocument('<root><node>value</node></root>');
+
+// Validate and get errors without throwing an exception
+$errors = $xml->validate('/path/to/schema.xsd', false);
+
+if (empty($errors)) {
+    echo "Document is valid!";
+} else {
+    echo "Document is not valid:";
+    foreach ($errors as $error) {
+        echo "- " . $error . "\n";
+    }
+}
+``` 
\ No newline at end of file
diff --git a/phpunit.xml.dist b/phpunit.xml.dist
index 13600e9..711a9b0 100644
--- a/phpunit.xml.dist
+++ b/phpunit.xml.dist
@@ -9,24 +9,24 @@ and open the template in the editor.
          bootstrap="./vendor/autoload.php"
          colors="true"
          testdox="true"
-         convertErrorsToExceptions="true"
-         convertNoticesToExceptions="true"
-         convertWarningsToExceptions="true"
-         convertDeprecationsToExceptions="true"
+         displayDetailsOnTestsThatTriggerDeprecations="true"
+         displayDetailsOnTestsThatTriggerErrors="true"
+         displayDetailsOnTestsThatTriggerNotices="true"
+         displayDetailsOnTestsThatTriggerWarnings="true"
+         displayDetailsOnPhpunitDeprecations="true"
          stopOnFailure="false"
-         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.3/phpunit.xsd">
-
+         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.5/phpunit.xsd">
   <php>
     <ini name="display_errors" value="On"/>
     <ini name="display_startup_errors" value="On"/>
     <ini name="error_reporting" value="E_ALL"/>
   </php>
 
-  <coverage>
+  <source>
     <include>
-      <directory>./src</directory>
+      <directory>./src/</directory>
     </include>
-  </coverage>
+  </source>
 
   <testsuites>
     <testsuite name="Test Suite">
diff --git a/src/Attributes/XmlEntity.php b/src/Attributes/XmlEntity.php
index eb44ee8..3e8e3dc 100644
--- a/src/Attributes/XmlEntity.php
+++ b/src/Attributes/XmlEntity.php
@@ -17,7 +17,7 @@ class XmlEntity
     private ?string $usePrefix;
     private bool $explicityMap = false;
 
-    public function __construct(?string $rootElementName = null, array $namespaces = [], bool $preserveCaseName = false, bool $addNamespaceRoot = true, string $usePrefix = null, bool $explicityMap = false)
+    public function __construct(?string $rootElementName = null, array $namespaces = [], bool $preserveCaseName = false, bool $addNamespaceRoot = true, ?string $usePrefix = null, bool $explicityMap = false)
     {
         $this->rootElementName = $rootElementName;
         $this->namespaces = $namespaces;
diff --git a/src/EntityParser.php b/src/EntityParser.php
index 669247b..6a822c4 100644
--- a/src/EntityParser.php
+++ b/src/EntityParser.php
@@ -105,7 +105,7 @@ protected function addNamespaces(XmlNode $xml, XmlEntity $metadata): void
      * @throws DOMException
      * @throws XmlUtilException
      */
-    public function arrayToXml(object|array $array, XmlNode $xml, XmlEntity $rootMetadata = null): void
+    public function arrayToXml(object|array $array, XmlNode $xml, ?XmlEntity $rootMetadata = null): void
     {
         // The main Root document is not empty
         if (empty($rootMetadata)) {
diff --git a/src/File.php b/src/File.php
index db0c5fe..8c031b1 100644
--- a/src/File.php
+++ b/src/File.php
@@ -27,10 +27,10 @@ public function getFilename(): string
     }
 
     /**
-     * @return string
+     * @return string|bool
      * @throws FileException
      */
-    public function getContents(): string
+    public function getContents(): string|bool
     {
         if (!file_exists($this->filename)) {
             throw new FileException('File not found');
diff --git a/src/XmlDocument.php b/src/XmlDocument.php
index 8bee3c9..61c8163 100644
--- a/src/XmlDocument.php
+++ b/src/XmlDocument.php
@@ -88,12 +88,16 @@ public static function emptyDocument(string $name, ?string $namespace = null): X
     /**
      * Adjust xml string to the proper format
      *
-     * @param string $string - XML string document
+     * @param string|bool $string $string - XML string document
      * @return string - Return the string converted
      * @throws XmlUtilException
      */
-    protected function fixXmlHeader(string $string): string
+    protected function fixXmlHeader(string|bool $string): string
     {
+        if ($string === false) {
+            throw new XmlUtilException("Error loading XML Document.", 250);
+        }
+
         $string = $this->removeBom($string);
 
         if (str_contains($string, "<?xml")) {
@@ -149,8 +153,11 @@ protected function fixXmlHeader(string $string): string
         }
     }
 
-    protected function removeBom(string $xmlStr): string
+    protected function removeBom(string|bool $xmlStr): string|null
     {
+        if ($xmlStr === false) {
+            throw new XmlUtilException("Error loading XML Document.", 250);
+        }
         return preg_replace('/^\xEF\xBB\xBF/', '', $xmlStr);
     }
 
diff --git a/src/XmlNode.php b/src/XmlNode.php
index e8554b0..e133251 100644
--- a/src/XmlNode.php
+++ b/src/XmlNode.php
@@ -261,7 +261,7 @@ public function removeTagName(string $tagName): bool
     }
 
 
-    public function toArray(Closure $func = null): array
+    public function toArray(?Closure $func = null): array
     {
         return $this->_toArray($this->DOMNode(), $func);
     }
@@ -380,7 +380,7 @@ public function toString(bool $format = false, bool $noHeader = false): string
         return $this->_toString($this->DOMDocument(), $format, $this->node);
     }
 
-    protected function _toString(DOMDocument $domDocument, bool $format = false, DOMNode $node = null): string
+    protected function _toString(DOMDocument $domDocument, bool $format = false, ?DOMNode $node = null): string
     {
         if (!$format) {
             return $domDocument->saveXML($node);
diff --git a/tests/CleanDocumentTest.php b/tests/CleanDocumentTest.php
index 0c7be80..a3ae8a6 100644
--- a/tests/CleanDocumentTest.php
+++ b/tests/CleanDocumentTest.php
@@ -3,12 +3,14 @@
 namespace Tests;
 
 use ByJG\XmlUtil\CleanDocument;
+use Override;
 use PHPUnit\Framework\TestCase;
 
 class CleanDocumentTest extends TestCase
 {
     protected CleanDocument $object;
 
+    #[Override]
     public function setUp(): void
     {
         $this->object = new CleanDocument(