diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..f9e13b7
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,44 @@
+name: CI
+
+on: [push]
+
+jobs:
+
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v1
+        with:
+          fetch-depth: 1
+
+      - name: Set up Python 3.8
+        uses: actions/setup-python@v1
+        with:
+          python-version: 3.8
+
+      - name: Install and configure Poetry
+        uses: snok/install-poetry@v1
+        with:
+          virtualenvs-create: true
+          virtualenvs-in-project: false
+          virtualenvs-path: ~/.virtualenvs
+          installer-parallel: true
+
+      - name: Cache poetry virtualenv
+        uses: actions/cache@v1
+        id: cache
+        with:
+          path: ~/.virtualenvs
+          key: poetry-${{ hashFiles('**/poetry.lock') }}
+          restore-keys: |
+            poetry-${{ hashFiles('**/poetry.lock') }}
+
+      - name: Install dependencies
+        run: poetry install
+        if: steps.cache.outputs.cache-hit != 'true'
+
+      - name: Run tests
+        run: |
+          poetry run invoke testserver &
+          poetry run invoke tests
\ No newline at end of file
diff --git a/backlog.md b/backlog.md
index dfc7116..2c71c12 100644
--- a/backlog.md
+++ b/backlog.md
@@ -1,3 +1,9 @@
+- add invalid_value and invalid_value_error_code to PropertyValueConstraint
+- move loading source to openapidriver.py init
+- split openapi_executors
+    - test and validation keywords
+    - request builder keywords in openapi_core -> reusable package
+- support generator for PathPropertiesConstraint and PropertyValueConstraint
 - change random property invalidation to full coverage
     - loop over all properties, return list with each invalidated data set
     - remove every required property
@@ -5,8 +11,6 @@
     - invalid type for each property
     - perform request for each invalidated data set and perform all validations
     - fail test case on first fail or continue?
-- support for API key in headers
-- support for header invalidation -> 400 / 422?
 - source / origin / base_path default from openapi doc
 - support alternative id property names
 - support running test cases in random order
diff --git a/docs/README.md b/docs/README.md
index 2fbbd3f..10e50b7 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -74,6 +74,13 @@ module also implements a number of keywords.
 Details about the Keywords can be found
 [here](https://marketsquare.github.io/robotframework-openapidriver/openapidriver.html).
 
+The OpenApiDriver also support handling of relations between resources within the scope
+of the API being validated as well as handling dependencies on resources outside the
+scope of the API. In addition there is support for handling restrictions on the values
+of parameters and properties.
+Details about the `mappings_path` variable usage can be found
+[here](https://marketsquare.github.io/robotframework-openapidriver/advanced_use.md).
+
 ---
 ## Limitations
 
diff --git a/docs/advanced_use.md b/docs/advanced_use.md
new file mode 100644
index 0000000..1682300
--- /dev/null
+++ b/docs/advanced_use.md
@@ -0,0 +1,296 @@
+# Advanced use scenario's: using the mappings_path
+
+## Introduction
+When working with APIs, there are often relations between resources or constraints on values.
+The property on one resource may refer to the `id` of another resource.
+The value for a certain property may have to be unique within a certain scope.
+Perhaps an endpoint path contains parameters that must match values that are defined outside the API itself.
+
+These types of relations and limitations cannot be described / modeled within the openapi document.
+To support automatic validation of API endpoints where such relations apply, OpenApiDriver supports the usage of a custom mappings file.
+
+## Taking a custom mappings file into use
+To take a custom mappings file into use, the absolute path to it has to be passed to OpenApiDriver as the `mappings_path` parameter:
+```robot framework
+*** Settings ***
+Library             OpenApiDriver
+...                 source=http://localhost:8000/openapi.json
+...                 origin=http://localhost:8000
+...                 mappings_path=${root}/tests/custom_user_mappings.py
+...
+```
+> Note: An absolute path is required.
+> In the example above, `${root}` is a global variable that holds the absolute path to the repository root.
+
+## The custom mappings file
+Just like custom Robot Framework libraries, the mappings file has to be implemented in Python.
+Since this Python file is imported by the OpenApiDriver, it has to follow a fixed format (more technically, implement a certain interface).
+The bare minimum implementation of a mappings.py file looks like this:
+```python
+from OpenApiDriver import (
+    IGNORE,
+    Dto,
+    IdDependency,
+    IdReference,
+    PathPropertiesConstraint,
+    PropertyValueConstraint,
+    UniquePropertyValueConstraint,
+)
+
+
+class MyDtoThatDoesNothing(Dto):
+    @staticmethod
+    def get_relations():
+        relations = []
+        return relations
+
+
+DTO_MAPPING = {
+    ("/myspecialendpoint", "post"): MyDtoThatDoesNothing
+}
+
+```
+There are 3 main parts in this mappings file:
+
+1. The import section.
+Here the classes needed to implement custom mappings are imported.
+This section can just be copied without changes.
+2. The section defining the mapping Dtos.
+More on this later.
+3. The `DTO_MAPPING` "constant" definition / assignment.
+
+## The DTO_MAPPING
+When a custom mappings file is used, the OpenApiDriver will attempt to import it and then import `DTO_MAPPING` from it.
+For this reason, the exact same name must be used in a custom mappings file (capitilization matters).
+
+The `DTO_MAPPING` is a dictionary with a tuple as its key and a mappings Dto as its value.
+The tuple must be in the form `("endpoint_from_the_paths_section", "method_supported_by_the_endpoint")`.
+The `endpoint_from_the_paths_section` must be exactly as found in the openapi document.
+The `method_supported_by_the_endpoint` must be one of the methods supported by the endpoint and must be in lowercase.
+
+## Dto mapping classes
+As can be seen from the import section above, a number of classes are available to deal with relations between resources and / or constraints on properties.
+Each of these classes is designed to handle a relation or constraint commonly seen in REST APIs.
+
+---
+
+To explain the different mapping classes, we'll use the following example:
+
+Imagine we have an API endpoint `/employees` where we can create (`post`) a new Employee resource.
+The Employee has a number of required properties; name, employee_number, wagegroup_id, and date_of_birth.
+
+There is also the the `/wagegroups` endpoint where a Wagegroup resource can be created.
+This Wagegroup also has a number of required properties: name and hourly rate.
+
+---
+
+### `IdReference`
+> *The value for this propery must the the `id` of another resource*
+
+To add an Employee, a `wagegroup_id` is required, the `id` of a Wagegroup resource that is already present in the system.
+
+Since a typical REST API generates this `id` for a new resource and returns that `id` as part of the `post` response, the required `wagegroup_id` can be obtained by posting a new Wagegroup. This relation can be implemented as follows:
+```python
+class EmployeeDto(Dto):
+    @staticmethod
+    def get_relations():
+        relations = [
+            IdDependency(
+                property_name="wagegroup_id",
+                get_path="/wagegroups",
+                error_code=451,
+            ),
+        ]
+        return relations
+
+DTO_MAPPING = {
+    ("/employees", "post"): EmployeeDto
+}
+```
+Notice that the `get_path` of the `IdDependency` is not named `post_path` instead.
+This is deliberate for two reasons:
+
+1. The purpose is getting an `id`
+2. If the `post` operation is not supported on the provided path, a `get` operation is performed instead.
+It is assumed that such a `get` will yield a list of resources and that each of these resources has an `id` that is valid for the desired `post` operation.
+
+Also note the `error_code` of the `IdDependency`.
+If a `post` is attempted with a value for the `wagegroup_id` that does not exist, the API should return an `error_code` response.
+This `error_code` should be described as one of the `responses` in the openapi document for the `post` operation of the `/employees` path.
+
+---
+
+### `IdDependency`
+> *This resource may not be DELETED if another resource refers to it*
+
+If an Employee has been added to the system, this Employee refers to the `id` of a Wagegroup for its required `employee_number` property.
+
+Now let's say there is also the `/wagegroups/${wagegroup_id}` endpoint that supports the `delete` operation.
+If the Wagegroup refered to the Employee would be deleted, the Employee would be left with an invalid reference for one of its required properties.
+To prevent this, an API typically returns an `error_code` when such a `delete` operation is attempted on a resource that is refered to in this fashion.
+This `error_code` should be described as one of the `responses` in the openapi document for the `delete` operation of the `/wagegroups/${wagegroup_id}` path.
+
+To verify that the specified `error_code` indeed occurs when attempting to `delete` the Wagegroup, we can implement the following dependency:
+```python
+class WagegroupDto(Dto):
+    @staticmethod
+    def get_relations():
+        relations = [
+            IdReference(
+                property_name="wagegroup_id",
+                post_path="/employees",
+                error_code=406,
+            ),
+        ]
+        return relations
+
+DTO_MAPPING = {
+    ("/wagegroups/{wagegroup_id}", "delete"): WagegroupDto
+}
+```
+
+---
+
+### `UniquePropertyValueConstraint`
+> *The value of this property must be unique within its scope*
+
+In a lot of systems, there is data that should be unique; an employee number, the email address of an employee, the domain name for the employee, etc.
+Often those values are automatically generated based on other data, but for some data, an "available value" must be chosen by hand.
+
+In our example, the required `employee_number` must be chosen from the "free" numbers.
+When a number is chosen that is already in use, the API should return the `error_code` specified in the openapi document for the operation (typically `post`, `put` and `patch`) on the endpoint.
+
+To verify that the specified `error_code` occurs when attempting to `post` an Employee with an `employee_number` that is already in use, we can implement the following dependency:
+```python
+class EmployeeDto(Dto):
+    @staticmethod
+    def get_relations():
+        relations = [
+            UniquePropertyValueConstraint(
+                property_name="employee_number",
+                value=42,
+                error_code=422,
+            ),
+        ]
+        return relations
+
+DTO_MAPPING = {
+    ("/employees", "post"): EmployeeDto,
+    ("/employees/${employee_id}", "put"): EmployeeDto,
+    ("/employees/${employee_id}", "patch"): EmployeeDto,
+}
+```
+Note how this example reuses the `EmployeeDto` to model the uniqueness constraint for all the operations (`post`, `put` and `patch`) that all relate to the same `employee_number`.
+
+---
+
+### `PropertyValueConstraint`
+> *Use one of these values for this property*
+
+The OpenApiDriver uses the `type` information in the openapi document to generate random data of the correct type to perform the operations that need it.
+While this works in many situations (e.g. a random `string` for a `name`), there can be additional restrictions to a value that cannot be specified in an openapi document.
+
+In our example, the `date_of_birth` must be a string in a specific format, e.g. 1995/03/27.
+This type of constraint can be modeled as follows:
+```python
+class EmployeeDto(Dto):
+    @staticmethod
+    def get_relations():
+        relations = [
+            PropertyValueConstraint(
+                property_name="date_of_birth",
+                values=["1995/03/27", "1980/10/02"],
+                error_code=422,
+            ),
+        ]
+        return relations
+
+DTO_MAPPING = {
+    ("/employees", "post"): EmployeeDto,
+    ("/employees/${employee_id}", "put"): EmployeeDto,
+    ("/employees/${employee_id}", "patch"): EmployeeDto,
+}
+```
+> Note: in a next release, the `PropertyValueConstraint` will be extended with an `error_value` attribute to support e.g. a scenario where the `date_of_birth` in our example must mean the Employee being created is 18 years or older.
+
+---
+
+### `PathPropertiesConstraint`
+> *Just use this for the `path`*
+
+To be able to automatically perform endpoint validations, the OpenApiDriver has to construct the `url` for the resource from the `path` as found in the openapi document.
+Often, such a `path` contains a reference to a resource id, e.g. `/employees/${employee_id}`.
+When such an `id` is needed, the OpenApiDriver tries to obtain a valid `id` by taking these steps:
+
+1. Attempt a `post` on the "parent endpoint" and extract the `id` from the response.
+In our example: perform a `post` request on the `/employees` endpoint and get the `id` from the response.
+2. If 1. fails, perform a `get` request on the `/employees` endpoint. It is assumed that this will return a list of Employee objects with an `id`.
+One item from the returned list is picked at rondom and its `id` is used.
+
+This mechanism relies on the standard REST structure and patterns.
+
+Unfortunately, this structure / pattern does not apply to every endpoint, not every path parameter refers to a resource id.
+Imagine we want to extend the API from our example with an endpoint that returns all the Employees that have their birthday at a given date:
+`/birthdays/${month}/${date}`.
+It should be clear that the OpenApiDriver won't be able to acquire a valid `month` and `date`. The `PathPropertiesConstraint` can be used in this case:
+```python
+class BirthdaysDto(Dto):
+    @staticmethod
+    def get_relations():
+        relations = [
+            PathPropertiesConstraint(path="/birthdays/03/27"),
+        ]
+        return relations
+
+DTO_MAPPING = {
+    ("/birthdays/{month}/{date}", "get"): BirthdaysDto
+}
+```
+
+---
+
+### `IGNORE`
+> *Never send this query parameter as part of a request*
+
+Some optional query parameters have a range of valid values that depend on one or more path parameters.
+Since path parameters are part of a url, they cannot be optional or empty so to extend the path parameters with optional parameters, query parameters can be used.
+
+To illustrate this, let's imagine an API where the energy label for a building can be requested: `/energylabel/${zipcode}/${home_number}`.
+Some addresses however have an address extension, e.g. 1234AB 42 <sup>2.C</sup>.
+The extension may not be limited to a fixed pattern / range and if an address has an extension, in many cases the address without an extension part is invalid.
+
+To prevent OpenApiDriver from generating invalid combinations of path and query parameters in this type of endpoint, the `IGNORE` special value can be used to ensure the related query parameter is never send in a request.
+```python
+class EnergyLabelDto(Dto):
+    @staticmethod
+    def get_parameter_relations():
+        relations = [
+            PropertyValueConstraint(
+                property_name="address_extension",
+                values=[IGNORE],
+                error_code=422,
+            ),
+        ]
+        return relations
+
+    @staticmethod
+    def get_relations(:
+        relations = [
+            PathPropertiesConstraint(path="/energy_label/1111AA/10"),
+        ]
+        return relations
+
+DTO_MAPPING = {
+    ("/energy_label/{zipcode}/{home_number}", "get"): EnergyLabelDto
+}
+```
+Note that in this example, the `get_parameter_relations()` method is implemented.
+This method works mostly the same as the `get_relations()` method but applies to headers and query parameters.
+
+---
+
+## Type annotations
+
+An additional import to support type annotations is also available: `Relation`.
+A fully typed example can be found
+[here](https://github.com/MarketSquare/robotframework-openapidriver/blob/main/tests/user_implemented/custom_user_mappings.py).
diff --git a/docs/openapidriver.html b/docs/openapidriver.html
index e1699b7..32a0015 100644
--- a/docs/openapidriver.html
+++ b/docs/openapidriver.html
@@ -6,7 +6,7 @@
 <meta http-equiv="Pragma" content="no-cache">
 <meta http-equiv="Expires" content="-1">
 <meta http-equiv="X-UA-Compatible" content="IE=edge">
-<meta content="Robot Framework 4.1.1 (Python 3.9.7 on win32)" name="Generator">
+<meta content="Robot Framework 4.1.2 (Python 3.10.0 on win32)" name="Generator">
 <link rel="icon" type="image/x-icon" href="data:image/x-icon;base64,AAABAAEAEBAAAAEAIABoBAAAFgAAACgAAAAQAAAAIAAAAAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKcAAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAAqAAAAAAAAAAAAAAAAAAAALIAAAD/AAAA4AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA4AAAAP8AAACxAAAAAAAAAKYAAAD/AAAAuwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC/AAAA/wAAAKkAAAD6AAAAzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN8AAAD/AAAA+gAAAMMAAAAAAAAAAgAAAGsAAABrAAAAawAAAGsAAABrAAAAawAAAGsAAABrAAAADAAAAAAAAADaAAAA/wAAAPoAAADDAAAAAAAAAIsAAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAANEAAAAAAAAA2gAAAP8AAAD6AAAAwwAAAAAAAAAAAAAAMgAAADIAAAAyAAAAMgAAADIAAAAyAAAAMgAAADIAAAAFAAAAAAAAANoAAAD/AAAA+gAAAMMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADaAAAA/wAAAPoAAADDAAAAAAAAADwAAAB8AAAAAAAAAGAAAABcAAAAAAAAAH8AAABKAAAAAAAAAAAAAAAAAAAA2gAAAP8AAAD6AAAAwwAAAAAAAADCAAAA/wAAACkAAADqAAAA4QAAAAAAAAD7AAAA/wAAALAAAAAGAAAAAAAAANoAAAD/AAAA+gAAAMMAAAAAAAAAIwAAAP4AAAD/AAAA/wAAAGAAAAAAAAAAAAAAAMkAAAD/AAAAigAAAAAAAADaAAAA/wAAAPoAAADDAAAAAAAAAAAAAAAIAAAAcAAAABkAAAAAAAAAAAAAAAAAAAAAAAAAEgAAAAAAAAAAAAAA2gAAAP8AAAD7AAAAywAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN4AAAD/AAAAqwAAAP8AAACvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIAAAD/AAAAsgAAAAAAAAC5AAAA/wAAAMoAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMkAAAD/AAAAvAAAAAAAAAAAAAAAAAAAAKwAAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAArQAAAAAAAAAAwAMAAIABAAAf+AAAP/wAAD/8AAAgBAAAP/wAAD/8AAA//AAAJIwAADHEAAA//AAAP/wAAB/4AACAAQAAwAMAAA==">
 <style media="all" type="text/css">
 :root {
@@ -1102,7 +1102,7 @@
 jQuery.extend({highlight:function(e,t,n,r){if(e.nodeType===3){var i=e.data.match(t);if(i){var s=document.createElement(n||"span");s.className=r||"highlight";var o=e.splitText(i.index);o.splitText(i[0].length);var u=o.cloneNode(true);s.appendChild(u);o.parentNode.replaceChild(s,o);return 1}}else if(e.nodeType===1&&e.childNodes&&!/(script|style)/i.test(e.tagName)&&!(e.tagName===n.toUpperCase()&&e.className===r)){for(var a=0;a<e.childNodes.length;a++){a+=jQuery.highlight(e.childNodes[a],t,n,r)}}return 0}});jQuery.fn.unhighlight=function(e){var t={className:"highlight",element:"span"};jQuery.extend(t,e);return this.find(t.element+"."+t.className).each(function(){var e=this.parentNode;e.replaceChild(this.firstChild,this);e.normalize()}).end()};jQuery.fn.highlight=function(e,t){var n={className:"highlight",element:"span",caseSensitive:false,wordsOnly:false};jQuery.extend(n,t);if(e.constructor===String){e=[e]}e=jQuery.grep(e,function(e,t){return e!=""});e=jQuery.map(e,function(e,t){return e.replace(/[-[\]{}()*+?.,\\^$|#\s]/g,"\\$&")});if(e.length==0){return this}var r=n.caseSensitive?"":"i";var i="("+e.join("|")+")";if(n.wordsOnly){i="\\b"+i+"\\b"}var s=new RegExp(i,r);return this.each(function(){jQuery.highlight(this,s,n.element,n.className)})}
 </script>
 <script type="text/javascript">
-libdoc = {"name": "openapidriver", "doc": "<p>Visit the <a href=\"https://github.com/MarketSquare/robotframework-openapidriver\">library page</a> for an introduction and examples.</p>\n<p>Most of the provided keywords are for internal use by the library (for example to ensure the result logs provide insight into the executed steps) but a number of them are intended to be used as <code>Test Template</code> or within the <code>Keyword</code> that serves as the <code>Test Template</code>.</p>\n<p>The following Keywords are intended to be used in Test Suites:</p>\n<ul>\n<li><code>Test Endpoint</code></li>\n<li><code>Test Invalid Url</code></li>\n<li><code>Test Unauthorized</code></li>\n</ul>", "version": "2.0.0", "generated": "2021-10-28 15:59:34", "type": "LIBRARY", "scope": "SUITE", "docFormat": "HTML", "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapidriver.py", "lineno": 119, "tags": [], "inits": [{"name": "Init", "args": [{"name": "source", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "source: str"}, {"name": "ignored_endpoints", "types": ["List[str]", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "ignored_endpoints: List[str] | None = None"}, {"name": "ignored_responses", "types": ["List[int]", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "ignored_responses: List[int] | None = None"}, {"name": "ignored_testcases", "types": ["List[typing.List[str]]", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "ignored_testcases: List[typing.List[str]] | None = None"}, {"name": "ignore_fastapi_default_422", "types": ["bool"], "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "ignore_fastapi_default_422: bool = False"}, {"name": "origin", "types": ["str"], "defaultValue": "", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "origin: str = "}, {"name": "base_path", "types": ["str"], "defaultValue": "", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "base_path: str = "}, {"name": "mappings_path", "types": ["str", "Path"], "defaultValue": "", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "mappings_path: str | Path = "}, {"name": "username", "types": ["str"], "defaultValue": "", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "username: str = "}, {"name": "password", "types": ["str"], "defaultValue": "", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "password: str = "}, {"name": "security_token", "types": ["str"], "defaultValue": "", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "security_token: str = "}, {"name": "auth", "types": ["AuthBase", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "auth: AuthBase | None = None"}, {"name": "response_validation", "types": ["ValidationLevel"], "defaultValue": "WARN", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "response_validation: ValidationLevel = WARN"}, {"name": "disable_server_validation", "types": ["bool"], "defaultValue": "True", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "disable_server_validation: bool = True"}, {"name": "require_body_for_invalid_url", "types": ["bool"], "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "require_body_for_invalid_url: bool = False"}, {"name": "invalid_property_default_response", "types": ["int"], "defaultValue": "422", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "invalid_property_default_response: int = 422"}], "doc": "<h4>source</h4>\n<p>An absolute path to an openapi.json or openapi.yaml file or an url to such a file.</p>\n<h4>ignored_endpoints</h4>\n<p>A list of endpoints that will be ignored when generating the test cases.</p>\n<h4>ignored_responses</h4>\n<p>A list of responses that will be ignored when generating the test cases.</p>\n<h4>ignored_testcases</h4>\n<p>A list of specific test cases that, if it would be generated, will be ignored. Specific test cases to ignore must be specified as a <code>List</code> of <code>endpoint</code>, <code>method</code> and <code>response</code>.</p>\n<h4>ignore_fastapi_default_422</h4>\n<p>The FastAPI framework generates an openapi.json that, by default, has a 422 response for almost every endpoint. In some cases, this response can only be triggered by request header invalidation, which is currently not supported. When testing a FastApi webserver, you can set this argument to <code>True</code></p>\n<h4>origin</h4>\n<p>The server (and port) of the target server. E.g. <code>https://localhost:7000</code></p>\n<h4>base_path</h4>\n<p>The routing between <code>origin</code> and the endpoints as found in the <code>paths</code> in the openapi document. E.g. <code>/petshop/v2</code>.</p>\n<h4>mappings_path</h4>\n<h4>username</h4>\n<p>The username to be used for Basic Authentication.</p>\n<h4>password</h4>\n<p>The password to be used for Basic Authentication.</p>\n<h4>security_token</h4>\n<p>The token to be used for token based security using the <span class=\"name\">Authorization</span> header.</p>\n<h4>auth</h4>\n<p>A <a href=\"https://docs.python-requests.org/en/latest/api/#authentication\">requests AuthBase instance</a> to be used for authentication instead of the <code>username</code> and <code>password</code>.</p>\n<h4>response_validation</h4>\n<p>By default, a <code>WARN</code> is logged when the Response received after a Request does not comply with the schema as defined in the openapi document for the given operation. The following values are supported:</p>\n<ul>\n<li><code>DISABLED</code>: All Response validation errors will be ignored</li>\n<li><code>INFO</code>: Any Response validation erros will be logged at <code>INFO</code> level</li>\n<li><code>WARN</code>: Any Response validation erros will be logged at <code>WARN</code> level</li>\n<li><code>STRICT</code>: The Test Case will fail on any Response validation errors</li>\n</ul>\n<h4>disable_server_validation</h4>\n<p>If enabled by setting this parameter to <code>True</code>, the Response validation will also include possible errors for Requests made to a server address that is not defined in the list of servers in the openapi document. This generally means that if there is a mismatch, every Test Case will raise this error. Note that <code>localhost</code> and <code>127.0.0.1</code> are not considered the same by Response validation.</p>\n<h4>require_body_for_invalid_url</h4>\n<p>When a request is made against an invalid url, this usually is because of a \"404\" request; a request for a resource that does not exist. Depending on API implementation, when a request with a missing or invalid request body is made on a non-existent resource, either a 404 or a 422 or 400 Response is normally returned. If the API being tested processes the request body before checking if the requested resource exists, set this parameter to True.</p>\n<h4>invalid_property_default_response</h4>\n<p>The default response code for requests with a JSON body that does not comply with the schema. Example: a value outside the specified range or a string value for a property defined as integer in the schema.</p>", "shortdoc": "=== source === An absolute path to an openapi.json or openapi.yaml file or an url to such a file.", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapidriver.py", "lineno": 139}], "keywords": [{"name": "Authorized Request", "args": [{"name": "url", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "url: str"}, {"name": "method", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "method: str"}, {"name": "params", "types": ["Dict[str, typing.Any]", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "params: Dict[str, typing.Any] | None = None"}, {"name": "headers", "types": ["Dict[str, typing.Any]", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "headers: Dict[str, typing.Any] | None = None"}, {"name": "json", "types": ["Dict[str, typing.Any]", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "json: Dict[str, typing.Any] | None = None"}], "doc": "", "shortdoc": "", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 1014}, {"name": "Ensure Conflict", "args": [{"name": "url", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "url: str"}, {"name": "method", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "method: str"}, {"name": "dto", "types": ["Dto"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "dto: Dto"}, {"name": "conflict_status_code", "types": ["int"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "conflict_status_code: int"}], "doc": "", "shortdoc": "", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 745}, {"name": "Ensure In Use", "args": [{"name": "url", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "url: str"}, {"name": "resource_relation", "types": ["IdReference"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "resource_relation: IdReference"}], "doc": "", "shortdoc": "", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 715}, {"name": "Get Dto Data", "args": [{"name": "schema", "types": ["Dict[str, typing.Any]"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "schema: Dict[str, typing.Any]"}, {"name": "dto", "types": ["Type[OpenApiDriver.dto_base.Dto]"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "dto: Type[OpenApiDriver.dto_base.Dto]"}, {"name": "operation_id", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "operation_id: str"}], "doc": "", "shortdoc": "", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 508}, {"name": "Get Invalidated Url", "args": [{"name": "valid_url", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "valid_url: str"}], "doc": "", "shortdoc": "", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 622}, {"name": "Get Valid Id For Endpoint", "args": [{"name": "endpoint", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "endpoint: str"}, {"name": "method", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "method: str"}], "doc": "", "shortdoc": "", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 307}, {"name": "Get Valid Url", "args": [{"name": "endpoint", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "endpoint: str"}, {"name": "method", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "method: str"}], "doc": "", "shortdoc": "", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 284}, {"name": "Test Endpoint", "args": [{"name": "endpoint", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "endpoint: str"}, {"name": "method", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "method: str"}, {"name": "status_code", "types": ["int"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "status_code: int"}], "doc": "", "shortdoc": "", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 161}, {"name": "Test Invalid Url", "args": [{"name": "endpoint", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "endpoint: str"}, {"name": "method", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "method: str"}, {"name": "expected_status_code", "types": ["int"], "defaultValue": "404", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "expected_status_code: int = 404"}], "doc": "", "shortdoc": "", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 134}, {"name": "Test Unauthorized", "args": [{"name": "endpoint", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "endpoint: str"}, {"name": "method", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "method: str"}], "doc": "", "shortdoc": "", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 124}, {"name": "Validate Resource Properties", "args": [{"name": "resource", "types": ["Dict[str, typing.Any]"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "resource: Dict[str, typing.Any]"}, {"name": "schema_properties", "types": ["Dict[str, typing.Any]"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "schema_properties: Dict[str, typing.Any]"}], "doc": "", "shortdoc": "", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 938}, {"name": "Validate Response", "args": [{"name": "endpoint", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "endpoint: str"}, {"name": "response", "types": ["Response"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "response: Response"}, {"name": "original_data", "types": ["Dict[str, typing.Any]", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "original_data: Dict[str, typing.Any] | None = None"}], "doc": "", "shortdoc": "", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 837}, {"name": "Validate Send Response", "args": [{"name": "response", "types": ["Response"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "response: Response"}, {"name": "original_data", "types": ["Dict[str, typing.Any]", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "original_data: Dict[str, typing.Any] | None = None"}], "doc": "", "shortdoc": "", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 953}], "dataTypes": {"enums": [{"name": "ValidationLevel", "type": "Enum", "doc": "<p>An enumeration.</p>", "members": [{"name": "DISABLED", "value": "DISABLED"}, {"name": "INFO", "value": "INFO"}, {"name": "WARN", "value": "WARN"}, {"name": "STRICT", "value": "STRICT"}]}], "typedDicts": []}}
+libdoc = {"name": "OpenApiDriver", "doc": "<p>Visit the <a href=\"https://github.com/MarketSquare/robotframework-openapidriver\">library page</a> for an introduction and examples.</p>\n<p>Most of the provided keywords are for internal use by the library (for example to ensure the result logs provide insight into the executed steps) but a number of them are intended to be used as <code>Test Template</code> or within the <code>Keyword</code> that serves as the <code>Test Template</code>.</p>\n<p>The following Keywords are intended to be used in Test Suites:</p>\n<ul>\n<li><code>Test Endpoint</code></li>\n<li><code>Test Invalid Url</code></li>\n<li><code>Test Unauthorized</code></li>\n</ul>", "version": "2.1.0a3", "generated": "2021-11-23 20:28:48", "type": "LIBRARY", "scope": "SUITE", "docFormat": "HTML", "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapidriver.py", "lineno": 121, "tags": [], "inits": [{"name": "Init", "args": [{"name": "source", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "source: str"}, {"name": "ignored_endpoints", "types": ["List[str]", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "ignored_endpoints: List[str] | None = None"}, {"name": "ignored_responses", "types": ["List[int]", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "ignored_responses: List[int] | None = None"}, {"name": "ignored_testcases", "types": ["List[typing.List[str]]", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "ignored_testcases: List[typing.List[str]] | None = None"}, {"name": "ignore_fastapi_default_422", "types": ["bool"], "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "ignore_fastapi_default_422: bool = False"}, {"name": "origin", "types": ["str"], "defaultValue": "", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "origin: str = "}, {"name": "base_path", "types": ["str"], "defaultValue": "", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "base_path: str = "}, {"name": "mappings_path", "types": ["str", "Path"], "defaultValue": "", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "mappings_path: str | Path = "}, {"name": "username", "types": ["str"], "defaultValue": "", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "username: str = "}, {"name": "password", "types": ["str"], "defaultValue": "", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "password: str = "}, {"name": "security_token", "types": ["str"], "defaultValue": "", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "security_token: str = "}, {"name": "auth", "types": ["AuthBase", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "auth: AuthBase | None = None"}, {"name": "response_validation", "types": ["ValidationLevel"], "defaultValue": "WARN", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "response_validation: ValidationLevel = WARN"}, {"name": "disable_server_validation", "types": ["bool"], "defaultValue": "True", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "disable_server_validation: bool = True"}, {"name": "require_body_for_invalid_url", "types": ["bool"], "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "require_body_for_invalid_url: bool = False"}, {"name": "invalid_property_default_response", "types": ["int"], "defaultValue": "422", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "invalid_property_default_response: int = 422"}], "doc": "<h4>source</h4>\n<p>An absolute path to an openapi.json or openapi.yaml file or an url to such a file.</p>\n<h4>ignored_endpoints</h4>\n<p>A list of endpoints that will be ignored when generating the test cases.</p>\n<h4>ignored_responses</h4>\n<p>A list of responses that will be ignored when generating the test cases.</p>\n<h4>ignored_testcases</h4>\n<p>A list of specific test cases that, if it would be generated, will be ignored. Specific test cases to ignore must be specified as a <code>List</code> of <code>endpoint</code>, <code>method</code> and <code>response</code>.</p>\n<h4>ignore_fastapi_default_422</h4>\n<p>The FastAPI framework generates an openapi.json that, by default, has a 422 response for almost every endpoint. In some cases, this response can only be triggered by request header invalidation, which is currently not supported. When testing a FastApi webserver, you can set this argument to <code>True</code></p>\n<h4>origin</h4>\n<p>The server (and port) of the target server. E.g. <code>https://localhost:7000</code></p>\n<h4>base_path</h4>\n<p>The routing between <code>origin</code> and the endpoints as found in the <code>paths</code> in the openapi document. E.g. <code>/petshop/v2</code>.</p>\n<h4>mappings_path</h4>\n<h4>username</h4>\n<p>The username to be used for Basic Authentication.</p>\n<h4>password</h4>\n<p>The password to be used for Basic Authentication.</p>\n<h4>security_token</h4>\n<p>The token to be used for token based security using the <span class=\"name\">Authorization</span> header.</p>\n<h4>auth</h4>\n<p>A <a href=\"https://docs.python-requests.org/en/latest/api/#authentication\">requests AuthBase instance</a> to be used for authentication instead of the <code>username</code> and <code>password</code>.</p>\n<h4>response_validation</h4>\n<p>By default, a <code>WARN</code> is logged when the Response received after a Request does not comply with the schema as defined in the openapi document for the given operation. The following values are supported:</p>\n<ul>\n<li><code>DISABLED</code>: All Response validation errors will be ignored</li>\n<li><code>INFO</code>: Any Response validation erros will be logged at <code>INFO</code> level</li>\n<li><code>WARN</code>: Any Response validation erros will be logged at <code>WARN</code> level</li>\n<li><code>STRICT</code>: The Test Case will fail on any Response validation errors</li>\n</ul>\n<h4>disable_server_validation</h4>\n<p>If enabled by setting this parameter to <code>True</code>, the Response validation will also include possible errors for Requests made to a server address that is not defined in the list of servers in the openapi document. This generally means that if there is a mismatch, every Test Case will raise this error. Note that <code>localhost</code> and <code>127.0.0.1</code> are not considered the same by Response validation.</p>\n<h4>require_body_for_invalid_url</h4>\n<p>When a request is made against an invalid url, this usually is because of a \"404\" request; a request for a resource that does not exist. Depending on API implementation, when a request with a missing or invalid request body is made on a non-existent resource, either a 404 or a 422 or 400 Response is normally returned. If the API being tested processes the request body before checking if the requested resource exists, set this parameter to True.</p>\n<h4>invalid_property_default_response</h4>\n<p>The default response code for requests with a JSON body that does not comply with the schema. Example: a value outside the specified range or a string value for a property defined as integer in the schema.</p>", "shortdoc": "=== source === An absolute path to an openapi.json or openapi.yaml file or an url to such a file.", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapidriver.py", "lineno": 141}], "keywords": [{"name": "Authorized Request", "args": [{"name": "url", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "url: str"}, {"name": "method", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "method: str"}, {"name": "params", "types": ["Dict[str, typing.Any]", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "params: Dict[str, typing.Any] | None = None"}, {"name": "headers", "types": ["Dict[str, typing.Any]", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "headers: Dict[str, typing.Any] | None = None"}, {"name": "json", "types": ["Dict[str, typing.Any]", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "json: Dict[str, typing.Any] | None = None"}], "doc": "<p>Perform a request using the security token or authentication set in the library.</p>\n<p>&gt; Note: provided username / password or auth objects take precedence over token based security</p>", "shortdoc": "Perform a request using the security token or authentication set in the library.", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 1117}, {"name": "Ensure In Use", "args": [{"name": "url", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "url: str"}, {"name": "resource_relation", "types": ["IdReference"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "resource_relation: IdReference"}], "doc": "<p>Ensure that the <span class=\"name\">id</span> of the resource referenced by the <span class=\"name\">url</span> is used by the resource defined by the <span class=\"name\">resource_relation</span>.</p>", "shortdoc": "Ensure that the `id` of the resource referenced by the `url` is used by the resource defined by the `resource_relation`.", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 805}, {"name": "Get Invalid Json Data", "args": [{"name": "data_relations", "types": ["List[typing.Union[OpenApiDriver.dto_base.IdDependency, OpenApiDriver.dto_base.IdReference, OpenApiDriver.dto_base.PathPropertiesConstraint, OpenApiDriver.dto_base.PropertyValueConstraint, OpenApiDriver.dto_base.UniquePropertyValueConstraint]]"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "data_relations: List[typing.Union[OpenApiDriver.dto_base.IdDependency, OpenApiDriver.dto_base.IdReference, OpenApiDriver.dto_base.PathPropertiesConstraint, OpenApiDriver.dto_base.PropertyValueConstraint, OpenApiDriver.dto_base.UniquePropertyValueConstraint]]"}, {"name": "schema", "types": ["Dict[str, typing.Any]"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "schema: Dict[str, typing.Any]"}, {"name": "url", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "url: str"}, {"name": "method", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "method: str"}, {"name": "dto", "types": ["Dto"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "dto: Dto"}, {"name": "status_code", "types": ["int"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "status_code: int"}], "doc": "<p>Return <span class=\"name\">json_data</span> based on the <span class=\"name\">dto</span> that will cause the provided <span class=\"name\">status_code</span> for the <span class=\"name\">method</span> operation on the <span class=\"name\">url</span>.</p>\n<p>&gt; Note: applicable UniqueProperyValueConstraint and IdReference Relations are considered before changes to <span class=\"name\">json_data</span> are made.</p>", "shortdoc": "Return `json_data` based on the `dto` that will cause the provided `status_code` for the `method` operation on the `url`.", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 698}, {"name": "Get Invalidated Url", "args": [{"name": "valid_url", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "valid_url: str"}], "doc": "<p>Return an url with all the path parameters in the <span class=\"name\">valid_url</span> replaced by a random UUID. If the <span class=\"name\">valid_url</span> does not contain any parameters, None is returned.</p>", "shortdoc": "Return an url with all the path parameters in the `valid_url` replaced by a random UUID. If the `valid_url` does not contain any parameters, None is returned.", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 673}, {"name": "Get Json Data For Dto Class", "args": [{"name": "schema", "types": ["Dict[str, typing.Any]"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "schema: Dict[str, typing.Any]"}, {"name": "dto_class", "types": ["Type[OpenApiDriver.dto_base.Dto]"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "dto_class: Type[OpenApiDriver.dto_base.Dto]"}, {"name": "operation_id", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "operation_id: str"}], "doc": "<p>Generate a valid (json-compatible) dict for all the <span class=\"name\">dto_class</span> properties.</p>", "shortdoc": "Generate a valid (json-compatible) dict for all the `dto_class` properties.", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 599}, {"name": "Get Json Data With Conflict", "args": [{"name": "url", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "url: str"}, {"name": "method", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "method: str"}, {"name": "dto", "types": ["Dto"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "dto: Dto"}, {"name": "conflict_status_code", "types": ["int"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "conflict_status_code: int"}], "doc": "<p>Return <span class=\"name\">json_data</span> based on the <span class=\"name\">UniqueProperyValueConstraint</span> that must be returned by the <span class=\"name\">get_relations</span> implementation on the <span class=\"name\">dto</span> for the given <span class=\"name\">conflict_status_code</span>.</p>", "shortdoc": "Return `json_data` based on the `UniqueProperyValueConstraint` that must be returned by the `get_relations` implementation on the `dto` for the given `conflict_status_code`.", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 839}, {"name": "Get Valid Id For Endpoint", "args": [{"name": "endpoint", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "endpoint: str"}, {"name": "method", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "method: str"}], "doc": "<p>Support keyword that returns the <span class=\"name\">id</span> for an existing resource at <span class=\"name\">endpoint</span>.</p>\n<p>To prevent resource conflicts with other test cases, a new resource is created (POST) if possible.</p>", "shortdoc": "Support keyword that returns the `id` for an existing resource at `endpoint`.", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 389}, {"name": "Get Valid Url", "args": [{"name": "endpoint", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "endpoint: str"}, {"name": "method", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "method: str"}], "doc": "<p>This keyword returns a valid url for the given <span class=\"name\">endpoint</span> and <span class=\"name\">method</span>.</p>\n<p>If the <span class=\"name\">endpoint</span> contains path parameters the Get Valid Id For Endpoint keyword will be executed to retrieve valid ids for the path parameters.</p>\n<p>&gt; Note: if valid ids cannot be retrieved within the scope of the API, the <span class=\"name\">PathPropertiesConstraint</span> Relation can be used. More information can be found [here](https://marketsquare.github.io/robotframework-openapidriver/advanced_use.md).</p>", "shortdoc": "This keyword returns a valid url for the given `endpoint` and `method`.", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 356}, {"name": "Invalidate Parameters", "args": [{"name": "params", "types": ["Dict[str, typing.Any]"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "params: Dict[str, typing.Any]"}, {"name": "headers", "types": ["Dict[str, str]"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "headers: Dict[str, str]"}, {"name": "relations", "types": ["List[typing.Union[OpenApiDriver.dto_base.IdDependency, OpenApiDriver.dto_base.IdReference, OpenApiDriver.dto_base.PathPropertiesConstraint, OpenApiDriver.dto_base.PropertyValueConstraint, OpenApiDriver.dto_base.UniquePropertyValueConstraint]]"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "relations: List[typing.Union[OpenApiDriver.dto_base.IdDependency, OpenApiDriver.dto_base.IdReference, OpenApiDriver.dto_base.PathPropertiesConstraint, OpenApiDriver.dto_base.PropertyValueConstraint, OpenApiDriver.dto_base.UniquePropertyValueConstraint]]"}, {"name": "parameters", "types": ["List[typing.Dict[str, typing.Any]]"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "parameters: List[typing.Dict[str, typing.Any]]"}, {"name": "status_code", "types": ["int"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "status_code: int"}], "doc": "<p>Returns a version of <span class=\"name\">params, headers</span> that has been modified to cause the provided <span class=\"name\">status_code</span>.</p>", "shortdoc": "Returns a version of `params, headers` that has been modified to cause the provided `status_code`.", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 742}, {"name": "Perform Validated Request", "args": [{"name": "endpoint", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "endpoint: str"}, {"name": "method", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "method: str"}, {"name": "status_code", "types": ["int"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "status_code: int"}, {"name": "url", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "url: str"}, {"name": "params", "types": ["Dict[str, typing.Any]"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "params: Dict[str, typing.Any]"}, {"name": "headers", "types": ["Dict[str, str]"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "headers: Dict[str, str]"}, {"name": "json_data", "types": ["Dict[str, typing.Any]"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "json_data: Dict[str, typing.Any]"}, {"name": "original_data", "types": ["Dict[str, typing.Any]", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "original_data: Dict[str, typing.Any] | None = None"}], "doc": "<p>This keyword first calls the Authorized Request keyword, then the Validate Response keyword and finally validates is, for <span class=\"name\">DELETE</span> operations, whether the target resource was indeed deleted (OK response) or not (error responses).</p>", "shortdoc": "This keyword first calls the Authorized Request keyword, then the Validate Response keyword and finally validates is, for `DELETE` operations, whether the target resource was indeed deleted (OK response) or not (error responses).", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 291}, {"name": "Test Endpoint", "args": [{"name": "endpoint", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "endpoint: str"}, {"name": "method", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "method: str"}, {"name": "status_code", "types": ["int"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "status_code: int"}], "doc": "<p>Validate that performing the <span class=\"name\">method</span> operation on <span class=\"name\">endpoint</span> results in a <span class=\"name\">status_code</span> response.</p>\n<p>This is the main keyword to be used in the <span class=\"name\">Test Template</span> keyword when using the OpenApiDriver.</p>\n<p>The keyword calls other keywords to generate the neccesary data to perform the desired operation and validate the response against the openapi document.</p>", "shortdoc": "Validate that performing the `method` operation on `endpoint` results in a `status_code` response.", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 194}, {"name": "Test Invalid Url", "args": [{"name": "endpoint", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "endpoint: str"}, {"name": "method", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "method: str"}, {"name": "expected_status_code", "types": ["int"], "defaultValue": "404", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "expected_status_code: int = 404"}], "doc": "<p>Perform a request for the provided 'endpoint' and 'method' where the url for the <span class=\"name\">endpoint</span> is invalidated.</p>\n<p>This keyword will be <span class=\"name\">SKIPPED</span> if the endpoint contains no parts that can be invalidated.</p>\n<p>The optional <span class=\"name\">expected_status_code</span> parameter (default: 404) can be set to the expected status code for APIs that do not return a 404 on invalid urls.</p>\n<p>&gt; Note: Depending on API design, the url may be validated before or after validation of headers, query parameters and / or (json) body. By default, no parameters are send with the request. The <span class=\"name\">require_body_for_invalid_url</span> parameter can be set to <span class=\"name\">True</span> if needed.</p>", "shortdoc": "Perform a request for the provided 'endpoint' and 'method' where the url for the `endpoint` is invalidated.", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 152}, {"name": "Test Unauthorized", "args": [{"name": "endpoint", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "endpoint: str"}, {"name": "method", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "method: str"}], "doc": "<p>Perform a request for <span class=\"name\">method</span> on the <span class=\"name\">endpoint</span>, with no authorization.</p>\n<p>This keyword only passes if the response code is 401: Unauthorized.</p>\n<p>Any authorization parameters used to initialize the library are ignored for this request. &gt; Note: No headers or (json) body are send with the request. For security reasons, the authorization validation should be checked first.</p>", "shortdoc": "Perform a request for `method` on the `endpoint`, with no authorization.", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 132}, {"name": "Validate Resource Properties", "args": [{"name": "resource", "types": ["Dict[str, typing.Any]"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "resource: Dict[str, typing.Any]"}, {"name": "schema_properties", "types": ["Dict[str, typing.Any]"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "schema_properties: Dict[str, typing.Any]"}], "doc": "<p>Validate that the 'resource' does not contain any properties that are not defined in the <span class=\"name\">schema_properties</span>.</p>", "shortdoc": "Validate that the 'resource' does not contain any properties that are not defined in the `schema_properties`.", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 1027}, {"name": "Validate Response", "args": [{"name": "endpoint", "types": ["str"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "endpoint: str"}, {"name": "response", "types": ["Response"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "response: Response"}, {"name": "original_data", "types": ["Dict[str, typing.Any]", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "original_data: Dict[str, typing.Any] | None = None"}], "doc": "<p>Validate the <span class=\"name\">response</span> by performing the following validations:</p>\n<ul>\n<li>validate the <span class=\"name\">response</span> against the openapi schema for the <span class=\"name\">endpoint</span></li>\n<li>validate that the response does not contain extra properties</li>\n<li>validate that a href, if present, refers to the correct resource</li>\n<li>validate that the value for a property that is in the response is equal to the property value that was send</li>\n<li>validate that no <span class=\"name\">original_data</span> is preserved when performing a PUT operation</li>\n<li>validate that a PATCH operation only updates the provided properties</li>\n</ul>", "shortdoc": "Validate the `response` by performing the following validations: - validate the `response` against the openapi schema for the `endpoint` - validate that the response does not contain extra properties - validate that a href, if present, refers to the correct resource - validate that the value for a property that is in the response is equal to     the property value that was send - validate that no `original_data` is preserved when performing a PUT operation - validate that a PATCH operation only updates the provided properties", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 917}, {"name": "Validate Send Response", "args": [{"name": "response", "types": ["Response"], "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "response: Response"}, {"name": "original_data", "types": ["Dict[str, typing.Any]", "None"], "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "original_data: Dict[str, typing.Any] | None = None"}], "doc": "<p>Validate that each property that was send that is in the response has the value that was send. In case a PATCH request, validate that only the properties that were patched have changed and that other properties are still at their pre-patch values.</p>", "shortdoc": "Validate that each property that was send that is in the response has the value that was send. In case a PATCH request, validate that only the properties that were patched have changed and that other properties are still at their pre-patch values.", "tags": [], "source": "C:\\GitHub\\robotframework-openapidriver\\src\\OpenApiDriver\\openapi_executors.py", "lineno": 1046}], "dataTypes": {"enums": [{"name": "ValidationLevel", "type": "Enum", "doc": "<p>The available levels for the response_validation parameter.</p>", "members": [{"name": "DISABLED", "value": "DISABLED"}, {"name": "INFO", "value": "INFO"}, {"name": "WARN", "value": "WARN"}, {"name": "STRICT", "value": "STRICT"}]}], "typedDicts": []}}
 </script>
 <title></title>
 </head>
diff --git a/poetry.lock b/poetry.lock
index ed0bcac..9cd0bca 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -1,3 +1,20 @@
+[[package]]
+name = "anyio"
+version = "3.3.4"
+description = "High level compatibility layer for multiple asynchronous event loop implementations"
+category = "dev"
+optional = false
+python-versions = ">=3.6.2"
+
+[package.dependencies]
+idna = ">=2.8"
+sniffio = ">=1.1"
+
+[package.extras]
+doc = ["sphinx-rtd-theme", "sphinx-autodoc-typehints (>=1.2.0)"]
+test = ["coverage[toml] (>=4.5)", "hypothesis (>=4.0)", "pytest (>=6.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (<0.15)", "mock (>=4)", "uvloop (>=0.15)"]
+trio = ["trio (>=0.16)"]
+
 [[package]]
 name = "asgiref"
 version = "3.4.1"
@@ -11,7 +28,7 @@ tests = ["pytest", "pytest-asyncio", "mypy (>=0.800)"]
 
 [[package]]
 name = "astroid"
-version = "2.8.0"
+version = "2.8.6"
 description = "An abstract syntax tree for Python with inference support."
 category = "dev"
 optional = false
@@ -20,7 +37,7 @@ python-versions = "~=3.6"
 [package.dependencies]
 lazy-object-proxy = ">=1.4.0"
 typing-extensions = {version = ">=3.10", markers = "python_version < \"3.10\""}
-wrapt = ">=1.11,<1.13"
+wrapt = ">=1.11,<1.14"
 
 [[package]]
 name = "attrs"
@@ -38,7 +55,7 @@ tests_no_zope = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>
 
 [[package]]
 name = "black"
-version = "21.9b0"
+version = "21.11b1"
 description = "The uncompromising code formatter."
 category = "dev"
 optional = false
@@ -49,7 +66,7 @@ click = ">=7.1.2"
 mypy-extensions = ">=0.4.3"
 pathspec = ">=0.9.0,<1"
 platformdirs = ">=2"
-regex = ">=2020.1.8"
+regex = ">=2021.4.4"
 tomli = ">=0.2.6,<2.0.0"
 typing-extensions = [
     {version = ">=3.10.0.0", markers = "python_version < \"3.10\""},
@@ -58,14 +75,14 @@ typing-extensions = [
 
 [package.extras]
 colorama = ["colorama (>=0.4.3)"]
-d = ["aiohttp (>=3.6.0)", "aiohttp-cors (>=0.4.0)"]
+d = ["aiohttp (>=3.7.4)"]
 jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"]
-python2 = ["typed-ast (>=1.4.2)"]
+python2 = ["typed-ast (>=1.4.3)"]
 uvloop = ["uvloop (>=0.15.2)"]
 
 [[package]]
 name = "certifi"
-version = "2021.5.30"
+version = "2021.10.8"
 description = "Python package for providing Mozilla's CA Bundle."
 category = "main"
 optional = false
@@ -81,7 +98,7 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
 
 [[package]]
 name = "charset-normalizer"
-version = "2.0.6"
+version = "2.0.7"
 description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet."
 category = "main"
 optional = false
@@ -92,7 +109,7 @@ unicode_backport = ["unicodedata2"]
 
 [[package]]
 name = "click"
-version = "8.0.1"
+version = "8.0.3"
 description = "Composable command line interface toolkit"
 category = "dev"
 optional = false
@@ -133,7 +150,7 @@ python-versions = ">= 2.7, != 3.0.*, != 3.1.*, != 3.2.*, != 3.3.*, != 3.4.*"
 
 [[package]]
 name = "docutils"
-version = "0.17.1"
+version = "0.18"
 description = "Docutils -- Python Documentation Utilities"
 category = "main"
 optional = false
@@ -141,21 +158,21 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
 
 [[package]]
 name = "fastapi"
-version = "0.68.1"
+version = "0.70.0"
 description = "FastAPI framework, high performance, easy to learn, fast to code, ready for production"
 category = "dev"
 optional = false
-python-versions = ">=3.6"
+python-versions = ">=3.6.1"
 
 [package.dependencies]
 pydantic = ">=1.6.2,<1.7 || >1.7,<1.7.1 || >1.7.1,<1.7.2 || >1.7.2,<1.7.3 || >1.7.3,<1.8 || >1.8,<1.8.1 || >1.8.1,<2.0.0"
-starlette = "0.14.2"
+starlette = "0.16.0"
 
 [package.extras]
-all = ["requests (>=2.24.0,<3.0.0)", "aiofiles (>=0.5.0,<0.6.0)", "jinja2 (>=2.11.2,<3.0.0)", "python-multipart (>=0.0.5,<0.0.6)", "itsdangerous (>=1.1.0,<2.0.0)", "pyyaml (>=5.3.1,<6.0.0)", "graphene (>=2.1.8,<3.0.0)", "ujson (>=4.0.1,<5.0.0)", "orjson (>=3.2.1,<4.0.0)", "email_validator (>=1.1.1,<2.0.0)", "uvicorn[standard] (>=0.12.0,<0.14.0)", "async_exit_stack (>=1.0.1,<2.0.0)", "async_generator (>=1.10,<2.0.0)"]
-dev = ["python-jose[cryptography] (>=3.3.0,<4.0.0)", "passlib[bcrypt] (>=1.7.2,<2.0.0)", "autoflake (>=1.3.1,<2.0.0)", "flake8 (>=3.8.3,<4.0.0)", "uvicorn[standard] (>=0.12.0,<0.14.0)", "graphene (>=2.1.8,<3.0.0)"]
-doc = ["mkdocs (>=1.1.2,<2.0.0)", "mkdocs-material (>=7.1.9,<8.0.0)", "mdx-include (>=1.4.1,<2.0.0)", "mkdocs-markdownextradata-plugin (>=0.1.7,<0.2.0)", "typer-cli (>=0.0.12,<0.0.13)", "pyyaml (>=5.3.1,<6.0.0)"]
-test = ["pytest (>=6.2.4,<7.0.0)", "pytest-cov (>=2.12.0,<3.0.0)", "pytest-asyncio (>=0.14.0,<0.15.0)", "mypy (==0.812)", "flake8 (>=3.8.3,<4.0.0)", "black (==20.8b1)", "isort (>=5.0.6,<6.0.0)", "requests (>=2.24.0,<3.0.0)", "httpx (>=0.14.0,<0.15.0)", "email_validator (>=1.1.1,<2.0.0)", "sqlalchemy (>=1.3.18,<1.4.0)", "peewee (>=3.13.3,<4.0.0)", "databases[sqlite] (>=0.3.2,<0.4.0)", "orjson (>=3.2.1,<4.0.0)", "ujson (>=4.0.1,<5.0.0)", "async_exit_stack (>=1.0.1,<2.0.0)", "async_generator (>=1.10,<2.0.0)", "python-multipart (>=0.0.5,<0.0.6)", "aiofiles (>=0.5.0,<0.6.0)", "flask (>=1.1.2,<2.0.0)"]
+all = ["requests (>=2.24.0,<3.0.0)", "jinja2 (>=2.11.2,<4.0.0)", "python-multipart (>=0.0.5,<0.0.6)", "itsdangerous (>=1.1.0,<3.0.0)", "pyyaml (>=5.3.1,<6.0.0)", "ujson (>=4.0.1,<5.0.0)", "orjson (>=3.2.1,<4.0.0)", "email_validator (>=1.1.1,<2.0.0)", "uvicorn[standard] (>=0.12.0,<0.16.0)"]
+dev = ["python-jose[cryptography] (>=3.3.0,<4.0.0)", "passlib[bcrypt] (>=1.7.2,<2.0.0)", "autoflake (>=1.4.0,<2.0.0)", "flake8 (>=3.8.3,<4.0.0)", "uvicorn[standard] (>=0.12.0,<0.16.0)"]
+doc = ["mkdocs (>=1.1.2,<2.0.0)", "mkdocs-material (>=7.1.9,<8.0.0)", "mdx-include (>=1.4.1,<2.0.0)", "mkdocs-markdownextradata-plugin (>=0.1.7,<0.3.0)", "typer-cli (>=0.0.12,<0.0.13)", "pyyaml (>=5.3.1,<6.0.0)"]
+test = ["pytest (>=6.2.4,<7.0.0)", "pytest-cov (>=2.12.0,<4.0.0)", "mypy (==0.910)", "flake8 (>=3.8.3,<4.0.0)", "black (==21.9b0)", "isort (>=5.0.6,<6.0.0)", "requests (>=2.24.0,<3.0.0)", "httpx (>=0.14.0,<0.19.0)", "email_validator (>=1.1.1,<2.0.0)", "sqlalchemy (>=1.3.18,<1.5.0)", "peewee (>=3.13.3,<4.0.0)", "databases[sqlite] (>=0.3.2,<0.6.0)", "orjson (>=3.2.1,<4.0.0)", "ujson (>=4.0.1,<5.0.0)", "python-multipart (>=0.0.5,<0.0.6)", "flask (>=1.1.2,<3.0.0)", "anyio[trio] (>=3.2.1,<4.0.0)", "types-ujson (==0.1.1)", "types-orjson (==3.6.0)", "types-dataclasses (==0.1.7)"]
 
 [[package]]
 name = "h11"
@@ -167,12 +184,27 @@ python-versions = ">=3.6"
 
 [[package]]
 name = "idna"
-version = "3.2"
+version = "3.3"
 description = "Internationalized Domain Names in Applications (IDNA)"
 category = "main"
 optional = false
 python-versions = ">=3.5"
 
+[[package]]
+name = "importlib-resources"
+version = "5.4.0"
+description = "Read resources from Python packages"
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+zipp = {version = ">=3.1.0", markers = "python_version < \"3.10\""}
+
+[package.extras]
+docs = ["sphinx", "jaraco.packaging (>=8.2)", "rst.linker (>=1.9)"]
+testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-flake8", "pytest-cov", "pytest-enabler (>=1.0.1)", "pytest-black (>=0.3.7)", "pytest-mypy"]
+
 [[package]]
 name = "invoke"
 version = "1.6.0"
@@ -194,7 +226,7 @@ six = "*"
 
 [[package]]
 name = "isort"
-version = "5.9.3"
+version = "5.10.1"
 description = "A Python utility / library to sort Python imports."
 category = "dev"
 optional = false
@@ -208,20 +240,20 @@ plugins = ["setuptools"]
 
 [[package]]
 name = "jsonschema"
-version = "3.2.0"
+version = "4.2.1"
 description = "An implementation of JSON Schema validation for Python"
 category = "main"
 optional = false
-python-versions = "*"
+python-versions = ">=3.7"
 
 [package.dependencies]
 attrs = ">=17.4.0"
-pyrsistent = ">=0.14.0"
-six = ">=1.11.0"
+importlib-resources = {version = ">=1.4.0", markers = "python_version < \"3.9\""}
+pyrsistent = ">=0.14.0,<0.17.0 || >0.17.0,<0.17.1 || >0.17.1,<0.17.2 || >0.17.2"
 
 [package.extras]
-format = ["idna", "jsonpointer (>1.13)", "rfc3987", "strict-rfc3339", "webcolors"]
-format_nongpl = ["idna", "jsonpointer (>1.13)", "webcolors", "rfc3986-validator (>0.1.0)", "rfc3339-validator"]
+format = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3987", "uri-template", "webcolors (>=1.11)"]
+format_nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3986-validator (>0.1.0)", "uri-template", "webcolors (>=1.11)"]
 
 [[package]]
 name = "lazy-object-proxy"
@@ -241,7 +273,7 @@ python-versions = "*"
 
 [[package]]
 name = "more-itertools"
-version = "8.10.0"
+version = "8.11.0"
 description = "More routines for operating on iterables, beyond itertools"
 category = "main"
 optional = false
@@ -351,7 +383,7 @@ python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7"
 
 [[package]]
 name = "platformdirs"
-version = "2.3.0"
+version = "2.4.0"
 description = "A small Python module for determining appropriate platform-specific dirs, e.g. a \"user data dir\"."
 category = "dev"
 optional = false
@@ -434,15 +466,15 @@ python-versions = ">=3.6"
 
 [[package]]
 name = "pyyaml"
-version = "5.4.1"
+version = "6.0"
 description = "YAML parser and emitter for Python"
 category = "main"
 optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*"
+python-versions = ">=3.6"
 
 [[package]]
 name = "regex"
-version = "2021.8.28"
+version = "2021.11.10"
 description = "Alternative regular expression module, to replace re."
 category = "dev"
 optional = false
@@ -468,7 +500,7 @@ use_chardet_on_py3 = ["chardet (>=3.0.2,<5)"]
 
 [[package]]
 name = "robotframework"
-version = "4.1.1"
+version = "4.1.2"
 description = "Generic automation framework for acceptance testing and robotic process automation (RPA)"
 category = "main"
 optional = false
@@ -511,7 +543,7 @@ robotframework = ">=3.2"
 
 [[package]]
 name = "robotframework-tidy"
-version = "1.5.1"
+version = "1.6.2"
 description = "Code autoformatter for Robot Framework"
 category = "dev"
 optional = false
@@ -526,7 +558,7 @@ toml = ">=0.10.2"
 
 [[package]]
 name = "ruamel.yaml"
-version = "0.17.16"
+version = "0.17.17"
 description = "ruamel.yaml is a YAML parser/emitter that supports roundtrip preservation of comments, seq/map flow style, and map key order"
 category = "main"
 optional = false
@@ -563,16 +595,27 @@ category = "main"
 optional = false
 python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*"
 
+[[package]]
+name = "sniffio"
+version = "1.2.0"
+description = "Sniff out which async library your code is running under"
+category = "dev"
+optional = false
+python-versions = ">=3.5"
+
 [[package]]
 name = "starlette"
-version = "0.14.2"
+version = "0.16.0"
 description = "The little ASGI library that shines."
 category = "dev"
 optional = false
 python-versions = ">=3.6"
 
+[package.dependencies]
+anyio = ">=3.0.0,<4"
+
 [package.extras]
-full = ["aiofiles", "graphene", "itsdangerous", "jinja2", "python-multipart", "pyyaml", "requests"]
+full = ["itsdangerous", "jinja2", "python-multipart", "pyyaml", "requests", "graphene"]
 
 [[package]]
 name = "toml"
@@ -584,7 +627,7 @@ python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*"
 
 [[package]]
 name = "tomli"
-version = "1.2.1"
+version = "1.2.2"
 description = "A lil' TOML parser"
 category = "dev"
 optional = false
@@ -592,7 +635,7 @@ python-versions = ">=3.6"
 
 [[package]]
 name = "types-requests"
-version = "2.25.6"
+version = "2.26.0"
 description = "Typing stubs for requests"
 category = "dev"
 optional = false
@@ -600,15 +643,15 @@ python-versions = "*"
 
 [[package]]
 name = "typing-extensions"
-version = "3.10.0.2"
-description = "Backported and Experimental Type Hints for Python 3.5+"
+version = "4.0.0"
+description = "Backported and Experimental Type Hints for Python 3.6+"
 category = "dev"
 optional = false
-python-versions = "*"
+python-versions = ">=3.6"
 
 [[package]]
 name = "urllib3"
-version = "1.26.6"
+version = "1.26.7"
 description = "HTTP library with thread-safe connection pooling, file post, and more."
 category = "main"
 optional = false
@@ -637,7 +680,7 @@ standard = ["websockets (>=9.1)", "httptools (>=0.2.0,<0.3.0)", "watchgod (>=0.6
 
 [[package]]
 name = "werkzeug"
-version = "2.0.1"
+version = "2.0.2"
 description = "The comprehensive WSGI web application library."
 category = "main"
 optional = false
@@ -648,11 +691,23 @@ watchdog = ["watchdog"]
 
 [[package]]
 name = "wrapt"
-version = "1.12.1"
+version = "1.13.3"
 description = "Module for decorators, wrappers and monkey patching."
 category = "dev"
 optional = false
-python-versions = "*"
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7"
+
+[[package]]
+name = "zipp"
+version = "3.6.0"
+description = "Backport of pathlib-compatible object wrapper for zip files"
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.extras]
+docs = ["sphinx", "jaraco.packaging (>=8.2)", "rst.linker (>=1.9)"]
+testing = ["pytest (>=4.6)", "pytest-checkdocs (>=2.4)", "pytest-flake8", "pytest-cov", "pytest-enabler (>=1.0.1)", "jaraco.itertools", "func-timeout", "pytest-black (>=0.3.7)", "pytest-mypy"]
 
 [metadata]
 lock-version = "1.1"
@@ -660,37 +715,41 @@ python-versions = "^3.8"
 content-hash = "a69a3e7dd1e36c45a0599d2b906c24333a604a9aa032c877966fbbfa4689fcb6"
 
 [metadata.files]
+anyio = [
+    {file = "anyio-3.3.4-py3-none-any.whl", hash = "sha256:4fd09a25ab7fa01d34512b7249e366cd10358cdafc95022c7ff8c8f8a5026d66"},
+    {file = "anyio-3.3.4.tar.gz", hash = "sha256:67da67b5b21f96b9d3d65daa6ea99f5d5282cb09f50eb4456f8fb51dffefc3ff"},
+]
 asgiref = [
     {file = "asgiref-3.4.1-py3-none-any.whl", hash = "sha256:ffc141aa908e6f175673e7b1b3b7af4fdb0ecb738fc5c8b88f69f055c2415214"},
     {file = "asgiref-3.4.1.tar.gz", hash = "sha256:4ef1ab46b484e3c706329cedeff284a5d40824200638503f5768edb6de7d58e9"},
 ]
 astroid = [
-    {file = "astroid-2.8.0-py3-none-any.whl", hash = "sha256:dcc06f6165f415220013801642bd6c9808a02967070919c4b746c6864c205471"},
-    {file = "astroid-2.8.0.tar.gz", hash = "sha256:fe81f80c0b35264acb5653302ffbd935d394f1775c5e4487df745bf9c2442708"},
+    {file = "astroid-2.8.6-py3-none-any.whl", hash = "sha256:cd8326b424c971e7d87678609cf6275d22028afd37d6ac59c16d47f1245882f6"},
+    {file = "astroid-2.8.6.tar.gz", hash = "sha256:5f6f75e45f15290e73b56f9dfde95b4bf96382284cde406ef4203e928335a495"},
 ]
 attrs = [
     {file = "attrs-21.2.0-py2.py3-none-any.whl", hash = "sha256:149e90d6d8ac20db7a955ad60cf0e6881a3f20d37096140088356da6c716b0b1"},
     {file = "attrs-21.2.0.tar.gz", hash = "sha256:ef6aaac3ca6cd92904cdd0d83f629a15f18053ec84e6432106f7a4d04ae4f5fb"},
 ]
 black = [
-    {file = "black-21.9b0-py3-none-any.whl", hash = "sha256:380f1b5da05e5a1429225676655dddb96f5ae8c75bdf91e53d798871b902a115"},
-    {file = "black-21.9b0.tar.gz", hash = "sha256:7de4cfc7eb6b710de325712d40125689101d21d25283eed7e9998722cf10eb91"},
+    {file = "black-21.11b1-py3-none-any.whl", hash = "sha256:802c6c30b637b28645b7fde282ed2569c0cd777dbe493a41b6a03c1d903f99ac"},
+    {file = "black-21.11b1.tar.gz", hash = "sha256:a042adbb18b3262faad5aff4e834ff186bb893f95ba3a8013f09de1e5569def2"},
 ]
 certifi = [
-    {file = "certifi-2021.5.30-py2.py3-none-any.whl", hash = "sha256:50b1e4f8446b06f41be7dd6338db18e0990601dce795c2b1686458aa7e8fa7d8"},
-    {file = "certifi-2021.5.30.tar.gz", hash = "sha256:2bbf76fd432960138b3ef6dda3dde0544f27cbf8546c458e60baf371917ba9ee"},
+    {file = "certifi-2021.10.8-py2.py3-none-any.whl", hash = "sha256:d62a0163eb4c2344ac042ab2bdf75399a71a2d8c7d47eac2e2ee91b9d6339569"},
+    {file = "certifi-2021.10.8.tar.gz", hash = "sha256:78884e7c1d4b00ce3cea67b44566851c4343c120abd683433ce934a68ea58872"},
 ]
 chardet = [
     {file = "chardet-4.0.0-py2.py3-none-any.whl", hash = "sha256:f864054d66fd9118f2e67044ac8981a54775ec5b67aed0441892edb553d21da5"},
     {file = "chardet-4.0.0.tar.gz", hash = "sha256:0d6f53a15db4120f2b08c94f11e7d93d2c911ee118b6b30a04ec3ee8310179fa"},
 ]
 charset-normalizer = [
-    {file = "charset-normalizer-2.0.6.tar.gz", hash = "sha256:5ec46d183433dcbd0ab716f2d7f29d8dee50505b3fdb40c6b985c7c4f5a3591f"},
-    {file = "charset_normalizer-2.0.6-py3-none-any.whl", hash = "sha256:5d209c0a931f215cee683b6445e2d77677e7e75e159f78def0db09d68fafcaa6"},
+    {file = "charset-normalizer-2.0.7.tar.gz", hash = "sha256:e019de665e2bcf9c2b64e2e5aa025fa991da8720daa3c1138cadd2fd1856aed0"},
+    {file = "charset_normalizer-2.0.7-py3-none-any.whl", hash = "sha256:f7af805c321bfa1ce6714c51f254e0d5bb5e5834039bc17db7ebe3a4cec9492b"},
 ]
 click = [
-    {file = "click-8.0.1-py3-none-any.whl", hash = "sha256:fba402a4a47334742d782209a7c79bc448911afe1149d07bdabdf480b3e2f4b6"},
-    {file = "click-8.0.1.tar.gz", hash = "sha256:8c04c11192119b1ef78ea049e0a6f0463e4c48ef00a30160c704337586f3ad7a"},
+    {file = "click-8.0.3-py3-none-any.whl", hash = "sha256:353f466495adaeb40b6b5f592f9f91cb22372351c84caeb068132442a4518ef3"},
+    {file = "click-8.0.3.tar.gz", hash = "sha256:410e932b050f5eed773c4cda94de75971c89cdb3155a72a0831139a79e5ecb5b"},
 ]
 colorama = [
     {file = "colorama-0.4.4-py2.py3-none-any.whl", hash = "sha256:9f47eda37229f68eee03b24b9748937c7dc3868f906e8ba69fbcbdd3bc5dc3e2"},
@@ -756,20 +815,24 @@ dictpath = [
     {file = "dictpath-0.1.3.tar.gz", hash = "sha256:751cde3b76b176d25f961b90c423a11a4d5ede9bd09ab0d64a85abb738c190d8"},
 ]
 docutils = [
-    {file = "docutils-0.17.1-py2.py3-none-any.whl", hash = "sha256:cf316c8370a737a022b72b56874f6602acf974a37a9fba42ec2876387549fc61"},
-    {file = "docutils-0.17.1.tar.gz", hash = "sha256:686577d2e4c32380bb50cbb22f575ed742d58168cee37e99117a854bcd88f125"},
+    {file = "docutils-0.18-py2.py3-none-any.whl", hash = "sha256:a31688b2ea858517fa54293e5d5df06fbb875fb1f7e4c64529271b77781ca8fc"},
+    {file = "docutils-0.18.tar.gz", hash = "sha256:c1d5dab2b11d16397406a282e53953fe495a46d69ae329f55aa98a5c4e3c5fbb"},
 ]
 fastapi = [
-    {file = "fastapi-0.68.1-py3-none-any.whl", hash = "sha256:94d2820906c36b9b8303796fb7271337ec89c74223229e3cfcf056b5a7d59e23"},
-    {file = "fastapi-0.68.1.tar.gz", hash = "sha256:644bb815bae326575c4b2842469fb83053a4b974b82fa792ff9283d17fbbd99d"},
+    {file = "fastapi-0.70.0-py3-none-any.whl", hash = "sha256:a36d5f2fad931aa3575c07a3472c784e81f3e664e3bb5c8b9c88d0ec1104f59c"},
+    {file = "fastapi-0.70.0.tar.gz", hash = "sha256:66da43cfe5185ea1df99552acffd201f1832c6b364e0f4136c0a99f933466ced"},
 ]
 h11 = [
     {file = "h11-0.12.0-py3-none-any.whl", hash = "sha256:36a3cb8c0a032f56e2da7084577878a035d3b61d104230d4bd49c0c6b555a9c6"},
     {file = "h11-0.12.0.tar.gz", hash = "sha256:47222cb6067e4a307d535814917cd98fd0a57b6788ce715755fa2b6c28b56042"},
 ]
 idna = [
-    {file = "idna-3.2-py3-none-any.whl", hash = "sha256:14475042e284991034cb48e06f6851428fb14c4dc953acd9be9a5e95c7b6dd7a"},
-    {file = "idna-3.2.tar.gz", hash = "sha256:467fbad99067910785144ce333826c71fb0e63a425657295239737f7ecd125f3"},
+    {file = "idna-3.3-py3-none-any.whl", hash = "sha256:84d9dd047ffa80596e0f246e2eab0b391788b0503584e8945f2368256d2735ff"},
+    {file = "idna-3.3.tar.gz", hash = "sha256:9d643ff0a55b762d5cdb124b8eaa99c66322e2157b69160bc32796e824360e6d"},
+]
+importlib-resources = [
+    {file = "importlib_resources-5.4.0-py3-none-any.whl", hash = "sha256:33a95faed5fc19b4bc16b29a6eeae248a3fe69dd55d4d229d2b480e23eeaad45"},
+    {file = "importlib_resources-5.4.0.tar.gz", hash = "sha256:d756e2f85dd4de2ba89be0b21dba2a3bbec2e871a42a3a16719258a11f87506b"},
 ]
 invoke = [
     {file = "invoke-1.6.0-py2-none-any.whl", hash = "sha256:e6c9917a1e3e73e7ea91fdf82d5f151ccfe85bf30cc65cdb892444c02dbb5f74"},
@@ -781,12 +844,12 @@ isodate = [
     {file = "isodate-0.6.0.tar.gz", hash = "sha256:2e364a3d5759479cdb2d37cce6b9376ea504db2ff90252a2e5b7cc89cc9ff2d8"},
 ]
 isort = [
-    {file = "isort-5.9.3-py3-none-any.whl", hash = "sha256:e17d6e2b81095c9db0a03a8025a957f334d6ea30b26f9ec70805411e5c7c81f2"},
-    {file = "isort-5.9.3.tar.gz", hash = "sha256:9c2ea1e62d871267b78307fe511c0838ba0da28698c5732d54e2790bf3ba9899"},
+    {file = "isort-5.10.1-py3-none-any.whl", hash = "sha256:6f62d78e2f89b4500b080fe3a81690850cd254227f27f75c3a0c491a1f351ba7"},
+    {file = "isort-5.10.1.tar.gz", hash = "sha256:e8443a5e7a020e9d7f97f1d7d9cd17c88bcb3bc7e218bf9cf5095fe550be2951"},
 ]
 jsonschema = [
-    {file = "jsonschema-3.2.0-py2.py3-none-any.whl", hash = "sha256:4e5b3cf8216f577bee9ce139cbe72eca3ea4f292ec60928ff24758ce626cd163"},
-    {file = "jsonschema-3.2.0.tar.gz", hash = "sha256:c8a85b28d377cc7737e46e2d9f2b4f44ee3c0e1deac6bf46ddefc7187d30797a"},
+    {file = "jsonschema-4.2.1-py3-none-any.whl", hash = "sha256:2a0f162822a64d95287990481b45d82f096e99721c86534f48201b64ebca6e8c"},
+    {file = "jsonschema-4.2.1.tar.gz", hash = "sha256:390713469ae64b8a58698bb3cbc3859abe6925b565a973f87323ef21b09a27a8"},
 ]
 lazy-object-proxy = [
     {file = "lazy-object-proxy-1.6.0.tar.gz", hash = "sha256:489000d368377571c6f982fba6497f2aa13c6d1facc40660963da62f5c379726"},
@@ -817,8 +880,8 @@ mccabe = [
     {file = "mccabe-0.6.1.tar.gz", hash = "sha256:dd8d182285a0fe56bace7f45b5e7d1a6ebcbf524e8f3bd87eb0f125271b8831f"},
 ]
 more-itertools = [
-    {file = "more-itertools-8.10.0.tar.gz", hash = "sha256:1debcabeb1df793814859d64a81ad7cb10504c24349368ccf214c664c474f41f"},
-    {file = "more_itertools-8.10.0-py3-none-any.whl", hash = "sha256:56ddac45541718ba332db05f464bebfb0768110111affd27f66e0051f276fa43"},
+    {file = "more-itertools-8.11.0.tar.gz", hash = "sha256:0a2fd25d343c08d7e7212071820e7e7ea2f41d8fb45d6bc8a00cd6ce3b7aab88"},
+    {file = "more_itertools-8.11.0-py3-none-any.whl", hash = "sha256:88afff98d83d08fe5e4049b81e2b54c06ebb6b3871a600040865c7a592061cbb"},
 ]
 mypy = [
     {file = "mypy-0.910-cp35-cp35m-macosx_10_9_x86_64.whl", hash = "sha256:a155d80ea6cee511a3694b108c4494a39f42de11ee4e61e72bc424c490e46457"},
@@ -872,8 +935,8 @@ pathspec = [
     {file = "pathspec-0.9.0.tar.gz", hash = "sha256:e564499435a2673d586f6b2130bb5b95f04a3ba06f81b8f895b651a3c76aabb1"},
 ]
 platformdirs = [
-    {file = "platformdirs-2.3.0-py3-none-any.whl", hash = "sha256:8003ac87717ae2c7ee1ea5a84a1a61e87f3fbd16eb5aadba194ea30a9019f648"},
-    {file = "platformdirs-2.3.0.tar.gz", hash = "sha256:15b056538719b1c94bdaccb29e5f81879c7f7f0f4a153f46086d155dffcd4f0f"},
+    {file = "platformdirs-2.4.0-py3-none-any.whl", hash = "sha256:8868bbe3c3c80d42f20156f22e7131d2fb321f5bc86a2a345375c6481a67021d"},
+    {file = "platformdirs-2.4.0.tar.gz", hash = "sha256:367a5e80b3d04d2428ffa76d33f124cf11e8fff2acdaa9b43d545f5c7d661ef2"},
 ]
 prance = [
     {file = "prance-0.21.8.0-py3-none-any.whl", hash = "sha256:51ec41d10b317bf5d4e74782a7f7f0c0488c6042433b5b4fde2a988cd069d235"},
@@ -935,86 +998,98 @@ pyrsistent = [
     {file = "pyrsistent-0.18.0.tar.gz", hash = "sha256:773c781216f8c2900b42a7b638d5b517bb134ae1acbebe4d1e8f1f41ea60eb4b"},
 ]
 pyyaml = [
-    {file = "PyYAML-5.4.1-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:3b2b1824fe7112845700f815ff6a489360226a5609b96ec2190a45e62a9fc922"},
-    {file = "PyYAML-5.4.1-cp27-cp27m-win32.whl", hash = "sha256:129def1b7c1bf22faffd67b8f3724645203b79d8f4cc81f674654d9902cb4393"},
-    {file = "PyYAML-5.4.1-cp27-cp27m-win_amd64.whl", hash = "sha256:4465124ef1b18d9ace298060f4eccc64b0850899ac4ac53294547536533800c8"},
-    {file = "PyYAML-5.4.1-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:bb4191dfc9306777bc594117aee052446b3fa88737cd13b7188d0e7aa8162185"},
-    {file = "PyYAML-5.4.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:6c78645d400265a062508ae399b60b8c167bf003db364ecb26dcab2bda048253"},
-    {file = "PyYAML-5.4.1-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:4e0583d24c881e14342eaf4ec5fbc97f934b999a6828693a99157fde912540cc"},
-    {file = "PyYAML-5.4.1-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:72a01f726a9c7851ca9bfad6fd09ca4e090a023c00945ea05ba1638c09dc3347"},
-    {file = "PyYAML-5.4.1-cp36-cp36m-manylinux2014_s390x.whl", hash = "sha256:895f61ef02e8fed38159bb70f7e100e00f471eae2bc838cd0f4ebb21e28f8541"},
-    {file = "PyYAML-5.4.1-cp36-cp36m-win32.whl", hash = "sha256:3bd0e463264cf257d1ffd2e40223b197271046d09dadf73a0fe82b9c1fc385a5"},
-    {file = "PyYAML-5.4.1-cp36-cp36m-win_amd64.whl", hash = "sha256:e4fac90784481d221a8e4b1162afa7c47ed953be40d31ab4629ae917510051df"},
-    {file = "PyYAML-5.4.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:5accb17103e43963b80e6f837831f38d314a0495500067cb25afab2e8d7a4018"},
-    {file = "PyYAML-5.4.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:e1d4970ea66be07ae37a3c2e48b5ec63f7ba6804bdddfdbd3cfd954d25a82e63"},
-    {file = "PyYAML-5.4.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:cb333c16912324fd5f769fff6bc5de372e9e7a202247b48870bc251ed40239aa"},
-    {file = "PyYAML-5.4.1-cp37-cp37m-manylinux2014_s390x.whl", hash = "sha256:fe69978f3f768926cfa37b867e3843918e012cf83f680806599ddce33c2c68b0"},
-    {file = "PyYAML-5.4.1-cp37-cp37m-win32.whl", hash = "sha256:dd5de0646207f053eb0d6c74ae45ba98c3395a571a2891858e87df7c9b9bd51b"},
-    {file = "PyYAML-5.4.1-cp37-cp37m-win_amd64.whl", hash = "sha256:08682f6b72c722394747bddaf0aa62277e02557c0fd1c42cb853016a38f8dedf"},
-    {file = "PyYAML-5.4.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:d2d9808ea7b4af864f35ea216be506ecec180628aced0704e34aca0b040ffe46"},
-    {file = "PyYAML-5.4.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:8c1be557ee92a20f184922c7b6424e8ab6691788e6d86137c5d93c1a6ec1b8fb"},
-    {file = "PyYAML-5.4.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:fd7f6999a8070df521b6384004ef42833b9bd62cfee11a09bda1079b4b704247"},
-    {file = "PyYAML-5.4.1-cp38-cp38-manylinux2014_s390x.whl", hash = "sha256:bfb51918d4ff3d77c1c856a9699f8492c612cde32fd3bcd344af9be34999bfdc"},
-    {file = "PyYAML-5.4.1-cp38-cp38-win32.whl", hash = "sha256:fa5ae20527d8e831e8230cbffd9f8fe952815b2b7dae6ffec25318803a7528fc"},
-    {file = "PyYAML-5.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:0f5f5786c0e09baddcd8b4b45f20a7b5d61a7e7e99846e3c799b05c7c53fa696"},
-    {file = "PyYAML-5.4.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:294db365efa064d00b8d1ef65d8ea2c3426ac366c0c4368d930bf1c5fb497f77"},
-    {file = "PyYAML-5.4.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:74c1485f7707cf707a7aef42ef6322b8f97921bd89be2ab6317fd782c2d53183"},
-    {file = "PyYAML-5.4.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:d483ad4e639292c90170eb6f7783ad19490e7a8defb3e46f97dfe4bacae89122"},
-    {file = "PyYAML-5.4.1-cp39-cp39-manylinux2014_s390x.whl", hash = "sha256:fdc842473cd33f45ff6bce46aea678a54e3d21f1b61a7750ce3c498eedfe25d6"},
-    {file = "PyYAML-5.4.1-cp39-cp39-win32.whl", hash = "sha256:49d4cdd9065b9b6e206d0595fee27a96b5dd22618e7520c33204a4a3239d5b10"},
-    {file = "PyYAML-5.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:c20cfa2d49991c8b4147af39859b167664f2ad4561704ee74c1de03318e898db"},
-    {file = "PyYAML-5.4.1.tar.gz", hash = "sha256:607774cbba28732bfa802b54baa7484215f530991055bb562efbed5b2f20a45e"},
+    {file = "PyYAML-6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d4db7c7aef085872ef65a8fd7d6d09a14ae91f691dec3e87ee5ee0539d516f53"},
+    {file = "PyYAML-6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9df7ed3b3d2e0ecfe09e14741b857df43adb5a3ddadc919a2d94fbdf78fea53c"},
+    {file = "PyYAML-6.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77f396e6ef4c73fdc33a9157446466f1cff553d979bd00ecb64385760c6babdc"},
+    {file = "PyYAML-6.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a80a78046a72361de73f8f395f1f1e49f956c6be882eed58505a15f3e430962b"},
+    {file = "PyYAML-6.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f84fbc98b019fef2ee9a1cb3ce93e3187a6df0b2538a651bfb890254ba9f90b5"},
+    {file = "PyYAML-6.0-cp310-cp310-win32.whl", hash = "sha256:2cd5df3de48857ed0544b34e2d40e9fac445930039f3cfe4bcc592a1f836d513"},
+    {file = "PyYAML-6.0-cp310-cp310-win_amd64.whl", hash = "sha256:daf496c58a8c52083df09b80c860005194014c3698698d1a57cbcfa182142a3a"},
+    {file = "PyYAML-6.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:897b80890765f037df3403d22bab41627ca8811ae55e9a722fd0392850ec4d86"},
+    {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50602afada6d6cbfad699b0c7bb50d5ccffa7e46a3d738092afddc1f9758427f"},
+    {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:48c346915c114f5fdb3ead70312bd042a953a8ce5c7106d5bfb1a5254e47da92"},
+    {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:98c4d36e99714e55cfbaaee6dd5badbc9a1ec339ebfc3b1f52e293aee6bb71a4"},
+    {file = "PyYAML-6.0-cp36-cp36m-win32.whl", hash = "sha256:0283c35a6a9fbf047493e3a0ce8d79ef5030852c51e9d911a27badfde0605293"},
+    {file = "PyYAML-6.0-cp36-cp36m-win_amd64.whl", hash = "sha256:07751360502caac1c067a8132d150cf3d61339af5691fe9e87803040dbc5db57"},
+    {file = "PyYAML-6.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:819b3830a1543db06c4d4b865e70ded25be52a2e0631ccd2f6a47a2822f2fd7c"},
+    {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:473f9edb243cb1935ab5a084eb238d842fb8f404ed2193a915d1784b5a6b5fc0"},
+    {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0ce82d761c532fe4ec3f87fc45688bdd3a4c1dc5e0b4a19814b9009a29baefd4"},
+    {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:231710d57adfd809ef5d34183b8ed1eeae3f76459c18fb4a0b373ad56bedcdd9"},
+    {file = "PyYAML-6.0-cp37-cp37m-win32.whl", hash = "sha256:c5687b8d43cf58545ade1fe3e055f70eac7a5a1a0bf42824308d868289a95737"},
+    {file = "PyYAML-6.0-cp37-cp37m-win_amd64.whl", hash = "sha256:d15a181d1ecd0d4270dc32edb46f7cb7733c7c508857278d3d378d14d606db2d"},
+    {file = "PyYAML-6.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0b4624f379dab24d3725ffde76559cff63d9ec94e1736b556dacdfebe5ab6d4b"},
+    {file = "PyYAML-6.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:213c60cd50106436cc818accf5baa1aba61c0189ff610f64f4a3e8c6726218ba"},
+    {file = "PyYAML-6.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9fa600030013c4de8165339db93d182b9431076eb98eb40ee068700c9c813e34"},
+    {file = "PyYAML-6.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:277a0ef2981ca40581a47093e9e2d13b3f1fbbeffae064c1d21bfceba2030287"},
+    {file = "PyYAML-6.0-cp38-cp38-win32.whl", hash = "sha256:d4eccecf9adf6fbcc6861a38015c2a64f38b9d94838ac1810a9023a0609e1b78"},
+    {file = "PyYAML-6.0-cp38-cp38-win_amd64.whl", hash = "sha256:1e4747bc279b4f613a09eb64bba2ba602d8a6664c6ce6396a4d0cd413a50ce07"},
+    {file = "PyYAML-6.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:055d937d65826939cb044fc8c9b08889e8c743fdc6a32b33e2390f66013e449b"},
+    {file = "PyYAML-6.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e61ceaab6f49fb8bdfaa0f92c4b57bcfbea54c09277b1b4f7ac376bfb7a7c174"},
+    {file = "PyYAML-6.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d67d839ede4ed1b28a4e8909735fc992a923cdb84e618544973d7dfc71540803"},
+    {file = "PyYAML-6.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cba8c411ef271aa037d7357a2bc8f9ee8b58b9965831d9e51baf703280dc73d3"},
+    {file = "PyYAML-6.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:40527857252b61eacd1d9af500c3337ba8deb8fc298940291486c465c8b46ec0"},
+    {file = "PyYAML-6.0-cp39-cp39-win32.whl", hash = "sha256:b5b9eccad747aabaaffbc6064800670f0c297e52c12754eb1d976c57e4f74dcb"},
+    {file = "PyYAML-6.0-cp39-cp39-win_amd64.whl", hash = "sha256:b3d267842bf12586ba6c734f89d1f5b871df0273157918b0ccefa29deb05c21c"},
+    {file = "PyYAML-6.0.tar.gz", hash = "sha256:68fb519c14306fec9720a2a5b45bc9f0c8d1b9c72adf45c37baedfcd949c35a2"},
 ]
 regex = [
-    {file = "regex-2021.8.28-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9d05ad5367c90814099000442b2125535e9d77581855b9bee8780f1b41f2b1a2"},
-    {file = "regex-2021.8.28-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3bf1bc02bc421047bfec3343729c4bbbea42605bcfd6d6bfe2c07ade8b12d2a"},
-    {file = "regex-2021.8.28-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5f6a808044faae658f546dd5f525e921de9fa409de7a5570865467f03a626fc0"},
-    {file = "regex-2021.8.28-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:a617593aeacc7a691cc4af4a4410031654f2909053bd8c8e7db837f179a630eb"},
-    {file = "regex-2021.8.28-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:79aef6b5cd41feff359acaf98e040844613ff5298d0d19c455b3d9ae0bc8c35a"},
-    {file = "regex-2021.8.28-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:0fc1f8f06977c2d4f5e3d3f0d4a08089be783973fc6b6e278bde01f0544ff308"},
-    {file = "regex-2021.8.28-cp310-cp310-win32.whl", hash = "sha256:6eebf512aa90751d5ef6a7c2ac9d60113f32e86e5687326a50d7686e309f66ed"},
-    {file = "regex-2021.8.28-cp310-cp310-win_amd64.whl", hash = "sha256:ac88856a8cbccfc14f1b2d0b829af354cc1743cb375e7f04251ae73b2af6adf8"},
-    {file = "regex-2021.8.28-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:c206587c83e795d417ed3adc8453a791f6d36b67c81416676cad053b4104152c"},
-    {file = "regex-2021.8.28-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8690ed94481f219a7a967c118abaf71ccc440f69acd583cab721b90eeedb77c"},
-    {file = "regex-2021.8.28-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:328a1fad67445550b982caa2a2a850da5989fd6595e858f02d04636e7f8b0b13"},
-    {file = "regex-2021.8.28-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c7cb4c512d2d3b0870e00fbbac2f291d4b4bf2634d59a31176a87afe2777c6f0"},
-    {file = "regex-2021.8.28-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66256b6391c057305e5ae9209941ef63c33a476b73772ca967d4a2df70520ec1"},
-    {file = "regex-2021.8.28-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:8e44769068d33e0ea6ccdf4b84d80c5afffe5207aa4d1881a629cf0ef3ec398f"},
-    {file = "regex-2021.8.28-cp36-cp36m-win32.whl", hash = "sha256:08d74bfaa4c7731b8dac0a992c63673a2782758f7cfad34cf9c1b9184f911354"},
-    {file = "regex-2021.8.28-cp36-cp36m-win_amd64.whl", hash = "sha256:abb48494d88e8a82601af905143e0de838c776c1241d92021e9256d5515b3645"},
-    {file = "regex-2021.8.28-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b4c220a1fe0d2c622493b0a1fd48f8f991998fb447d3cd368033a4b86cf1127a"},
-    {file = "regex-2021.8.28-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4a332404baa6665b54e5d283b4262f41f2103c255897084ec8f5487ce7b9e8e"},
-    {file = "regex-2021.8.28-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c61dcc1cf9fd165127a2853e2c31eb4fb961a4f26b394ac9fe5669c7a6592892"},
-    {file = "regex-2021.8.28-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:ee329d0387b5b41a5dddbb6243a21cb7896587a651bebb957e2d2bb8b63c0791"},
-    {file = "regex-2021.8.28-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f60667673ff9c249709160529ab39667d1ae9fd38634e006bec95611f632e759"},
-    {file = "regex-2021.8.28-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:b844fb09bd9936ed158ff9df0ab601e2045b316b17aa8b931857365ea8586906"},
-    {file = "regex-2021.8.28-cp37-cp37m-win32.whl", hash = "sha256:4cde065ab33bcaab774d84096fae266d9301d1a2f5519d7bd58fc55274afbf7a"},
-    {file = "regex-2021.8.28-cp37-cp37m-win_amd64.whl", hash = "sha256:1413b5022ed6ac0d504ba425ef02549a57d0f4276de58e3ab7e82437892704fc"},
-    {file = "regex-2021.8.28-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:ed4b50355b066796dacdd1cf538f2ce57275d001838f9b132fab80b75e8c84dd"},
-    {file = "regex-2021.8.28-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28fc475f560d8f67cc8767b94db4c9440210f6958495aeae70fac8faec631797"},
-    {file = "regex-2021.8.28-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bdc178caebd0f338d57ae445ef8e9b737ddf8fbc3ea187603f65aec5b041248f"},
-    {file = "regex-2021.8.28-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:999ad08220467b6ad4bd3dd34e65329dd5d0df9b31e47106105e407954965256"},
-    {file = "regex-2021.8.28-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:808ee5834e06f57978da3e003ad9d6292de69d2bf6263662a1a8ae30788e080b"},
-    {file = "regex-2021.8.28-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:d5111d4c843d80202e62b4fdbb4920db1dcee4f9366d6b03294f45ed7b18b42e"},
-    {file = "regex-2021.8.28-cp38-cp38-win32.whl", hash = "sha256:473858730ef6d6ff7f7d5f19452184cd0caa062a20047f6d6f3e135a4648865d"},
-    {file = "regex-2021.8.28-cp38-cp38-win_amd64.whl", hash = "sha256:31a99a4796bf5aefc8351e98507b09e1b09115574f7c9dbb9cf2111f7220d2e2"},
-    {file = "regex-2021.8.28-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:04f6b9749e335bb0d2f68c707f23bb1773c3fb6ecd10edf0f04df12a8920d468"},
-    {file = "regex-2021.8.28-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b006628fe43aa69259ec04ca258d88ed19b64791693df59c422b607b6ece8bb"},
-    {file = "regex-2021.8.28-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:121f4b3185feaade3f85f70294aef3f777199e9b5c0c0245c774ae884b110a2d"},
-    {file = "regex-2021.8.28-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:a577a21de2ef8059b58f79ff76a4da81c45a75fe0bfb09bc8b7bb4293fa18983"},
-    {file = "regex-2021.8.28-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1743345e30917e8c574f273f51679c294effba6ad372db1967852f12c76759d8"},
-    {file = "regex-2021.8.28-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:e1e8406b895aba6caa63d9fd1b6b1700d7e4825f78ccb1e5260551d168db38ed"},
-    {file = "regex-2021.8.28-cp39-cp39-win32.whl", hash = "sha256:ed283ab3a01d8b53de3a05bfdf4473ae24e43caee7dcb5584e86f3f3e5ab4374"},
-    {file = "regex-2021.8.28-cp39-cp39-win_amd64.whl", hash = "sha256:610b690b406653c84b7cb6091facb3033500ee81089867ee7d59e675f9ca2b73"},
-    {file = "regex-2021.8.28.tar.gz", hash = "sha256:f585cbbeecb35f35609edccb95efd95a3e35824cd7752b586503f7e6087303f1"},
+    {file = "regex-2021.11.10-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9345b6f7ee578bad8e475129ed40123d265464c4cfead6c261fd60fc9de00bcf"},
+    {file = "regex-2021.11.10-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:416c5f1a188c91e3eb41e9c8787288e707f7d2ebe66e0a6563af280d9b68478f"},
+    {file = "regex-2021.11.10-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e0538c43565ee6e703d3a7c3bdfe4037a5209250e8502c98f20fea6f5fdf2965"},
+    {file = "regex-2021.11.10-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7ee1227cf08b6716c85504aebc49ac827eb88fcc6e51564f010f11a406c0a667"},
+    {file = "regex-2021.11.10-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6650f16365f1924d6014d2ea770bde8555b4a39dc9576abb95e3cd1ff0263b36"},
+    {file = "regex-2021.11.10-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:30ab804ea73972049b7a2a5c62d97687d69b5a60a67adca07eb73a0ddbc9e29f"},
+    {file = "regex-2021.11.10-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:68a067c11463de2a37157930d8b153005085e42bcb7ad9ca562d77ba7d1404e0"},
+    {file = "regex-2021.11.10-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:162abfd74e88001d20cb73ceaffbfe601469923e875caf9118333b1a4aaafdc4"},
+    {file = "regex-2021.11.10-cp310-cp310-win32.whl", hash = "sha256:98ba568e8ae26beb726aeea2273053c717641933836568c2a0278a84987b2a1a"},
+    {file = "regex-2021.11.10-cp310-cp310-win_amd64.whl", hash = "sha256:780b48456a0f0ba4d390e8b5f7c661fdd218934388cde1a974010a965e200e12"},
+    {file = "regex-2021.11.10-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:dba70f30fd81f8ce6d32ddeef37d91c8948e5d5a4c63242d16a2b2df8143aafc"},
+    {file = "regex-2021.11.10-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1f54b9b4b6c53369f40028d2dd07a8c374583417ee6ec0ea304e710a20f80a0"},
+    {file = "regex-2021.11.10-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fbb9dc00e39f3e6c0ef48edee202f9520dafb233e8b51b06b8428cfcb92abd30"},
+    {file = "regex-2021.11.10-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:666abff54e474d28ff42756d94544cdfd42e2ee97065857413b72e8a2d6a6345"},
+    {file = "regex-2021.11.10-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5537f71b6d646f7f5f340562ec4c77b6e1c915f8baae822ea0b7e46c1f09b733"},
+    {file = "regex-2021.11.10-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed2e07c6a26ed4bea91b897ee2b0835c21716d9a469a96c3e878dc5f8c55bb23"},
+    {file = "regex-2021.11.10-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ca5f18a75e1256ce07494e245cdb146f5a9267d3c702ebf9b65c7f8bd843431e"},
+    {file = "regex-2021.11.10-cp36-cp36m-win32.whl", hash = "sha256:93a5051fcf5fad72de73b96f07d30bc29665697fb8ecdfbc474f3452c78adcf4"},
+    {file = "regex-2021.11.10-cp36-cp36m-win_amd64.whl", hash = "sha256:b483c9d00a565633c87abd0aaf27eb5016de23fed952e054ecc19ce32f6a9e7e"},
+    {file = "regex-2021.11.10-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:fff55f3ce50a3ff63ec8e2a8d3dd924f1941b250b0aac3d3d42b687eeff07a8e"},
+    {file = "regex-2021.11.10-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e32d2a2b02ccbef10145df9135751abea1f9f076e67a4e261b05f24b94219e36"},
+    {file = "regex-2021.11.10-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:53db2c6be8a2710b359bfd3d3aa17ba38f8aa72a82309a12ae99d3c0c3dcd74d"},
+    {file = "regex-2021.11.10-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2207ae4f64ad3af399e2d30dde66f0b36ae5c3129b52885f1bffc2f05ec505c8"},
+    {file = "regex-2021.11.10-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d5ca078bb666c4a9d1287a379fe617a6dccd18c3e8a7e6c7e1eb8974330c626a"},
+    {file = "regex-2021.11.10-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dd33eb9bdcfbabab3459c9ee651d94c842bc8a05fabc95edf4ee0c15a072495e"},
+    {file = "regex-2021.11.10-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:05b7d6d7e64efe309972adab77fc2af8907bb93217ec60aa9fe12a0dad35874f"},
+    {file = "regex-2021.11.10-cp37-cp37m-win32.whl", hash = "sha256:e71255ba42567d34a13c03968736c5d39bb4a97ce98188fafb27ce981115beec"},
+    {file = "regex-2021.11.10-cp37-cp37m-win_amd64.whl", hash = "sha256:07856afef5ffcc052e7eccf3213317fbb94e4a5cd8177a2caa69c980657b3cb4"},
+    {file = "regex-2021.11.10-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:ba05430e819e58544e840a68b03b28b6d328aff2e41579037e8bab7653b37d83"},
+    {file = "regex-2021.11.10-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7f301b11b9d214f83ddaf689181051e7f48905568b0c7017c04c06dfd065e244"},
+    {file = "regex-2021.11.10-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aaa4e0705ef2b73dd8e36eeb4c868f80f8393f5f4d855e94025ce7ad8525f50"},
+    {file = "regex-2021.11.10-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:788aef3549f1924d5c38263104dae7395bf020a42776d5ec5ea2b0d3d85d6646"},
+    {file = "regex-2021.11.10-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f8af619e3be812a2059b212064ea7a640aff0568d972cd1b9e920837469eb3cb"},
+    {file = "regex-2021.11.10-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85bfa6a5413be0ee6c5c4a663668a2cad2cbecdee367630d097d7823041bdeec"},
+    {file = "regex-2021.11.10-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f23222527b307970e383433daec128d769ff778d9b29343fb3496472dc20dabe"},
+    {file = "regex-2021.11.10-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:da1a90c1ddb7531b1d5ff1e171b4ee61f6345119be7351104b67ff413843fe94"},
+    {file = "regex-2021.11.10-cp38-cp38-win32.whl", hash = "sha256:0617383e2fe465732af4509e61648b77cbe3aee68b6ac8c0b6fe934db90be5cc"},
+    {file = "regex-2021.11.10-cp38-cp38-win_amd64.whl", hash = "sha256:a3feefd5e95871872673b08636f96b61ebef62971eab044f5124fb4dea39919d"},
+    {file = "regex-2021.11.10-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f7f325be2804246a75a4f45c72d4ce80d2443ab815063cdf70ee8fb2ca59ee1b"},
+    {file = "regex-2021.11.10-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:537ca6a3586931b16a85ac38c08cc48f10fc870a5b25e51794c74df843e9966d"},
+    {file = "regex-2021.11.10-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eef2afb0fd1747f33f1ee3e209bce1ed582d1896b240ccc5e2697e3275f037c7"},
+    {file = "regex-2021.11.10-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:432bd15d40ed835a51617521d60d0125867f7b88acf653e4ed994a1f8e4995dc"},
+    {file = "regex-2021.11.10-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b43c2b8a330a490daaef5a47ab114935002b13b3f9dc5da56d5322ff218eeadb"},
+    {file = "regex-2021.11.10-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:962b9a917dd7ceacbe5cd424556914cb0d636001e393b43dc886ba31d2a1e449"},
+    {file = "regex-2021.11.10-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fa8c626d6441e2d04b6ee703ef2d1e17608ad44c7cb75258c09dd42bacdfc64b"},
+    {file = "regex-2021.11.10-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:3c5fb32cc6077abad3bbf0323067636d93307c9fa93e072771cf9a64d1c0f3ef"},
+    {file = "regex-2021.11.10-cp39-cp39-win32.whl", hash = "sha256:3b5df18db1fccd66de15aa59c41e4f853b5df7550723d26aa6cb7f40e5d9da5a"},
+    {file = "regex-2021.11.10-cp39-cp39-win_amd64.whl", hash = "sha256:83ee89483672b11f8952b158640d0c0ff02dc43d9cb1b70c1564b49abe92ce29"},
+    {file = "regex-2021.11.10.tar.gz", hash = "sha256:f341ee2df0999bfdf7a95e448075effe0db212a59387de1a70690e4acb03d4c6"},
 ]
 requests = [
     {file = "requests-2.26.0-py2.py3-none-any.whl", hash = "sha256:6c1246513ecd5ecd4528a0906f910e8f0f9c6b8ec72030dc9fd154dc1a6efd24"},
     {file = "requests-2.26.0.tar.gz", hash = "sha256:b8aa58f8cf793ffd8782d3d8cb19e66ef36f7aba4353eec859e74678b01b07a7"},
 ]
 robotframework = [
-    {file = "robotframework-4.1.1-py2.py3-none-any.whl", hash = "sha256:5a805410b7ee44dc6537a2b937e315b03c76ba178a46865cf1d649a036a44cb5"},
-    {file = "robotframework-4.1.1.zip", hash = "sha256:663f84c177b2fa9b3b782939e31637a057a33f3a4b29067812f1259b7f4bad35"},
+    {file = "robotframework-4.1.2-py2.py3-none-any.whl", hash = "sha256:6441c774f274ae022a184165287d967a7c1bb0c5f96ff0005f0468f4c979fb2b"},
+    {file = "robotframework-4.1.2.zip", hash = "sha256:7ea2454b847cfcb211e2906743c5c4a868ab096ab4ce1547ab102d91fb224443"},
 ]
 robotframework-datadriver = [
     {file = "robotframework-datadriver-1.5.0.tar.gz", hash = "sha256:67e14bf8d7c4d370ecaca35879cbf786c3f30382d3ceaf50c6ed81820e8166cf"},
@@ -1029,12 +1104,12 @@ robotframework-stacktrace = [
     {file = "robotframework_stacktrace-0.4.1-py3-none-any.whl", hash = "sha256:018d7a55b99733e64e3cc0b134771b61a47de61de23609ed35c7bf0a53e9290e"},
 ]
 robotframework-tidy = [
-    {file = "robotframework-tidy-1.5.1.tar.gz", hash = "sha256:4dffbd592fbddc5abd5ce1207221a6f82f43c7ade4b5528c007822866d36bd0e"},
-    {file = "robotframework_tidy-1.5.1-py3-none-any.whl", hash = "sha256:601186e09273bc986b62f8f054e2513e2b8faa1ac23f8ace5c8a128636674ca4"},
+    {file = "robotframework-tidy-1.6.2.tar.gz", hash = "sha256:f851c7e0e473820a2e82bdfd322b0d72c7e25043e5a58af48da636af9d23f2db"},
+    {file = "robotframework_tidy-1.6.2-py3-none-any.whl", hash = "sha256:61b82ff7cc4ada4a5a69f560326b194917c7e6a31ab1929210b5ad01c0014a82"},
 ]
 "ruamel.yaml" = [
-    {file = "ruamel.yaml-0.17.16-py3-none-any.whl", hash = "sha256:ea21da1198c4b41b8e7a259301cc9710d3b972bf8ba52f06218478e6802dd1f1"},
-    {file = "ruamel.yaml-0.17.16.tar.gz", hash = "sha256:1a771fc92d3823682b7f0893ad56cb5a5c87c48e62b5399d6f42c8759a583b33"},
+    {file = "ruamel.yaml-0.17.17-py3-none-any.whl", hash = "sha256:9af3ec5d7f8065582f3aa841305465025d0afd26c5fb54e15b964e11838fc74f"},
+    {file = "ruamel.yaml-0.17.17.tar.gz", hash = "sha256:9751de4cbb57d4bfbf8fc394e125ed4a2f170fbff3dc3d78abf50be85924f8be"},
 ]
 "ruamel.yaml.clib" = [
     {file = "ruamel.yaml.clib-0.2.6-cp35-cp35m-macosx_10_6_intel.whl", hash = "sha256:cfdb9389d888c5b74af297e51ce357b800dd844898af9d4a547ffc143fa56751"},
@@ -1067,39 +1142,95 @@ six = [
     {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"},
     {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"},
 ]
+sniffio = [
+    {file = "sniffio-1.2.0-py3-none-any.whl", hash = "sha256:471b71698eac1c2112a40ce2752bb2f4a4814c22a54a3eed3676bc0f5ca9f663"},
+    {file = "sniffio-1.2.0.tar.gz", hash = "sha256:c4666eecec1d3f50960c6bdf61ab7bc350648da6c126e3cf6898d8cd4ddcd3de"},
+]
 starlette = [
-    {file = "starlette-0.14.2-py3-none-any.whl", hash = "sha256:3c8e48e52736b3161e34c9f0e8153b4f32ec5d8995a3ee1d59410d92f75162ed"},
-    {file = "starlette-0.14.2.tar.gz", hash = "sha256:7d49f4a27f8742262ef1470608c59ddbc66baf37c148e938c7038e6bc7a998aa"},
+    {file = "starlette-0.16.0-py3-none-any.whl", hash = "sha256:38eb24bf705a2c317e15868e384c1b8a12ca396e5a3c3a003db7e667c43f939f"},
+    {file = "starlette-0.16.0.tar.gz", hash = "sha256:e1904b5d0007aee24bdd3c43994be9b3b729f4f58e740200de1d623f8c3a8870"},
 ]
 toml = [
     {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"},
     {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"},
 ]
 tomli = [
-    {file = "tomli-1.2.1-py3-none-any.whl", hash = "sha256:8dd0e9524d6f386271a36b41dbf6c57d8e32fd96fd22b6584679dc569d20899f"},
-    {file = "tomli-1.2.1.tar.gz", hash = "sha256:a5b75cb6f3968abb47af1b40c1819dc519ea82bcc065776a866e8d74c5ca9442"},
+    {file = "tomli-1.2.2-py3-none-any.whl", hash = "sha256:f04066f68f5554911363063a30b108d2b5a5b1a010aa8b6132af78489fe3aade"},
+    {file = "tomli-1.2.2.tar.gz", hash = "sha256:c6ce0015eb38820eaf32b5db832dbc26deb3dd427bd5f6556cf0acac2c214fee"},
 ]
 types-requests = [
-    {file = "types-requests-2.25.6.tar.gz", hash = "sha256:e21541c0f55c066c491a639309159556dd8c5833e49fcde929c4c47bdb0002ee"},
-    {file = "types_requests-2.25.6-py3-none-any.whl", hash = "sha256:a5a305b43ea57bf64d6731f89816946a405b591eff6de28d4c0fd58422cee779"},
+    {file = "types-requests-2.26.0.tar.gz", hash = "sha256:df5ec8c34b413a42ebb38e4f96bdeb68090b875bdfcc5138dc82989c95445883"},
+    {file = "types_requests-2.26.0-py3-none-any.whl", hash = "sha256:809b5dcd3c408ac39d11d593835b6aff32420b3e7ddb79c7f3e823330f040466"},
 ]
 typing-extensions = [
-    {file = "typing_extensions-3.10.0.2-py2-none-any.whl", hash = "sha256:d8226d10bc02a29bcc81df19a26e56a9647f8b0a6d4a83924139f4a8b01f17b7"},
-    {file = "typing_extensions-3.10.0.2-py3-none-any.whl", hash = "sha256:f1d25edafde516b146ecd0613dabcc61409817af4766fbbcfb8d1ad4ec441a34"},
-    {file = "typing_extensions-3.10.0.2.tar.gz", hash = "sha256:49f75d16ff11f1cd258e1b988ccff82a3ca5570217d7ad8c5f48205dd99a677e"},
+    {file = "typing_extensions-4.0.0-py3-none-any.whl", hash = "sha256:829704698b22e13ec9eaf959122315eabb370b0884400e9818334d8b677023d9"},
 ]
 urllib3 = [
-    {file = "urllib3-1.26.6-py2.py3-none-any.whl", hash = "sha256:39fb8672126159acb139a7718dd10806104dec1e2f0f6c88aab05d17df10c8d4"},
-    {file = "urllib3-1.26.6.tar.gz", hash = "sha256:f57b4c16c62fa2760b7e3d97c35b255512fb6b59a259730f36ba32ce9f8e342f"},
+    {file = "urllib3-1.26.7-py2.py3-none-any.whl", hash = "sha256:c4fdf4019605b6e5423637e01bc9fe4daef873709a7973e195ceba0a62bbc844"},
+    {file = "urllib3-1.26.7.tar.gz", hash = "sha256:4987c65554f7a2dbf30c18fd48778ef124af6fab771a377103da0585e2336ece"},
 ]
 uvicorn = [
     {file = "uvicorn-0.15.0-py3-none-any.whl", hash = "sha256:17f898c64c71a2640514d4089da2689e5db1ce5d4086c2d53699bf99513421c1"},
     {file = "uvicorn-0.15.0.tar.gz", hash = "sha256:d9a3c0dd1ca86728d3e235182683b4cf94cd53a867c288eaeca80ee781b2caff"},
 ]
 werkzeug = [
-    {file = "Werkzeug-2.0.1-py3-none-any.whl", hash = "sha256:6c1ec500dcdba0baa27600f6a22f6333d8b662d22027ff9f6202e3367413caa8"},
-    {file = "Werkzeug-2.0.1.tar.gz", hash = "sha256:1de1db30d010ff1af14a009224ec49ab2329ad2cde454c8a708130642d579c42"},
+    {file = "Werkzeug-2.0.2-py3-none-any.whl", hash = "sha256:63d3dc1cf60e7b7e35e97fa9861f7397283b75d765afcaefd993d6046899de8f"},
+    {file = "Werkzeug-2.0.2.tar.gz", hash = "sha256:aa2bb6fc8dee8d6c504c0ac1e7f5f7dc5810a9903e793b6f715a9f015bdadb9a"},
 ]
 wrapt = [
-    {file = "wrapt-1.12.1.tar.gz", hash = "sha256:b62ffa81fb85f4332a4f609cab4ac40709470da05643a082ec1eb88e6d9b97d7"},
+    {file = "wrapt-1.13.3-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:e05e60ff3b2b0342153be4d1b597bbcfd8330890056b9619f4ad6b8d5c96a81a"},
+    {file = "wrapt-1.13.3-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:85148f4225287b6a0665eef08a178c15097366d46b210574a658c1ff5b377489"},
+    {file = "wrapt-1.13.3-cp27-cp27m-manylinux1_x86_64.whl", hash = "sha256:2dded5496e8f1592ec27079b28b6ad2a1ef0b9296d270f77b8e4a3a796cf6909"},
+    {file = "wrapt-1.13.3-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:e94b7d9deaa4cc7bac9198a58a7240aaf87fe56c6277ee25fa5b3aa1edebd229"},
+    {file = "wrapt-1.13.3-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:498e6217523111d07cd67e87a791f5e9ee769f9241fcf8a379696e25806965af"},
+    {file = "wrapt-1.13.3-cp27-cp27mu-manylinux1_i686.whl", hash = "sha256:ec7e20258ecc5174029a0f391e1b948bf2906cd64c198a9b8b281b811cbc04de"},
+    {file = "wrapt-1.13.3-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:87883690cae293541e08ba2da22cacaae0a092e0ed56bbba8d018cc486fbafbb"},
+    {file = "wrapt-1.13.3-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:f99c0489258086308aad4ae57da9e8ecf9e1f3f30fa35d5e170b4d4896554d80"},
+    {file = "wrapt-1.13.3-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:6a03d9917aee887690aa3f1747ce634e610f6db6f6b332b35c2dd89412912bca"},
+    {file = "wrapt-1.13.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:936503cb0a6ed28dbfa87e8fcd0a56458822144e9d11a49ccee6d9a8adb2ac44"},
+    {file = "wrapt-1.13.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:f9c51d9af9abb899bd34ace878fbec8bf357b3194a10c4e8e0a25512826ef056"},
+    {file = "wrapt-1.13.3-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:220a869982ea9023e163ba915077816ca439489de6d2c09089b219f4e11b6785"},
+    {file = "wrapt-1.13.3-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:0877fe981fd76b183711d767500e6b3111378ed2043c145e21816ee589d91096"},
+    {file = "wrapt-1.13.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:43e69ffe47e3609a6aec0fe723001c60c65305784d964f5007d5b4fb1bc6bf33"},
+    {file = "wrapt-1.13.3-cp310-cp310-win32.whl", hash = "sha256:78dea98c81915bbf510eb6a3c9c24915e4660302937b9ae05a0947164248020f"},
+    {file = "wrapt-1.13.3-cp310-cp310-win_amd64.whl", hash = "sha256:ea3e746e29d4000cd98d572f3ee2a6050a4f784bb536f4ac1f035987fc1ed83e"},
+    {file = "wrapt-1.13.3-cp35-cp35m-manylinux1_i686.whl", hash = "sha256:8c73c1a2ec7c98d7eaded149f6d225a692caa1bd7b2401a14125446e9e90410d"},
+    {file = "wrapt-1.13.3-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:086218a72ec7d986a3eddb7707c8c4526d677c7b35e355875a0fe2918b059179"},
+    {file = "wrapt-1.13.3-cp35-cp35m-manylinux2010_i686.whl", hash = "sha256:e92d0d4fa68ea0c02d39f1e2f9cb5bc4b4a71e8c442207433d8db47ee79d7aa3"},
+    {file = "wrapt-1.13.3-cp35-cp35m-manylinux2010_x86_64.whl", hash = "sha256:d4a5f6146cfa5c7ba0134249665acd322a70d1ea61732723c7d3e8cc0fa80755"},
+    {file = "wrapt-1.13.3-cp35-cp35m-win32.whl", hash = "sha256:8aab36778fa9bba1a8f06a4919556f9f8c7b33102bd71b3ab307bb3fecb21851"},
+    {file = "wrapt-1.13.3-cp35-cp35m-win_amd64.whl", hash = "sha256:944b180f61f5e36c0634d3202ba8509b986b5fbaf57db3e94df11abee244ba13"},
+    {file = "wrapt-1.13.3-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:2ebdde19cd3c8cdf8df3fc165bc7827334bc4e353465048b36f7deeae8ee0918"},
+    {file = "wrapt-1.13.3-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:610f5f83dd1e0ad40254c306f4764fcdc846641f120c3cf424ff57a19d5f7ade"},
+    {file = "wrapt-1.13.3-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5601f44a0f38fed36cc07db004f0eedeaadbdcec90e4e90509480e7e6060a5bc"},
+    {file = "wrapt-1.13.3-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:e6906d6f48437dfd80464f7d7af1740eadc572b9f7a4301e7dd3d65db285cacf"},
+    {file = "wrapt-1.13.3-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:766b32c762e07e26f50d8a3468e3b4228b3736c805018e4b0ec8cc01ecd88125"},
+    {file = "wrapt-1.13.3-cp36-cp36m-win32.whl", hash = "sha256:5f223101f21cfd41deec8ce3889dc59f88a59b409db028c469c9b20cfeefbe36"},
+    {file = "wrapt-1.13.3-cp36-cp36m-win_amd64.whl", hash = "sha256:f122ccd12fdc69628786d0c947bdd9cb2733be8f800d88b5a37c57f1f1d73c10"},
+    {file = "wrapt-1.13.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:46f7f3af321a573fc0c3586612db4decb7eb37172af1bc6173d81f5b66c2e068"},
+    {file = "wrapt-1.13.3-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:778fd096ee96890c10ce96187c76b3e99b2da44e08c9e24d5652f356873f6709"},
+    {file = "wrapt-1.13.3-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:0cb23d36ed03bf46b894cfec777eec754146d68429c30431c99ef28482b5c1df"},
+    {file = "wrapt-1.13.3-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:96b81ae75591a795d8c90edc0bfaab44d3d41ffc1aae4d994c5aa21d9b8e19a2"},
+    {file = "wrapt-1.13.3-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:7dd215e4e8514004c8d810a73e342c536547038fb130205ec4bba9f5de35d45b"},
+    {file = "wrapt-1.13.3-cp37-cp37m-win32.whl", hash = "sha256:47f0a183743e7f71f29e4e21574ad3fa95676136f45b91afcf83f6a050914829"},
+    {file = "wrapt-1.13.3-cp37-cp37m-win_amd64.whl", hash = "sha256:fd76c47f20984b43d93de9a82011bb6e5f8325df6c9ed4d8310029a55fa361ea"},
+    {file = "wrapt-1.13.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:b73d4b78807bd299b38e4598b8e7bd34ed55d480160d2e7fdaabd9931afa65f9"},
+    {file = "wrapt-1.13.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:ec9465dd69d5657b5d2fa6133b3e1e989ae27d29471a672416fd729b429eb554"},
+    {file = "wrapt-1.13.3-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dd91006848eb55af2159375134d724032a2d1d13bcc6f81cd8d3ed9f2b8e846c"},
+    {file = "wrapt-1.13.3-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:ae9de71eb60940e58207f8e71fe113c639da42adb02fb2bcbcaccc1ccecd092b"},
+    {file = "wrapt-1.13.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:51799ca950cfee9396a87f4a1240622ac38973b6df5ef7a41e7f0b98797099ce"},
+    {file = "wrapt-1.13.3-cp38-cp38-win32.whl", hash = "sha256:4b9c458732450ec42578b5642ac53e312092acf8c0bfce140ada5ca1ac556f79"},
+    {file = "wrapt-1.13.3-cp38-cp38-win_amd64.whl", hash = "sha256:7dde79d007cd6dfa65afe404766057c2409316135cb892be4b1c768e3f3a11cb"},
+    {file = "wrapt-1.13.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:981da26722bebb9247a0601e2922cedf8bb7a600e89c852d063313102de6f2cb"},
+    {file = "wrapt-1.13.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:705e2af1f7be4707e49ced9153f8d72131090e52be9278b5dbb1498c749a1e32"},
+    {file = "wrapt-1.13.3-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:25b1b1d5df495d82be1c9d2fad408f7ce5ca8a38085e2da41bb63c914baadff7"},
+    {file = "wrapt-1.13.3-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:77416e6b17926d953b5c666a3cb718d5945df63ecf922af0ee576206d7033b5e"},
+    {file = "wrapt-1.13.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:865c0b50003616f05858b22174c40ffc27a38e67359fa1495605f96125f76640"},
+    {file = "wrapt-1.13.3-cp39-cp39-win32.whl", hash = "sha256:0a017a667d1f7411816e4bf214646d0ad5b1da2c1ea13dec6c162736ff25a374"},
+    {file = "wrapt-1.13.3-cp39-cp39-win_amd64.whl", hash = "sha256:81bd7c90d28a4b2e1df135bfbd7c23aee3050078ca6441bead44c42483f9ebfb"},
+    {file = "wrapt-1.13.3.tar.gz", hash = "sha256:1fea9cd438686e6682271d36f3481a9f3636195578bab9ca3382e2f5f01fc185"},
+]
+zipp = [
+    {file = "zipp-3.6.0-py3-none-any.whl", hash = "sha256:9fe5ea21568a0a70e50f273397638d39b03353731e6cbbb3fd8502a33fec40bc"},
+    {file = "zipp-3.6.0.tar.gz", hash = "sha256:71c644c5369f4a6e07636f0aa966270449561fcea2e3d6747b8d23efaa9d7832"},
 ]
diff --git a/pyproject.toml b/pyproject.toml
index 4dd6260..f5290a0 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name="robotframework-openapidriver"
-version = "2.1.0-alpha.1"
+version = "2.1.0-alpha.3"
 description = "A library for contract-testing OpenAPI / Swagger APIs."
 license = "Apache-2.0"
 authors = ["Robin Mackaij"]
@@ -17,7 +17,7 @@ classifiers = [
     "Framework :: Robot Framework",
 ]
 packages = [
-    { include = "openapidriver", from = "src" },
+    { include = "OpenApiDriver", from = "src" },
 ]
 
 [tool.poetry.dependencies]
@@ -58,6 +58,9 @@ exclude_lines = [
     "@abstract"
 ]
 
+[tool.mypy]
+show_error_codes = true
+
 [[tool.mypy.overrides]]
 module = [
     "DataDriver.*",
diff --git a/src/OpenApiDriver/__init__.py b/src/OpenApiDriver/__init__.py
index e2ae5d5..4fb0a72 100644
--- a/src/OpenApiDriver/__init__.py
+++ b/src/OpenApiDriver/__init__.py
@@ -1,7 +1,16 @@
+"""
+The OpenApiDriver package is intended to be used as a Robot Framework library.
+The following classes and constants are exposed to be used by the library user:
+- OpenApiDriver: The class to be used as a Library in the *** Settings *** section
+- IdDependency, IdReference, PathPropertiesConstraint, PropertyValueConstraint,
+    UniquePropertyValueConstraint: Classes to be subclassed by the library user
+    when implementing a custom mapping module (advanced use).
+- Dto, Relation: Base classes that can be used for type annotations.
+- IGNORE: A special constant that can be used as a value in the PropertyValueConstraint.
+"""
 from importlib.metadata import version
 
 from OpenApiDriver.dto_base import (
-    IGNORE,
     Dto,
     IdDependency,
     IdReference,
@@ -11,8 +20,9 @@
     UniquePropertyValueConstraint,
 )
 from OpenApiDriver.openapidriver import OpenApiDriver
+from OpenApiDriver.value_utils import IGNORE
 
 try:
     __version__ = version("robotframework-openapidriver")
-except:  # pragma: no cover
+except Exception:  # pragma: no cover
     pass
diff --git a/src/OpenApiDriver/dto_base.py b/src/OpenApiDriver/dto_base.py
index 441f614..931c1d1 100644
--- a/src/OpenApiDriver/dto_base.py
+++ b/src/OpenApiDriver/dto_base.py
@@ -10,10 +10,9 @@
 from typing import Any, Dict, List, Optional, Union
 from uuid import uuid4
 
-logger = getLogger(__name__)
-
+from OpenApiDriver import value_utils
 
-IGNORE = object()
+logger = getLogger(__name__)
 
 
 class ResourceRelation(ABC):
@@ -83,140 +82,77 @@ class DtoBase(ABC):
 
     @staticmethod
     def get_parameter_relations() -> List[Relation]:
+        """Return the list of Relations for the header and query parameters."""
         return []
 
+    def get_parameter_relations_for_error_code(self, error_code: int) -> List[Relation]:
+        """Return the list of Relations associated with the given error_code."""
+        relations: List[Relation] = [
+            r for r in self.get_parameter_relations() if r.error_code == error_code
+        ]
+        return relations
+
     @staticmethod
     def get_relations() -> List[Relation]:
+        """Return the list of Relations for the (json) body."""
         return []
 
     def get_relations_for_error_code(self, error_code: int) -> List[Relation]:
+        """Return the list of Relations associated with the given error_code."""
         relations: List[Relation] = [
             r for r in self.get_relations() if r.error_code == error_code
         ]
         return relations
 
-    def get_parameter_relations_for_error_code(self, error_code: int) -> List[Relation]:
-        relations: List[Relation] = [
-            r for r in self.get_parameter_relations() if r.error_code == error_code
-        ]
-        return relations
-
     def get_invalidated_data(
-        self, schema: Dict[str, Any], status_code: int
+        self,
+        schema: Dict[str, Any],
+        status_code: int,
+        invalid_property_default_code: int,
     ) -> Dict[str, Any]:
-        def get_invalid_value_from_enum(values: List[Any], value_type: str):
-            if value_type == "string":
-                invalid_value: Any = ""
-            elif value_type in ["integer", "number"]:
-                invalid_value = 0
-            elif value_type == "array":
-                invalid_value = []
-            elif value_type == "object":
-                invalid_value = {}
-            else:
-                logger.warning(f"Cannot invalidate enum value with type {value_type}")
-                return None
-            for value in values:
-                if value_type in ["string", "integer", "number"]:
-                    invalid_value += value
-                # TODO: can the values to choose from in an enum be array/object in JSON?
-                if value_type == "array":
-                    invalid_value.extend(value)
-                if value_type == "object":
-                    invalid_value.update(value)
-            return invalid_value
-
+        """Return a data set with one of the properties set to an invalid value or type."""
         properties: Dict[str, Any] = self.__dict__
 
-        relations = self.get_relations()
-        shuffle(relations)
-        for relation in relations:
-            if (
-                isinstance(relation, IdDependency)
-                and status_code == relation.error_code
-            ):
-                invalid_value = uuid4().hex
-                logger.debug(
-                    f"Breaking IdDependency for status_code {status_code}: replacing "
-                    f"{properties[relation.property_name]} with {invalid_value}"
-                )
-                properties[relation.property_name] = invalid_value
-                return properties
-
-        constrained_property_names: List[str] = [
-            r.property_name for r in relations if isinstance(r, PropertyValueConstraint)
-        ]
-        property_names = list(properties.keys())
+        relations = [r for r in self.get_relations() if r.error_code == status_code]
+        if status_code == invalid_property_default_code:
+            property_names = list(properties.keys())
+        else:
+            property_names = [r.property_name for r in relations]
         # shuffle the propery_names so different properties on the Dto are invalidated
         # when rerunning the test
         shuffle(property_names)
         for property_name in property_names:
             # if possible, invalidate a constraint but send otherwise valid data
-            property_data = schema["properties"][property_name]
-            property_type = property_data["type"]
-            current_value = properties[property_name]
-            if enum_values := property_data.get("enum"):
-                invalidated_value = get_invalid_value_from_enum(
-                    values=enum_values, value_type=property_type
-                )
-                if invalidated_value is not None:
-                    properties[property_name] = invalidated_value
-                    return properties
-            if (
-                property_type == "boolean"
-                and property_name in constrained_property_names
-            ):
-                properties[property_name] = not current_value
-                return properties
-            if property_type == "integer":
-                if minimum := property_data.get("minimum"):
-                    properties[property_name] = minimum - 1
-                    return properties
-                if maximum := property_data.get("maximum"):
-                    properties[property_name] = maximum + 1
-                    return properties
-                if property_name in constrained_property_names:
-                    # TODO: figure out a good generic approach, also consider multiple
-                    # constraints on the same property
-                    # HACK: this int is way out of the json supported int range
-                    properties[property_name] = uuid4().int
-                    return properties
-            if property_type == "number":
-                if minimum := property_data.get("minimum"):
-                    properties[property_name] = minimum - 1
-                    return properties
-                if maximum := property_data.get("maximum"):
-                    properties[property_name] = maximum + 1
-                    return properties
-                if property_name in constrained_property_names:
-                    # TODO: figure out a good generic approach, also consider multiple
-                    # constraints on the same property
-                    # HACK: this float is way out of the json supported float range
-                    properties[property_name] = uuid4().int / 3.14
-                    return properties
-            if property_type == "string":
-                if minimum := property_data.get("minLength"):
-                    if minimum > 0:
-                        # if there is a minimum length, send 1 character less
-                        properties[property_name] = current_value[0 : minimum - 1]
-                        return properties
-                if maximum := property_data.get("maxLength"):
-                    properties[property_name] = current_value + uuid4().hex
-                    return properties
-        # if there are no constraints to violate, send invalid data types
-        schema_properties = schema["properties"]
-        for property_name, property_values in schema_properties.items():
-            property_type = property_values.get("type")
-            if property_type != "string":
+            id_dependencies = [
+                r
+                for r in relations
+                if isinstance(r, IdDependency) and r.property_name == property_name
+            ]
+            if id_dependencies:
+                invalid_value = uuid4().hex
                 logger.debug(
-                    f"property {property_name} set to str instead of {property_type}"
+                    f"Breaking IdDependency for status_code {status_code}: replacing "
+                    f"{properties[property_name]} with {invalid_value}"
                 )
-                properties[property_name] = uuid4().hex
-            else:
-                # Since int / float / bool can always be cast to sting,
-                # change the string to a nested object
-                properties[property_name] = [{"invalid": [None]}]
-        return properties
+                properties[property_name] = invalid_value
+                return properties
+
+            value_schema = schema["properties"][property_name]
+            current_value = properties[property_name]
+            values_from_constraint = [
+                r.values
+                for r in relations
+                if isinstance(r, PropertyValueConstraint)
+                and r.property_name == property_name
+            ]
+
+            properties[property_name] = value_utils.get_invalid_value(
+                value_schema=value_schema,
+                current_value=current_value,
+                values_from_constraint=values_from_constraint,
+            )
+            return properties
+        return properties  # pragma: no cover
 
 
 @dataclass
diff --git a/src/OpenApiDriver/dto_utils.py b/src/OpenApiDriver/dto_utils.py
index e4ceba5..2363082 100644
--- a/src/OpenApiDriver/dto_utils.py
+++ b/src/OpenApiDriver/dto_utils.py
@@ -21,7 +21,7 @@ class get_dto_class:
     def __init__(self, mappings_module_name: str) -> None:
         try:
             mappings_module = import_module(mappings_module_name)
-            self.dto_mapping: Dict[Tuple[str, str], Any] = mappings_module.DTO_MAPPING
+            self.dto_mapping: Dict[Tuple[str, str], Any] = mappings_module.DTO_MAPPING  # type: ignore[attr-defined]
         except (ImportError, AttributeError, ValueError) as exception:
             logger.debug(f"DTO_MAPPING was not imported: {exception}")
             self.dto_mapping = {}
diff --git a/src/OpenApiDriver/openapi_executors.py b/src/OpenApiDriver/openapi_executors.py
index be70284..d2e26de 100644
--- a/src/OpenApiDriver/openapi_executors.py
+++ b/src/OpenApiDriver/openapi_executors.py
@@ -1,14 +1,15 @@
-"""Module containing the keywords and core logic to perform automatic OpenAPI contract validation."""
+"""Module containing the classes to perform automatic OpenAPI contract validation."""
 # TODO: support ${itemId} mapping instead of only "id"
 
 import json as _json
 import sys
+from copy import deepcopy
 from dataclasses import asdict, dataclass, field, make_dataclass
 from enum import Enum
 from itertools import zip_longest
 from logging import getLogger
 from pathlib import Path
-from random import choice, getrandbits, randint, uniform
+from random import choice
 from typing import Any, Dict, List, Optional, Tuple, Type, Union
 from uuid import uuid4
 
@@ -27,8 +28,8 @@
 from robot.libraries.BuiltIn import BuiltIn
 from robotlibcore import keyword
 
+from OpenApiDriver import value_utils
 from OpenApiDriver.dto_base import (
-    IGNORE,
     Dto,
     IdDependency,
     IdReference,
@@ -38,6 +39,7 @@
     UniquePropertyValueConstraint,
 )
 from OpenApiDriver.dto_utils import DefaultDto, get_dto_class
+from OpenApiDriver.value_utils import IGNORE
 
 run_keyword = BuiltIn().run_keyword
 
@@ -46,6 +48,8 @@
 
 
 class ValidationLevel(str, Enum):
+    """The available levels for the response_validation parameter."""
+
     DISABLED = "DISABLED"
     INFO = "INFO"
     WARN = "WARN"
@@ -54,15 +58,19 @@ class ValidationLevel(str, Enum):
 
 @dataclass
 class RequestData:
-    dto: Union[Dto, DefaultDto] = DefaultDto
+    """Helper class to manage parameters used when making requests."""
+
+    dto: Union[Dto, DefaultDto] = DefaultDto()
     dto_schema: Dict[str, Any] = field(default_factory=dict)
     parameters: List[Dict[str, Any]] = field(default_factory=list)
     params: Dict[str, Any] = field(default_factory=dict)
     headers: Dict[str, Any] = field(default_factory=dict)
 
 
-class OpenapiExecutors:
-    def __init__(
+class OpenapiExecutors:  # pylint: disable=too-many-instance-attributes
+    """Main class providing the keywords and core logic to perform endpoint validations."""
+
+    def __init__(  # pylint: disable=too-many-arguments, too-many-locals
         self,
         source: str,
         origin: str = "",
@@ -122,6 +130,16 @@ def __init__(
 
     @keyword
     def test_unauthorized(self, endpoint: str, method: str) -> None:
+        """
+        Perform a request for `method` on the `endpoint`, with no authorization.
+
+        This keyword only passes if the response code is 401: Unauthorized.
+
+        Any authorization parameters used to initialize the library are
+        ignored for this request.
+        > Note: No headers or (json) body are send with the request. For security
+        reasons, the authorization validation should be checked first.
+        """
         url: str = run_keyword("get_valid_url", endpoint, method)
         response = self.session.request(
             method=method,
@@ -134,6 +152,21 @@ def test_unauthorized(self, endpoint: str, method: str) -> None:
     def test_invalid_url(
         self, endpoint: str, method: str, expected_status_code: int = 404
     ) -> None:
+        """
+        Perform a request for the provided 'endpoint' and 'method' where the url for
+        the `endpoint` is invalidated.
+
+        This keyword will be `SKIPPED` if the endpoint contains no parts that
+        can be invalidated.
+
+        The optional `expected_status_code` parameter (default: 404) can be set to the
+        expected status code for APIs that do not return a 404 on invalid urls.
+
+        > Note: Depending on API design, the url may be validated before or after
+        validation of headers, query parameters and / or (json) body. By default, no
+        parameters are send with the request. The `require_body_for_invalid_url`
+        parameter can be set to `True` if needed.
+        """
         valid_url: str = run_keyword("get_valid_url", endpoint, method)
 
         if not (url := run_keyword("get_invalidated_url", valid_url)):
@@ -159,6 +192,16 @@ def test_invalid_url(
 
     @keyword
     def test_endpoint(self, endpoint: str, method: str, status_code: int) -> None:
+        """
+        Validate that performing the `method` operation on `endpoint` results in a
+        `status_code` response.
+
+        This is the main keyword to be used in the `Test Template` keyword when using
+        the OpenApiDriver.
+
+        The keyword calls other keywords to generate the neccesary data to perform
+        the desired operation and validate the response against the openapi document.
+        """
         json_data: Optional[Dict[str, Any]] = None
         original_data: Optional[Dict[str, Any]] = None
 
@@ -168,77 +211,99 @@ def test_endpoint(self, endpoint: str, method: str, status_code: int) -> None:
         headers = request_data.headers
         dto = request_data.dto
         json_data = asdict(dto)
+        # when patching, get the original data to check only patched data has changed
+        if method == "PATCH":
+            get_request_data = self.get_request_data(endpoint=endpoint, method="GET")
+            get_params = get_request_data.params
+            get_headers = get_request_data.headers
+            response: Response = run_keyword(
+                "authorized_request", url, "GET", get_params, get_headers
+            )
+            if response.ok:
+                original_data = response.json()
         # in case of a status code indicating an error, ensure the error occurs
         if status_code >= 400:
             data_relations = dto.get_relations_for_error_code(status_code)
             parameter_relations = dto.get_parameter_relations_for_error_code(
                 status_code
             )
-            if data_relations and parameter_relations:
-                if randint(0, 1):
-                    json_data = self.invalidate_json_data(
-                        data_relations=data_relations,
-                        json_data=json_data,
-                        schema=request_data.dto_schema,
-                        url=url,
-                        method=method,
-                        dto=dto,
-                        status_code=status_code,
+            invalidation_keyword_data = {
+                "get_invalid_json_data": [
+                    "get_invalid_json_data",
+                    data_relations,
+                    request_data.dto_schema,
+                    url,
+                    method,
+                    dto,
+                    status_code,
+                ],
+                "invalidate_parameters": [
+                    "invalidate_parameters",
+                    params,
+                    headers,
+                    parameter_relations,
+                    request_data.parameters,
+                    status_code,
+                ],
+            }
+            invalidation_keywords = []
+            if data_relations:
+                invalidation_keywords.append("get_invalid_json_data")
+            if parameter_relations:
+                invalidation_keywords.append("invalidate_parameters")
+            if invalidation_keywords:
+                if (
+                    invalidation_keyword := choice(invalidation_keywords)
+                ) == "get_invalid_json_data":
+                    json_data = run_keyword(
+                        *invalidation_keyword_data[invalidation_keyword]
                     )
                 else:
-                    params, headers = self.invalidate_parameters(
-                        params=params,
-                        headers=headers,
-                        relations=parameter_relations,
-                        parameters=request_data.parameters,
+                    params, headers = run_keyword(
+                        *invalidation_keyword_data[invalidation_keyword]
                     )
-            elif data_relations:
-                json_data = self.invalidate_json_data(
-                    data_relations=data_relations,
-                    json_data=json_data,
-                    schema=request_data.dto_schema,
-                    url=url,
-                    method=method,
-                    dto=dto,
-                    status_code=status_code,
-                )
-            elif parameter_relations:
-                params, headers = self.invalidate_parameters(
-                    params=params,
-                    headers=headers,
-                    relations=parameter_relations,
-                    parameters=request_data.parameters,
-                )
+            # if there are no relations to invalide and the status_code is the default
+            # response_code for invalid properties, invalidate all properties
             elif status_code == self.invalid_property_default_response:
-                json_data = self.invalidate_json_data(
-                    data_relations=data_relations,
-                    json_data=json_data,
-                    schema=request_data.dto_schema,
-                    url=url,
-                    method=method,
-                    dto=dto,
-                    status_code=status_code,
+                json_data = run_keyword(
+                    *invalidation_keyword_data["get_invalid_json_data"]
                 )
-                params, headers = self.invalidate_parameters(
-                    params=params,
-                    headers=headers,
-                    relations=parameter_relations,
-                    parameters=request_data.parameters,
+                params, headers = run_keyword(
+                    *invalidation_keyword_data["invalidate_parameters"]
                 )
             else:
                 logger.error(
                     f"No Dto mapping found to cause status_code {status_code}."
                 )
+        run_keyword(
+            "perform_validated_request",
+            endpoint,
+            method,
+            status_code,
+            url,
+            params,
+            headers,
+            json_data,
+            original_data,
+        )
 
-        if method == "PATCH":
-            get_request_data = self.get_request_data(endpoint=endpoint, method="GET")
-            get_params = get_request_data.params
-            get_headers = get_request_data.headers
-            response: Response = run_keyword(
-                "authorized_request", url, "GET", get_params, get_headers
-            )
-            if response.ok:
-                original_data = response.json()
+    @keyword
+    def perform_validated_request(
+        self,
+        endpoint: str,
+        method: str,
+        status_code: int,
+        url: str,
+        params: Dict[str, Any],
+        headers: Dict[str, str],
+        json_data: Dict[str, Any],
+        original_data: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """
+        This keyword first calls the Authorized Request keyword, then the Validate
+        Response keyword and finally validates is, for `DELETE` operations, whether
+        the target resource was indeed deleted (OK response) or not (error responses).
+        """
         response = run_keyword(
             "authorized_request", url, method, params, headers, json_data
         )
@@ -261,27 +326,44 @@ def test_endpoint(self, endpoint: str, method: str, status_code: int) -> None:
                 f"Response status_code {response.status_code} was not {status_code}"
             )
         run_keyword("validate_response", endpoint, response, original_data)
-        if method == "DELETE" and response.ok:
+        if method == "DELETE":
             get_request_data = self.get_request_data(endpoint=endpoint, method="GET")
             get_params = get_request_data.params
             get_headers = get_request_data.headers
-            response = run_keyword(
+            get_response = run_keyword(
                 "authorized_request", url, "GET", get_params, get_headers
             )
             if response.ok:
-                raise AssertionError(
-                    f"Resource still exists after deletion. Url was {url}"
-                )
-            # if the endpoint supports GET, 404 is expected, if not 405 is expected
-            if response.status_code not in [404, 405]:
-                logger.warning(
-                    f"Unexpected response after deleting resource: Status_code "
-                    f"{response.status_code} was received after trying to get {url} "
-                    f"after sucessfully deleting it."
-                )
+                if get_response.ok:
+                    raise AssertionError(
+                        f"Resource still exists after deletion. Url was {url}"
+                    )
+                # if the endpoint supports GET, 404 is expected, if not 405 is expected
+                if get_response.status_code not in [404, 405]:
+                    logger.warning(
+                        f"Unexpected response after deleting resource: Status_code "
+                        f"{get_response.status_code} was received after trying to get {url} "
+                        f"after sucessfully deleting it."
+                    )
+            else:
+                if not get_response.ok:
+                    raise AssertionError(
+                        f"Resource could not be retrieved after failed deletion. "
+                        f"Url was {url}, status_code was {get_response.status_code}"
+                    )
 
     @keyword
     def get_valid_url(self, endpoint: str, method: str) -> str:
+        """
+        This keyword returns a valid url for the given `endpoint` and `method`.
+
+        If the `endpoint` contains path parameters the Get Valid Id For Endpoint
+        keyword will be executed to retrieve valid ids for the path parameters.
+
+        > Note: if valid ids cannot be retrieved within the scope of the API, the
+        `PathPropertiesConstraint` Relation can be used. More information can be found
+        [here](https://marketsquare.github.io/robotframework-openapidriver/advanced_use.md).
+        """
         dto_class = self.get_dto_class(endpoint=endpoint, method=method)
         relations = dto_class.get_relations()
         paths = [p.path for p in relations if isinstance(p, PathPropertiesConstraint)]
@@ -305,6 +387,12 @@ def get_valid_url(self, endpoint: str, method: str) -> str:
 
     @keyword
     def get_valid_id_for_endpoint(self, endpoint: str, method: str) -> str:
+        """
+        Support keyword that returns the `id` for an existing resource at `endpoint`.
+
+        To prevent resource conflicts with other test cases, a new resource is created
+        (POST) if possible.
+        """
         url: str = run_keyword("get_valid_url", endpoint, method)
         # Try to create a new resource to prevent conflicts caused by
         # operations performed on the same resource by other test cases
@@ -356,17 +444,25 @@ def get_valid_id_for_endpoint(self, endpoint: str, method: str) -> str:
             response.ok
         ), f"get_valid_id_for_endpoint received status_code {response.status_code}"
         response_data = response.json()
-        prepared_body: bytes = response.request.body
-        send_json: Dict[str, Any] = _json.loads(prepared_body.decode("UTF-8"))
+        if prepared_body := response.request.body:
+            if isinstance(prepared_body, bytes):
+                send_json = _json.loads(prepared_body.decode("UTF-8"))
+            else:
+                send_json = _json.loads(prepared_body)
+        else:
+            send_json = None
+        # no support for retrieving an id from an array returned on a POST request
+        if isinstance(response_data, list):
+            raise NotImplementedError(
+                f"Unexpected response body for POST request: expected an object but "
+                f"received an array ({response_data})"
+            )
         # POST on /resource_type/{id}/array_item/ will return the updated {id} resource
         # instead of a newly created resource. In this case, the send_json must be
         # in the array of the 'array_item' property on {id}
         send_path: str = response.request.path_url
-        if isinstance(response_data, dict):
-            response_path: Optional[str] = response_data.get("href", None)
-        else:
-            response_path = None
-        if response_path and send_path not in response_path:
+        response_path: Optional[str] = response_data.get("href", None)
+        if response_path and (send_path not in response_path) and send_json:
             property_to_check = send_path.replace(response_path, "")[1:]
             item_list: List[Dict[str, Any]] = response_data[property_to_check]
             # Use the (mandatory) id to get the POSTed resource from the list
@@ -378,16 +474,17 @@ def get_valid_id_for_endpoint(self, endpoint: str, method: str) -> str:
         return valid_id
 
     def get_request_data(self, endpoint: str, method: str) -> RequestData:
+        """Return an object with valid request data for body, headers and query params."""
         method = method.lower()
         # The endpoint can contain already resolved Ids that have to be matched
         # against the parametrized endpoints in the paths section.
         spec_endpoint = self.get_parametrized_endpoint(endpoint)
         try:
             method_spec = self.openapi_doc["paths"][spec_endpoint][method]
-        except KeyError:
+        except KeyError as exception:
             raise NotImplementedError(
                 f"method '{method}' not suported on '{spec_endpoint}"
-            )
+            ) from exception
         dto_class = self.get_dto_class(endpoint=spec_endpoint, method=method)
 
         parameters = method_spec.get("parameters", [])
@@ -399,20 +496,19 @@ def get_request_data(self, endpoint: str, method: str) -> RequestData:
 
         if (body_spec := method_spec.get("requestBody", None)) is None:
             if dto_class == DefaultDto:
-                return RequestData(
-                    dto=DefaultDto(),
-                    parameters=parameters,
-                    params=params,
-                    headers=headers,
+                dto_instance: Dto = DefaultDto()
+            else:
+                dto_class = make_dataclass(
+                    cls_name=method_spec["operationId"],
+                    fields=[],
+                    bases=(dto_class,),
                 )
-            dto_class = make_dataclass(
-                cls_name=method_spec["operationId"],
-                fields=[],
-                bases=(dto_class,),
-            )
-            dto_instance = dto_class()
+                dto_instance = dto_class()
             return RequestData(
-                dto=dto_instance, parameters=parameters, params=params, headers=headers
+                dto=dto_instance,
+                parameters=parameters,
+                params=params,
+                headers=headers,
             )
         # Content should be a single key/value entry, so use tuple assignment
         (content_type,) = body_spec["content"].keys()
@@ -420,23 +516,25 @@ def get_request_data(self, endpoint: str, method: str) -> RequestData:
             # At present no supported for other types.
             raise NotImplementedError(f"content_type '{content_type}' not supported")
         content_schema = body_spec["content"][content_type]["schema"]
-        resolved_schema: Dict[str, Any] = self.resolve_schema(content_schema)
-        dto_data = self.get_dto_data(
+        # TODO: is resolve_schema still needed?
+        resolved_schema: Dict[str, Any] = self._resolve_schema(content_schema)
+        dto_data = self.get_json_data_for_dto_class(
             schema=resolved_schema,
-            dto=dto_class,
+            dto_class=dto_class,
             operation_id=method_spec.get("operationId"),
         )
         if dto_data is None:
-            return RequestData(dto=DefaultDto(), parameters=parameters)
-        fields: List[Tuple[str, type]] = []
-        for key, value in dto_data.items():
-            fields.append((key, type(value)))
-        dto_class = make_dataclass(
-            cls_name=method_spec["operationId"],
-            fields=fields,
-            bases=(dto_class,),
-        )
-        dto_instance = dto_class(**dto_data)
+            dto_instance = DefaultDto()
+        else:
+            fields: List[Tuple[str, type]] = []
+            for key, value in dto_data.items():
+                fields.append((key, type(value)))
+            dto_class = make_dataclass(
+                cls_name=method_spec["operationId"],
+                fields=fields,
+                bases=(dto_class,),
+            )
+            dto_instance = dto_class(**dto_data)  # type: ignore[call-arg]
         return RequestData(
             dto=dto_instance,
             dto_schema=resolved_schema,
@@ -446,6 +544,11 @@ def get_request_data(self, endpoint: str, method: str) -> RequestData:
         )
 
     def get_parametrized_endpoint(self, endpoint: str) -> str:
+        """
+        Get the parametrized endpoint as found in the `paths` section of the openapi
+        document from a (partially) resolved endpoint.
+        """
+
         def match_parts(parts: List[str], spec_parts: List[str]) -> bool:
             for part, spec_part in zip_longest(parts, spec_parts, fillvalue="Filler"):
                 if part == "Filler" or spec_part == "Filler":
@@ -465,16 +568,17 @@ def match_parts(parts: List[str], spec_parts: List[str]) -> bool:
                 return spec_endpoint
         raise ValueError(f"{endpoint} not matched to openapi_doc path")
 
+    @staticmethod
     def get_parameter_data(
-        self,
         parameters: List[Dict[str, Any]],
         parameter_relations: List[Relation],
     ) -> Dict[str, str]:
+        """Generate a valid list of key-value pairs for all parameters."""
         result: Dict[str, str] = {}
         value: Any = None
         for parameter in parameters:
             parameter_name = parameter["name"]
-            parameter_type = parameter["schema"]["type"]
+            parameter_schema = parameter["schema"]
             relations = [
                 r for r in parameter_relations if r.property_name == parameter_name
             ]
@@ -486,31 +590,22 @@ def get_parameter_data(
                     continue
                 result[parameter_name] = str(value)
                 continue
-            if from_enum := parameter["schema"].get("enum", None):
-                value = choice(from_enum)
-                result[parameter_name] = str(value)
-                continue
-            if parameter_type == "boolean":
-                value = bool(getrandbits(1))
-            if parameter_type == "integer":
-                minimum = -2147483648
-                maximum = 2147483647
-                value = randint(minimum, maximum)
-            if parameter_type == "number":
-                value = uniform(0.0, 1.0)
-            if parameter_type == "string":
-                value = uuid4().hex
+            value = value_utils.get_valid_value(parameter_schema)
             # By the http standard, query string and header values must be strings
             result[parameter_name] = str(value)
         return result
 
     @keyword
-    def get_dto_data(
-        self, schema: Dict[str, Any], dto: Type[Dto], operation_id: str
+    def get_json_data_for_dto_class(
+        self, schema: Dict[str, Any], dto_class: Type[Dto], operation_id: str
     ) -> Optional[Dict[str, Any]]:
+        """
+        Generate a valid (json-compatible) dict for all the `dto_class` properties.
+        """
+
         def get_constrained_values(property_name: str) -> List[Any]:
-            relations = dto.get_relations()
-            values = [
+            relations = dto_class.get_relations()
+            values_list = [
                 c.values
                 for c in relations
                 if (
@@ -519,10 +614,10 @@ def get_constrained_values(property_name: str) -> List[Any]:
                 )
             ]
             # values should be empty or contain 1 list of allowed values
-            return values.pop() if values else []
+            return values_list.pop() if values_list else []
 
         def get_dependent_id(property_name: str, operation_id: str) -> Optional[str]:
-            relations = dto.get_relations()
+            relations = dto_class.get_relations()
             # multiple get paths are possible based on the operation being performed
             id_get_paths = [
                 (d.get_path, d.operation_id)
@@ -552,8 +647,12 @@ def get_dependent_id(property_name: str, operation_id: str) -> Optional[str]:
         json_data: Dict[str, Any] = {}
 
         for property_name in schema.get("properties", []):
-            property_type = schema["properties"][property_name]["type"]
+            value_schema = schema["properties"][property_name]
+            property_type = value_schema["type"]
             if constrained_values := get_constrained_values(property_name):
+                # do not add properties that are configured to be ignored
+                if IGNORE in constrained_values:
+                    continue
                 json_data[property_name] = choice(constrained_values)
                 continue
             if dependent_id := get_dependent_id(
@@ -561,65 +660,24 @@ def get_dependent_id(property_name: str, operation_id: str) -> Optional[str]:
             ):
                 json_data[property_name] = dependent_id
                 continue
-            if property_type == "boolean":
-                json_data[property_name] = bool(getrandbits(1))
-                continue
-            # if the property specifies an enum, pick one at random
-            if from_enum := schema["properties"][property_name].get("enum", None):
-                value = choice(from_enum)
-                json_data[property_name] = value
-                continue
-            # Use int32 integers if "format" does not specify int64
-            if property_type == "integer":
-                property_format = schema["properties"][property_name].get(
-                    "format", "int32"
-                )
-                if property_format == "int64":
-                    min_int = -9223372036854775808
-                    max_int = 9223372036854775807
-                else:
-                    min_int = -2147483648
-                    max_int = 2147483647
-                # TODO: add support for exclusiveMinimum and exclusiveMaximum
-                minimum = schema["properties"][property_name].get("minimum", min_int)
-                maximum = schema["properties"][property_name].get("maximum", max_int)
-                value = randint(minimum, maximum)
-                json_data[property_name] = value
-                continue
-            # Python floats are already double precision, so no check for "format"
-            if property_type == "number":
-                minimum = schema["properties"][property_name].get("minimum", 0.0)
-                maximum = schema["properties"][property_name].get("maximum", 1.0)
-                value = uniform(minimum, maximum)
-                json_data[property_name] = value
-                continue
-            # TODO: byte, binary, date, date-time based on "format"
-            if property_type == "string":
-                minimum = schema["properties"][property_name].get("minLength", 0)
-                maximum = schema["properties"][property_name].get("maxLength", 36)
-                value = uuid4().hex
-                while len(value) < minimum:
-                    value = value + uuid4().hex
-                if len(value) > maximum:
-                    value = value[:maximum]
-                json_data[property_name] = value
-                continue
             if property_type == "object":
                 default_dto = self.get_dto_class(endpoint="", method="")
-                object_data = self.get_dto_data(
-                    schema=schema["properties"][property_name],
-                    dto=default_dto,
+                object_data = self.get_json_data_for_dto_class(
+                    schema=value_schema,
+                    dto_class=default_dto,
                     operation_id="",
                 )
                 json_data[property_name] = object_data
                 continue
-            raise NotImplementedError(
-                f"Type '{property_type}' is currently not supported"
-            )
+            json_data[property_name] = value_utils.get_valid_value(value_schema)
         return json_data
 
     @keyword
     def get_invalidated_url(self, valid_url: str) -> Optional[str]:
+        """
+        Return an url with all the path parameters in the `valid_url` replaced by a
+        random UUID. If the `valid_url` does not contain any parameters, None is returned.
+        """
         endpoint = valid_url.replace(self.base_url, "")
         endpoint_parts = endpoint.split("/")
         # first part will be '' since an endpoint starts with /
@@ -639,71 +697,106 @@ def get_invalidated_url(self, valid_url: str) -> Optional[str]:
         # TODO: add support for header / query parameters that can be invalidated
         return None
 
-    @staticmethod
-    def invalidate_json_data(
+    @keyword
+    def get_invalid_json_data(
+        self,
         data_relations: List[Relation],
-        json_data: Dict[str, Any],
         schema: Dict[str, Any],
         url: str,
         method: str,
         dto: Dto,
         status_code: int,
     ) -> Dict[str, Any]:
+        """
+        Return `json_data` based on the `dto` that will cause the provided `status_code`
+        for the `method` operation on the `url`.
+
+        > Note: applicable UniqueProperyValueConstraint and IdReference Relations are
+            considered before changes to `json_data` are made.
+        """
         if not data_relations:
             if not schema:
                 raise AssertionError(
                     "Failed to invalidate: no data_relations and missing schema."
                 )
-            json_data = dto.get_invalidated_data(schema=schema, status_code=status_code)
+            json_data = dto.get_invalidated_data(
+                schema=schema,
+                status_code=status_code,
+                invalid_property_default_code=self.invalid_property_default_response,
+            )
             return json_data
         resource_relation = choice(data_relations)
         if isinstance(resource_relation, UniquePropertyValueConstraint):
-            json_data = run_keyword("ensure_conflict", url, method, dto, status_code)
+            json_data = run_keyword(
+                "get_json_data_with_conflict", url, method, dto, status_code
+            )
         elif isinstance(resource_relation, IdReference):
             run_keyword("ensure_in_use", url, resource_relation)
+            json_data = asdict(dto)
         else:
-            json_data = dto.get_invalidated_data(schema=schema, status_code=status_code)
+            json_data = dto.get_invalidated_data(
+                schema=schema,
+                status_code=status_code,
+                invalid_property_default_code=self.invalid_property_default_response,
+            )
         return json_data
 
-    @staticmethod
+    @keyword
     def invalidate_parameters(
+        self,
         params: Dict[str, Any],
         headers: Dict[str, str],
         relations: List[Relation],
         parameters: List[Dict[str, Any]],
+        status_code: int,
     ) -> Tuple[Dict[str, Any], Dict[str, str]]:
-        if not parameters:
+        """
+        Returns a version of `params, headers` that has been modified to cause the
+        provided `status_code`.
+        """
+        if not params and not headers:
             return params, headers
-        if relations:
-            relation = choice(relations)
-            parameter_to_invalidate = relation.property_name
-            if isinstance(relation, PropertyValueConstraint):
-                # if IGNORE is in the values, the parameter needs to be ignored for an
-                # OK response so leaving the value at it's original value should result
-                # in the specified error response
-                if IGNORE in relation.values:
-                    invalid_value = IGNORE
-                else:
-                    invalid_values = 2 * relation.values
-                    invalid_value = invalid_values.pop()
-                    for value in invalid_values:
-                        invalid_value = invalid_value + value
-            else:
-                # TODO: support for other supported constraints
-                raise NotImplemented
+        if any([params, headers]) and not parameters:
+            logger.warning(
+                "Could not invalidate parameters: parameters list was empty."
+            )
+            return params, headers
+        # ensure we're not modifying mutable arguments
+        params = deepcopy(params)
+        headers = deepcopy(headers)
+        relations_for_status_code = [
+            r
+            for r in relations
+            if isinstance(r, PropertyValueConstraint) and r.error_code == status_code
+        ]
+        if status_code == self.invalid_property_default_response:
+            parameter_data = choice(parameters)
+            parameter_to_invalidate = parameter_data["name"]
         else:
-            parameter_names = [p["name"] for p in parameters]
+            parameter_names = [r.property_name for r in relations_for_status_code]
             parameter_to_invalidate = choice(parameter_names)
-            [schema] = [
-                p.get("schema")
-                for p in parameters
-                if p.get("name") == parameter_to_invalidate
+            [parameter_data] = [
+                d for d in parameters if d["name"] == parameter_to_invalidate
             ]
-            parameter_type = schema.get("type")
-            if parameter_type == "string":
-                invalid_value = [{"invalid": [None]}]
-            else:
-                invalid_value = uuid4().hex
+        relations_for_parameter = [
+            r.values
+            for r in relations_for_status_code
+            if r.property_name == parameter_to_invalidate
+        ]
+        values_from_constraint = (
+            relations_for_parameter[0] if relations_for_parameter else None
+        )
+        if parameter_to_invalidate in params.keys():
+            valid_value = params[parameter_to_invalidate]
+        elif parameter_to_invalidate in headers.keys():
+            valid_value = headers[parameter_to_invalidate]
+        else:
+            valid_value = value_utils.get_valid_value(parameter_data["schema"])
+        invalid_value = value_utils.get_invalid_value(
+            value_schema=parameter_data["schema"],
+            current_value=valid_value,
+            values_from_constraint=values_from_constraint,
+        )
 
         if parameter_to_invalidate in params.keys():
             params[parameter_to_invalidate] = invalid_value
@@ -713,6 +806,10 @@ def invalidate_parameters(
 
     @keyword
     def ensure_in_use(self, url: str, resource_relation: IdReference) -> None:
+        """
+        Ensure that the `id` of the resource referenced by the `url` is used by the
+        resource defined by the `resource_relation`.
+        """
         endpoint = url.replace(self.base_url, "")
         endpoint_parts = endpoint.split("/")
         # first part will be '' since an endpoint starts with /
@@ -742,73 +839,59 @@ def ensure_in_use(self, url: str, resource_relation: IdReference) -> None:
             response.raise_for_status()
 
     @keyword
-    def ensure_conflict(
+    def get_json_data_with_conflict(
         self, url: str, method: str, dto: Dto, conflict_status_code: int
     ) -> Dict[str, Any]:
+        """
+        Return `json_data` based on the `UniqueProperyValueConstraint` that must be
+        returned by the `get_relations` implementation on the `dto` for the given
+        `conflict_status_code`.
+        """
         json_data = asdict(dto)
-        for relation in dto.get_relations():
-            if isinstance(relation, UniquePropertyValueConstraint):
-                json_data[relation.property_name] = relation.value
-                # create a new resource that the original request will conflict with
-                if method in ["PATCH", "PUT"]:
-                    post_url_parts = url.split("/")[:-1]
-                    post_url = "/".join(post_url_parts)
-                    # the PATCH or PUT may use a different dto than required for POST
-                    # so a valid POST dto must be constructed
-                    endpoint = post_url.replace(self.base_url, "")
-                    request_data = self.get_request_data(
-                        endpoint=endpoint, method="POST"
-                    )
-                    post_json = asdict(request_data.dto)
-                    for key in post_json.keys():
-                        if key in json_data:
-                            post_json[key] = json_data.get(key)
-                else:
-                    post_url = url
-                    post_json = json_data
+        unique_property_value_constraints = [
+            r
+            for r in dto.get_relations()
+            if isinstance(r, UniquePropertyValueConstraint)
+        ]
+        for relation in unique_property_value_constraints:
+            json_data[relation.property_name] = relation.value
+            # create a new resource that the original request will conflict with
+            if method in ["PATCH", "PUT"]:
+                post_url_parts = url.split("/")[:-1]
+                post_url = "/".join(post_url_parts)
+                # the PATCH or PUT may use a different dto than required for POST
+                # so a valid POST dto must be constructed
                 endpoint = post_url.replace(self.base_url, "")
                 request_data = self.get_request_data(endpoint=endpoint, method="POST")
-                params = request_data.params
-                headers = request_data.headers
-                response: Response = run_keyword(
-                    "authorized_request", post_url, "POST", params, headers, post_json
-                )
-                # conflicting resource may already exist
-                assert (
-                    response.ok or response.status_code == conflict_status_code
-                ), f"ensure_conflict received {response.status_code}: {response.json()}"
-                return json_data
-        endpoint = url.replace(self.base_url, "")
-        request_data = self.get_request_data(endpoint=endpoint, method="GET")
-        params = request_data.params
-        headers = request_data.headers
-        response = run_keyword("authorized_request", url, "GET", params, headers)
-        if response.ok:
-            response_json = response.json()
-            if isinstance(response_json, dict):
-                # update the values in the json_data with the values from the response
-                for key in json_data.keys():
-                    if key in response_json.keys():
-                        json_data[key] = response_json[key]
-                return json_data
-        # couldn't retrieve a resource to conflict with, so create one instead
-        request_data = self.get_request_data(endpoint=endpoint, method="POST")
-        params = request_data.params
-        headers = request_data.headers
-        response = run_keyword(
-            "authorized_request", url, "POST", params, headers, json_data
+                post_json = asdict(request_data.dto)
+                for key in post_json.keys():
+                    if key in json_data:
+                        post_json[key] = json_data.get(key)
+            else:
+                post_url = url
+                post_json = json_data
+            endpoint = post_url.replace(self.base_url, "")
+            request_data = self.get_request_data(endpoint=endpoint, method="POST")
+            params = request_data.params
+            headers = request_data.headers
+            response: Response = run_keyword(
+                "authorized_request", post_url, "POST", params, headers, post_json
+            )
+            # conflicting resource may already exist
+            assert (
+                response.ok or response.status_code == conflict_status_code
+            ), f"get_json_data_with_conflict received {response.status_code}: {response.json()}"
+            return json_data
+        raise ValueError(
+            f"No UniquePropertyValueConstraint in the get_relations list on dto {dto}."
         )
-        assert (
-            response.ok
-        ), f"ensure_conflict received {response.status_code}: {response.json()}"
-        return json_data
 
-    def resolve_schema(self, schema: Dict[str, Any]) -> Dict[str, Any]:
+    def _resolve_schema(self, schema: Dict[str, Any]) -> Dict[str, Any]:
         # schema is mutable, so copy to prevent mutation of original schema argument
         resolved_schema: Dict[str, Any] = schema.copy()
         if schema_parts := resolved_schema.pop("allOf", None):
             for schema_part in schema_parts:
-                resolved_part = self.resolve_schema(schema_part)
+                resolved_part = self._resolve_schema(schema_part)
                 resolved_schema = self._merge_schemas(resolved_schema, resolved_part)
         return resolved_schema
 
@@ -840,9 +923,19 @@ def validate_response(
         response: Response,
         original_data: Optional[Dict[str, Any]] = None,
     ) -> None:
+        """
+        Validate the `response` by performing the following validations:
+        - validate the `response` against the openapi schema for the `endpoint`
+        - validate that the response does not contain extra properties
+        - validate that a href, if present, refers to the correct resource
+        - validate that the value for a property that is in the response is equal to
+            the property value that was send
+        - validate that no `original_data` is preserved when performing a PUT operation
+        - validate that a PATCH operation only updates the provided properties
+        """
         if response.status_code == 204:
             assert not response.content
-            return
+            return None
         # validate the response against the schema
         openapi_request = RequestsOpenAPIRequest(response.request)
         openapi_response = RequestsOpenAPIResponse(response)
@@ -863,9 +956,16 @@ def validate_response(
                 else:
                     logger.info(validation_error)
 
-        response_spec = self.get_response_spec(
+        request_method = response.request.method
+        if request_method is None:
+            logger.warning(
+                f"Could not validate response for endpoint {endpoint}; no method found "
+                f"on the request property of the provided response."
+            )
+            return None
+        response_spec = self._get_response_spec(
             endpoint=endpoint,
-            method=response.request.method,
+            method=request_method,
             status_code=response.status_code,
         )
         # content should be a single key/value entry, so use tuple assignment
@@ -881,11 +981,11 @@ def validate_response(
         json_response = response.json()
 
         response_schema = response_spec["content"][content_type]["schema"]
-        resolved_schema = self.resolve_schema(response_schema)
+        resolved_schema = self._resolve_schema(response_schema)
         if list_item_schema := resolved_schema.get("items"):
             if not isinstance(json_response, list):
                 raise AssertionError(
-                    f"Response schema violation: the schema specifies an array / list as "
+                    f"Response schema violation: the schema specifies an array as "
                     f"response type but the response was of type {type(json_response)}."
                 )
             # at present, only lists of resource objects are supported
@@ -901,7 +1001,7 @@ def validate_response(
                 )
             # no further validation; value validation of individual resources should
             # be performed on the endpoints for the specific resource
-            return
+            return None
 
         run_keyword(
             "validate_resource_properties", json_response, resolved_schema["properties"]
@@ -922,22 +1022,18 @@ def validate_response(
         # every property that was sucessfully send and that is in the response
         # schema must have the value that was send
         if response.ok and response.request.method in ["POST", "PUT", "PATCH"]:
-            self.validate_send_response(response=response, original_data=original_data)
-        # ensure string properties are not empty
-        failed_keys: List[str] = []
-        for key, value in json_response.items():
-            if isinstance(value, str) and value.isspace():
-                failed_keys.append(key)
-        if failed_keys:
-            raise AssertionError(
-                f"Properties {', '.join(failed_keys)} contain a whitespace value"
-            )
+            run_keyword("validate_send_response", response, original_data)
+        return None
 
     @staticmethod
     @keyword
     def validate_resource_properties(
         resource: Dict[str, Any], schema_properties: Dict[str, Any]
     ) -> None:
+        """
+        Validate that the 'resource' does not contain any properties that are not
+        defined in the `schema_properties`.
+        """
         if resource.keys() != schema_properties.keys():
             expected_property_names = sorted(schema_properties.keys())
             property_names_in_resource = sorted(resource.keys())
@@ -953,9 +1049,24 @@ def validate_resource_properties(
     def validate_send_response(
         response: Response, original_data: Optional[Dict[str, Any]] = None
     ) -> None:
+        """
+        Validate that each property that was send that is in the response has the value
+        that was send.
+        In case a PATCH request, validate that only the properties that were patched
+        have changed and that other properties are still at their pre-patch values.
+        """
         reference = response.json()
-        prepared_body: bytes = response.request.body
-        send_json: Dict[str, Any] = _json.loads(prepared_body.decode("UTF-8"))
+        if prepared_body := response.request.body:
+            if isinstance(prepared_body, bytes):
+                send_json = _json.loads(prepared_body.decode("UTF-8"))
+            else:
+                send_json = _json.loads(prepared_body)
+        else:
+            logger.warning(
+                "Could not validate send response; the body of the request property "
+                "on the provided response was None."
+            )
+            return None
         # POST on /resource_type/{id}/array_item/ will return the updated {id} resource
         # instead of a newly created resource. In this case, the send_json must be
         # in the array of the 'array_item' property on {id}
@@ -975,16 +1086,10 @@ def validate_send_response(
             # sometimes, a property in the request is not in the response, e.g. a password
             if key not in reference.keys():
                 continue
-            if value is None:
+            if value is not None:
                 # if a None value is send, the target property should be cleared or
-                # reverted to the default value which depends on its type
-                assert reference[key] in [None, [], 1, False, ""], (
-                    f"Received value for {key} '{reference[key]}' does not "
-                    f"match '{value}' in the {response.request.method} request"
-                    f"\nSend: {_json.dumps(send_json, indent=4, sort_keys=True)}"
-                    f"\nGot: {_json.dumps(reference, indent=4, sort_keys=True)}"
-                )
-            else:
+                # reverted to the default value (which cannot be specified in the
+                # openapi document)
                 assert reference[key] == value, (
                     f"Received value for {key} '{reference[key]}' does not "
                     f"match '{value}' in the {response.request.method} request"
@@ -1001,8 +1106,9 @@ def validate_send_response(
                         f"\nPre-patch: {_json.dumps(original_data, indent=4, sort_keys=True)}"
                         f"\nGot: {_json.dumps(reference, indent=4, sort_keys=True)}"
                     )
+        return None
 
-    def get_response_spec(
+    def _get_response_spec(
         self, endpoint: str, method: str, status_code: int
     ) -> Dict[str, Any]:
         method = method.lower()
@@ -1019,6 +1125,12 @@ def authorized_request(
         headers: Optional[Dict[str, Any]] = None,
         json: Optional[Dict[str, Any]] = None,
     ) -> Response:
+        """
+        Perform a request using the security token or authentication set in the library.
+
+        > Note: provided username / password or auth objects take precedence over token
+            based security
+        """
         # if both an auth object and a token are available, auth takes precedence
         if self.security_token and not self.auth:
             security_header = {"Authorization": self.security_token}
@@ -1035,7 +1147,3 @@ def authorized_request(
         )
         logger.debug(f"Response text: {response.text}")
         return response
-
-
-# Support Robot Framework import mechanism
-openapi_executors = OpenapiExecutors  # pylint: disable=invalid-name
diff --git a/src/OpenApiDriver/openapi_reader.py b/src/OpenApiDriver/openapi_reader.py
index 5d1c8b1..d8bd176 100644
--- a/src/OpenApiDriver/openapi_reader.py
+++ b/src/OpenApiDriver/openapi_reader.py
@@ -33,7 +33,7 @@ class OpenApiReader(AbstractReaderClass):
     def get_data_from_source(self) -> List[TestCaseData]:
         test_data: List[TestCaseData] = []
 
-        endpoints = get_endpoints_from_source(getattr(self, "source", None))
+        endpoints = _get_endpoints_from_source(getattr(self, "source", None))
         if ignored_endpoints := getattr(self, "ignored_endpoints", None):
             for endpoint in ignored_endpoints:
                 endpoints.pop(endpoint)
@@ -77,7 +77,7 @@ def get_data_from_source(self) -> List[TestCaseData]:
                                 "${method}": method.upper(),
                                 "${status_code}": response,
                             },
-                            tags=get_tag_list(
+                            tags=_get_tag_list(
                                 tags=tag_list,
                                 method=method,
                                 response=response,
@@ -87,7 +87,7 @@ def get_data_from_source(self) -> List[TestCaseData]:
         return test_data
 
 
-def get_endpoints_from_source(source: Optional[str]) -> Dict[str, Any]:
+def _get_endpoints_from_source(source: Optional[str]) -> Dict[str, Any]:
     try:
         parser = ResolvingParser(source, backend="openapi-spec-validator")
     except (ResolutionError, AssertionError) as exception:
@@ -98,7 +98,7 @@ def get_endpoints_from_source(source: Optional[str]) -> Dict[str, Any]:
     return endpoints
 
 
-def get_tag_list(tags: List[str], method: str, response: str) -> List[str]:
+def _get_tag_list(tags: List[str], method: str, response: str) -> List[str]:
     tags.append(f"Method: {method.upper()}")
     tags.append(f"Response: {response}")
     return tags
diff --git a/src/OpenApiDriver/openapidriver.libspec b/src/OpenApiDriver/openapidriver.libspec
index 67667b8..95aabbd 100644
--- a/src/OpenApiDriver/openapidriver.libspec
+++ b/src/OpenApiDriver/openapidriver.libspec
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<keywordspec name="openapidriver" type="LIBRARY" format="HTML" scope="SUITE" generated="2021-10-28T13:59:35Z" specversion="3" source="openapidriver.py" lineno="119">
-<version>2.0.0</version>
+<keywordspec name="OpenApiDriver" type="LIBRARY" format="HTML" scope="SUITE" generated="2021-11-23T19:28:49Z" specversion="3" source="openapidriver.py" lineno="121">
+<version>2.1.0a3</version>
 <doc>&lt;p&gt;Visit the &lt;a href="https://github.com/MarketSquare/robotframework-openapidriver"&gt;library page&lt;/a&gt; for an introduction and examples.&lt;/p&gt;
 &lt;p&gt;Most of the provided keywords are for internal use by the library (for example to ensure the result logs provide insight into the executed steps) but a number of them are intended to be used as &lt;code&gt;Test Template&lt;/code&gt; or within the &lt;code&gt;Keyword&lt;/code&gt; that serves as the &lt;code&gt;Test Template&lt;/code&gt;.&lt;/p&gt;
 &lt;p&gt;The following Keywords are intended to be used in Test Suites:&lt;/p&gt;
@@ -12,7 +12,7 @@
 <tags>
 </tags>
 <inits>
-<init name="Init" lineno="139">
+<init name="Init" lineno="141">
 <arguments repr="source: str, ignored_endpoints: List[str] | None = None, ignored_responses: List[int] | None = None, ignored_testcases: List[typing.List[str]] | None = None, ignore_fastapi_default_422: bool = False, origin: str = , base_path: str = , mappings_path: str | Path = , username: str = , password: str = , security_token: str = , auth: AuthBase | None = None, response_validation: ValidationLevel = WARN, disable_server_validation: bool = True, require_body_for_invalid_url: bool = False, invalid_property_default_response: int = 422">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="source: str">
 <name>source</name>
@@ -140,7 +140,7 @@
 </init>
 </inits>
 <keywords>
-<kw name="Authorized Request" source="openapi_executors.py" lineno="1014">
+<kw name="Authorized Request" source="openapi_executors.py" lineno="1117">
 <arguments repr="url: str, method: str, params: Dict[str, typing.Any] | None = None, headers: Dict[str, typing.Any] | None = None, json: Dict[str, typing.Any] | None = None">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="url: str">
 <name>url</name>
@@ -169,11 +169,34 @@
 <default>None</default>
 </arg>
 </arguments>
-<doc/>
-<shortdoc/>
+<doc>&lt;p&gt;Perform a request using the security token or authentication set in the library.&lt;/p&gt;
+&lt;p&gt;&amp;gt; Note: provided username / password or auth objects take precedence over token based security&lt;/p&gt;</doc>
+<shortdoc>Perform a request using the security token or authentication set in the library.</shortdoc>
 </kw>
-<kw name="Ensure Conflict" source="openapi_executors.py" lineno="745">
-<arguments repr="url: str, method: str, dto: Dto, conflict_status_code: int">
+<kw name="Ensure In Use" source="openapi_executors.py" lineno="805">
+<arguments repr="url: str, resource_relation: IdReference">
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="url: str">
+<name>url</name>
+<type>str</type>
+</arg>
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="resource_relation: IdReference">
+<name>resource_relation</name>
+<type>IdReference</type>
+</arg>
+</arguments>
+<doc>&lt;p&gt;Ensure that the &lt;span class="name"&gt;id&lt;/span&gt; of the resource referenced by the &lt;span class="name"&gt;url&lt;/span&gt; is used by the resource defined by the &lt;span class="name"&gt;resource_relation&lt;/span&gt;.&lt;/p&gt;</doc>
+<shortdoc>Ensure that the `id` of the resource referenced by the `url` is used by the resource defined by the `resource_relation`.</shortdoc>
+</kw>
+<kw name="Get Invalid Json Data" source="openapi_executors.py" lineno="698">
+<arguments repr="data_relations: List[typing.Union[OpenApiDriver.dto_base.IdDependency, OpenApiDriver.dto_base.IdReference, OpenApiDriver.dto_base.PathPropertiesConstraint, OpenApiDriver.dto_base.PropertyValueConstraint, OpenApiDriver.dto_base.UniquePropertyValueConstraint]], schema: Dict[str, typing.Any], url: str, method: str, dto: Dto, status_code: int">
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="data_relations: List[typing.Union[OpenApiDriver.dto_base.IdDependency, OpenApiDriver.dto_base.IdReference, OpenApiDriver.dto_base.PathPropertiesConstraint, OpenApiDriver.dto_base.PropertyValueConstraint, OpenApiDriver.dto_base.UniquePropertyValueConstraint]]">
+<name>data_relations</name>
+<type>List[typing.Union[OpenApiDriver.dto_base.IdDependency, OpenApiDriver.dto_base.IdReference, OpenApiDriver.dto_base.PathPropertiesConstraint, OpenApiDriver.dto_base.PropertyValueConstraint, OpenApiDriver.dto_base.UniquePropertyValueConstraint]]</type>
+</arg>
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="schema: Dict[str, typing.Any]">
+<name>schema</name>
+<type>Dict[str, typing.Any]</type>
+</arg>
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="url: str">
 <name>url</name>
 <type>str</type>
@@ -186,36 +209,33 @@
 <name>dto</name>
 <type>Dto</type>
 </arg>
-<arg kind="POSITIONAL_OR_NAMED" required="true" repr="conflict_status_code: int">
-<name>conflict_status_code</name>
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="status_code: int">
+<name>status_code</name>
 <type>int</type>
 </arg>
 </arguments>
-<doc/>
-<shortdoc/>
+<doc>&lt;p&gt;Return &lt;span class="name"&gt;json_data&lt;/span&gt; based on the &lt;span class="name"&gt;dto&lt;/span&gt; that will cause the provided &lt;span class="name"&gt;status_code&lt;/span&gt; for the &lt;span class="name"&gt;method&lt;/span&gt; operation on the &lt;span class="name"&gt;url&lt;/span&gt;.&lt;/p&gt;
+&lt;p&gt;&amp;gt; Note: applicable UniqueProperyValueConstraint and IdReference Relations are considered before changes to &lt;span class="name"&gt;json_data&lt;/span&gt; are made.&lt;/p&gt;</doc>
+<shortdoc>Return `json_data` based on the `dto` that will cause the provided `status_code` for the `method` operation on the `url`.</shortdoc>
 </kw>
-<kw name="Ensure In Use" source="openapi_executors.py" lineno="715">
-<arguments repr="url: str, resource_relation: IdReference">
-<arg kind="POSITIONAL_OR_NAMED" required="true" repr="url: str">
-<name>url</name>
+<kw name="Get Invalidated Url" source="openapi_executors.py" lineno="673">
+<arguments repr="valid_url: str">
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="valid_url: str">
+<name>valid_url</name>
 <type>str</type>
 </arg>
-<arg kind="POSITIONAL_OR_NAMED" required="true" repr="resource_relation: IdReference">
-<name>resource_relation</name>
-<type>IdReference</type>
-</arg>
 </arguments>
-<doc/>
-<shortdoc/>
+<doc>&lt;p&gt;Return an url with all the path parameters in the &lt;span class="name"&gt;valid_url&lt;/span&gt; replaced by a random UUID. If the &lt;span class="name"&gt;valid_url&lt;/span&gt; does not contain any parameters, None is returned.&lt;/p&gt;</doc>
+<shortdoc>Return an url with all the path parameters in the `valid_url` replaced by a random UUID. If the `valid_url` does not contain any parameters, None is returned.</shortdoc>
 </kw>
-<kw name="Get Dto Data" source="openapi_executors.py" lineno="508">
-<arguments repr="schema: Dict[str, typing.Any], dto: Type[OpenApiDriver.dto_base.Dto], operation_id: str">
+<kw name="Get Json Data For Dto Class" source="openapi_executors.py" lineno="599">
+<arguments repr="schema: Dict[str, typing.Any], dto_class: Type[OpenApiDriver.dto_base.Dto], operation_id: str">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="schema: Dict[str, typing.Any]">
 <name>schema</name>
 <type>Dict[str, typing.Any]</type>
 </arg>
-<arg kind="POSITIONAL_OR_NAMED" required="true" repr="dto: Type[OpenApiDriver.dto_base.Dto]">
-<name>dto</name>
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="dto_class: Type[OpenApiDriver.dto_base.Dto]">
+<name>dto_class</name>
 <type>Type[OpenApiDriver.dto_base.Dto]</type>
 </arg>
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="operation_id: str">
@@ -223,20 +243,32 @@
 <type>str</type>
 </arg>
 </arguments>
-<doc/>
-<shortdoc/>
+<doc>&lt;p&gt;Generate a valid (json-compatible) dict for all the &lt;span class="name"&gt;dto_class&lt;/span&gt; properties.&lt;/p&gt;</doc>
+<shortdoc>Generate a valid (json-compatible) dict for all the `dto_class` properties.</shortdoc>
 </kw>
-<kw name="Get Invalidated Url" source="openapi_executors.py" lineno="622">
-<arguments repr="valid_url: str">
-<arg kind="POSITIONAL_OR_NAMED" required="true" repr="valid_url: str">
-<name>valid_url</name>
+<kw name="Get Json Data With Conflict" source="openapi_executors.py" lineno="839">
+<arguments repr="url: str, method: str, dto: Dto, conflict_status_code: int">
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="url: str">
+<name>url</name>
+<type>str</type>
+</arg>
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="method: str">
+<name>method</name>
 <type>str</type>
 </arg>
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="dto: Dto">
+<name>dto</name>
+<type>Dto</type>
+</arg>
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="conflict_status_code: int">
+<name>conflict_status_code</name>
+<type>int</type>
+</arg>
 </arguments>
-<doc/>
-<shortdoc/>
+<doc>&lt;p&gt;Return &lt;span class="name"&gt;json_data&lt;/span&gt; based on the &lt;span class="name"&gt;UniqueProperyValueConstraint&lt;/span&gt; that must be returned by the &lt;span class="name"&gt;get_relations&lt;/span&gt; implementation on the &lt;span class="name"&gt;dto&lt;/span&gt; for the given &lt;span class="name"&gt;conflict_status_code&lt;/span&gt;.&lt;/p&gt;</doc>
+<shortdoc>Return `json_data` based on the `UniqueProperyValueConstraint` that must be returned by the `get_relations` implementation on the `dto` for the given `conflict_status_code`.</shortdoc>
 </kw>
-<kw name="Get Valid Id For Endpoint" source="openapi_executors.py" lineno="307">
+<kw name="Get Valid Id For Endpoint" source="openapi_executors.py" lineno="389">
 <arguments repr="endpoint: str, method: str">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="endpoint: str">
 <name>endpoint</name>
@@ -247,10 +279,11 @@
 <type>str</type>
 </arg>
 </arguments>
-<doc/>
-<shortdoc/>
+<doc>&lt;p&gt;Support keyword that returns the &lt;span class="name"&gt;id&lt;/span&gt; for an existing resource at &lt;span class="name"&gt;endpoint&lt;/span&gt;.&lt;/p&gt;
+&lt;p&gt;To prevent resource conflicts with other test cases, a new resource is created (POST) if possible.&lt;/p&gt;</doc>
+<shortdoc>Support keyword that returns the `id` for an existing resource at `endpoint`.</shortdoc>
 </kw>
-<kw name="Get Valid Url" source="openapi_executors.py" lineno="284">
+<kw name="Get Valid Url" source="openapi_executors.py" lineno="356">
 <arguments repr="endpoint: str, method: str">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="endpoint: str">
 <name>endpoint</name>
@@ -261,10 +294,78 @@
 <type>str</type>
 </arg>
 </arguments>
-<doc/>
-<shortdoc/>
+<doc>&lt;p&gt;This keyword returns a valid url for the given &lt;span class="name"&gt;endpoint&lt;/span&gt; and &lt;span class="name"&gt;method&lt;/span&gt;.&lt;/p&gt;
+&lt;p&gt;If the &lt;span class="name"&gt;endpoint&lt;/span&gt; contains path parameters the Get Valid Id For Endpoint keyword will be executed to retrieve valid ids for the path parameters.&lt;/p&gt;
+&lt;p&gt;&amp;gt; Note: if valid ids cannot be retrieved within the scope of the API, the &lt;span class="name"&gt;PathPropertiesConstraint&lt;/span&gt; Relation can be used. More information can be found [here](https://marketsquare.github.io/robotframework-openapidriver/advanced_use.md).&lt;/p&gt;</doc>
+<shortdoc>This keyword returns a valid url for the given `endpoint` and `method`.</shortdoc>
+</kw>
+<kw name="Invalidate Parameters" source="openapi_executors.py" lineno="742">
+<arguments repr="params: Dict[str, typing.Any], headers: Dict[str, str], relations: List[typing.Union[OpenApiDriver.dto_base.IdDependency, OpenApiDriver.dto_base.IdReference, OpenApiDriver.dto_base.PathPropertiesConstraint, OpenApiDriver.dto_base.PropertyValueConstraint, OpenApiDriver.dto_base.UniquePropertyValueConstraint]], parameters: List[typing.Dict[str, typing.Any]], status_code: int">
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="params: Dict[str, typing.Any]">
+<name>params</name>
+<type>Dict[str, typing.Any]</type>
+</arg>
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="headers: Dict[str, str]">
+<name>headers</name>
+<type>Dict[str, str]</type>
+</arg>
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="relations: List[typing.Union[OpenApiDriver.dto_base.IdDependency, OpenApiDriver.dto_base.IdReference, OpenApiDriver.dto_base.PathPropertiesConstraint, OpenApiDriver.dto_base.PropertyValueConstraint, OpenApiDriver.dto_base.UniquePropertyValueConstraint]]">
+<name>relations</name>
+<type>List[typing.Union[OpenApiDriver.dto_base.IdDependency, OpenApiDriver.dto_base.IdReference, OpenApiDriver.dto_base.PathPropertiesConstraint, OpenApiDriver.dto_base.PropertyValueConstraint, OpenApiDriver.dto_base.UniquePropertyValueConstraint]]</type>
+</arg>
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="parameters: List[typing.Dict[str, typing.Any]]">
+<name>parameters</name>
+<type>List[typing.Dict[str, typing.Any]]</type>
+</arg>
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="status_code: int">
+<name>status_code</name>
+<type>int</type>
+</arg>
+</arguments>
+<doc>&lt;p&gt;Returns a version of &lt;span class="name"&gt;params, headers&lt;/span&gt; that has been modified to cause the provided &lt;span class="name"&gt;status_code&lt;/span&gt;.&lt;/p&gt;</doc>
+<shortdoc>Returns a version of `params, headers` that has been modified to cause the provided `status_code`.</shortdoc>
+</kw>
+<kw name="Perform Validated Request" source="openapi_executors.py" lineno="291">
+<arguments repr="endpoint: str, method: str, status_code: int, url: str, params: Dict[str, typing.Any], headers: Dict[str, str], json_data: Dict[str, typing.Any], original_data: Dict[str, typing.Any] | None = None">
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="endpoint: str">
+<name>endpoint</name>
+<type>str</type>
+</arg>
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="method: str">
+<name>method</name>
+<type>str</type>
+</arg>
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="status_code: int">
+<name>status_code</name>
+<type>int</type>
+</arg>
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="url: str">
+<name>url</name>
+<type>str</type>
+</arg>
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="params: Dict[str, typing.Any]">
+<name>params</name>
+<type>Dict[str, typing.Any]</type>
+</arg>
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="headers: Dict[str, str]">
+<name>headers</name>
+<type>Dict[str, str]</type>
+</arg>
+<arg kind="POSITIONAL_OR_NAMED" required="true" repr="json_data: Dict[str, typing.Any]">
+<name>json_data</name>
+<type>Dict[str, typing.Any]</type>
+</arg>
+<arg kind="POSITIONAL_OR_NAMED" required="false" repr="original_data: Dict[str, typing.Any] | None = None">
+<name>original_data</name>
+<type>Dict[str, typing.Any]</type>
+<type>None</type>
+<default>None</default>
+</arg>
+</arguments>
+<doc>&lt;p&gt;This keyword first calls the Authorized Request keyword, then the Validate Response keyword and finally validates is, for &lt;span class="name"&gt;DELETE&lt;/span&gt; operations, whether the target resource was indeed deleted (OK response) or not (error responses).&lt;/p&gt;</doc>
+<shortdoc>This keyword first calls the Authorized Request keyword, then the Validate Response keyword and finally validates is, for `DELETE` operations, whether the target resource was indeed deleted (OK response) or not (error responses).</shortdoc>
 </kw>
-<kw name="Test Endpoint" source="openapi_executors.py" lineno="161">
+<kw name="Test Endpoint" source="openapi_executors.py" lineno="194">
 <arguments repr="endpoint: str, method: str, status_code: int">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="endpoint: str">
 <name>endpoint</name>
@@ -279,10 +380,12 @@
 <type>int</type>
 </arg>
 </arguments>
-<doc/>
-<shortdoc/>
+<doc>&lt;p&gt;Validate that performing the &lt;span class="name"&gt;method&lt;/span&gt; operation on &lt;span class="name"&gt;endpoint&lt;/span&gt; results in a &lt;span class="name"&gt;status_code&lt;/span&gt; response.&lt;/p&gt;
+&lt;p&gt;This is the main keyword to be used in the &lt;span class="name"&gt;Test Template&lt;/span&gt; keyword when using the OpenApiDriver.&lt;/p&gt;
+&lt;p&gt;The keyword calls other keywords to generate the neccesary data to perform the desired operation and validate the response against the openapi document.&lt;/p&gt;</doc>
+<shortdoc>Validate that performing the `method` operation on `endpoint` results in a `status_code` response.</shortdoc>
 </kw>
-<kw name="Test Invalid Url" source="openapi_executors.py" lineno="134">
+<kw name="Test Invalid Url" source="openapi_executors.py" lineno="152">
 <arguments repr="endpoint: str, method: str, expected_status_code: int = 404">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="endpoint: str">
 <name>endpoint</name>
@@ -298,10 +401,13 @@
 <default>404</default>
 </arg>
 </arguments>
-<doc/>
-<shortdoc/>
+<doc>&lt;p&gt;Perform a request for the provided 'endpoint' and 'method' where the url for the &lt;span class="name"&gt;endpoint&lt;/span&gt; is invalidated.&lt;/p&gt;
+&lt;p&gt;This keyword will be &lt;span class="name"&gt;SKIPPED&lt;/span&gt; if the endpoint contains no parts that can be invalidated.&lt;/p&gt;
+&lt;p&gt;The optional &lt;span class="name"&gt;expected_status_code&lt;/span&gt; parameter (default: 404) can be set to the expected status code for APIs that do not return a 404 on invalid urls.&lt;/p&gt;
+&lt;p&gt;&amp;gt; Note: Depending on API design, the url may be validated before or after validation of headers, query parameters and / or (json) body. By default, no parameters are send with the request. The &lt;span class="name"&gt;require_body_for_invalid_url&lt;/span&gt; parameter can be set to &lt;span class="name"&gt;True&lt;/span&gt; if needed.&lt;/p&gt;</doc>
+<shortdoc>Perform a request for the provided 'endpoint' and 'method' where the url for the `endpoint` is invalidated.</shortdoc>
 </kw>
-<kw name="Test Unauthorized" source="openapi_executors.py" lineno="124">
+<kw name="Test Unauthorized" source="openapi_executors.py" lineno="132">
 <arguments repr="endpoint: str, method: str">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="endpoint: str">
 <name>endpoint</name>
@@ -312,10 +418,12 @@
 <type>str</type>
 </arg>
 </arguments>
-<doc/>
-<shortdoc/>
+<doc>&lt;p&gt;Perform a request for &lt;span class="name"&gt;method&lt;/span&gt; on the &lt;span class="name"&gt;endpoint&lt;/span&gt;, with no authorization.&lt;/p&gt;
+&lt;p&gt;This keyword only passes if the response code is 401: Unauthorized.&lt;/p&gt;
+&lt;p&gt;Any authorization parameters used to initialize the library are ignored for this request. &amp;gt; Note: No headers or (json) body are send with the request. For security reasons, the authorization validation should be checked first.&lt;/p&gt;</doc>
+<shortdoc>Perform a request for `method` on the `endpoint`, with no authorization.</shortdoc>
 </kw>
-<kw name="Validate Resource Properties" source="openapi_executors.py" lineno="938">
+<kw name="Validate Resource Properties" source="openapi_executors.py" lineno="1027">
 <arguments repr="resource: Dict[str, typing.Any], schema_properties: Dict[str, typing.Any]">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="resource: Dict[str, typing.Any]">
 <name>resource</name>
@@ -326,10 +434,10 @@
 <type>Dict[str, typing.Any]</type>
 </arg>
 </arguments>
-<doc/>
-<shortdoc/>
+<doc>&lt;p&gt;Validate that the 'resource' does not contain any properties that are not defined in the &lt;span class="name"&gt;schema_properties&lt;/span&gt;.&lt;/p&gt;</doc>
+<shortdoc>Validate that the 'resource' does not contain any properties that are not defined in the `schema_properties`.</shortdoc>
 </kw>
-<kw name="Validate Response" source="openapi_executors.py" lineno="837">
+<kw name="Validate Response" source="openapi_executors.py" lineno="917">
 <arguments repr="endpoint: str, response: Response, original_data: Dict[str, typing.Any] | None = None">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="endpoint: str">
 <name>endpoint</name>
@@ -346,10 +454,18 @@
 <default>None</default>
 </arg>
 </arguments>
-<doc/>
-<shortdoc/>
+<doc>&lt;p&gt;Validate the &lt;span class="name"&gt;response&lt;/span&gt; by performing the following validations:&lt;/p&gt;
+&lt;ul&gt;
+&lt;li&gt;validate the &lt;span class="name"&gt;response&lt;/span&gt; against the openapi schema for the &lt;span class="name"&gt;endpoint&lt;/span&gt;&lt;/li&gt;
+&lt;li&gt;validate that the response does not contain extra properties&lt;/li&gt;
+&lt;li&gt;validate that a href, if present, refers to the correct resource&lt;/li&gt;
+&lt;li&gt;validate that the value for a property that is in the response is equal to the property value that was send&lt;/li&gt;
+&lt;li&gt;validate that no &lt;span class="name"&gt;original_data&lt;/span&gt; is preserved when performing a PUT operation&lt;/li&gt;
+&lt;li&gt;validate that a PATCH operation only updates the provided properties&lt;/li&gt;
+&lt;/ul&gt;</doc>
+<shortdoc>Validate the `response` by performing the following validations: - validate the `response` against the openapi schema for the `endpoint` - validate that the response does not contain extra properties - validate that a href, if present, refers to the correct resource - validate that the value for a property that is in the response is equal to     the property value that was send - validate that no `original_data` is preserved when performing a PUT operation - validate that a PATCH operation only updates the provided properties</shortdoc>
 </kw>
-<kw name="Validate Send Response" source="openapi_executors.py" lineno="953">
+<kw name="Validate Send Response" source="openapi_executors.py" lineno="1046">
 <arguments repr="response: Response, original_data: Dict[str, typing.Any] | None = None">
 <arg kind="POSITIONAL_OR_NAMED" required="true" repr="response: Response">
 <name>response</name>
@@ -362,14 +478,14 @@
 <default>None</default>
 </arg>
 </arguments>
-<doc/>
-<shortdoc/>
+<doc>&lt;p&gt;Validate that each property that was send that is in the response has the value that was send. In case a PATCH request, validate that only the properties that were patched have changed and that other properties are still at their pre-patch values.&lt;/p&gt;</doc>
+<shortdoc>Validate that each property that was send that is in the response has the value that was send. In case a PATCH request, validate that only the properties that were patched have changed and that other properties are still at their pre-patch values.</shortdoc>
 </kw>
 </keywords>
 <datatypes>
 <enums>
 <enum name="ValidationLevel">
-<doc>&lt;p&gt;An enumeration.&lt;/p&gt;</doc>
+<doc>&lt;p&gt;The available levels for the response_validation parameter.&lt;/p&gt;</doc>
 <members>
 <member name="DISABLED" value="DISABLED"/>
 <member name="INFO" value="INFO"/>
diff --git a/src/OpenApiDriver/openapidriver.py b/src/OpenApiDriver/openapidriver.py
index 5a8e834..53bc4ac 100644
--- a/src/OpenApiDriver/openapidriver.py
+++ b/src/OpenApiDriver/openapidriver.py
@@ -1,10 +1,5 @@
 # region: docstring
-# --- directly after """ is required to prevent the generated README.md from staring with
-# a blank line, which invalides the  front matter that GitHub Pages (Jekyll) uses to
-# generate the README.html.
-"""---
----
-
+"""
 # OpenApiDriver for Robot Framework®
 
 OpenApiDriver is an extension of the Robot Framework® DataDriver library that allows
@@ -78,6 +73,13 @@
 Details about the Keywords can be found
 [here](https://marketsquare.github.io/robotframework-openapidriver/openapidriver.html).
 
+The OpenApiDriver also support handling of relations between resources within the scope
+of the API being validated as well as handling dependencies on resources outside the
+scope of the API. In addition there is support for handling restrictions on the values
+of parameters and properties.
+Details about the `mappings_path` variable usage can be found
+[here](https://marketsquare.github.io/robotframework-openapidriver/advanced_use.md).
+
 ---
 ## Limitations
 
@@ -136,7 +138,7 @@ class OpenApiDriver(DataDriver, DynamicCore):
     ROBOT_LIBRARY_VERSION = __version__
     ROBOT_LIBRARY_DOC_FORMAT = "ROBOT"
 
-    def __init__(
+    def __init__(  # pylint: disable=too-many-arguments
         self,
         source: str,
         ignored_endpoints: Optional[List[str]] = None,
@@ -266,7 +268,3 @@ def __init__(
     # accepts an AbstractReaderClass subclass as reader_class argument
     def _data_reader(self) -> AbstractReaderClass:
         return OpenApiReader(self.reader_config)
-
-
-# Support Robot Framework import mechanism
-openapidriver = OpenApiDriver  # pylint: disable=invalid-name
diff --git a/src/OpenApiDriver/value_utils.py b/src/OpenApiDriver/value_utils.py
new file mode 100644
index 0000000..4b7639a
--- /dev/null
+++ b/src/OpenApiDriver/value_utils.py
@@ -0,0 +1,235 @@
+"""Utility module with functions to handle OpenAPI value types and restrictions."""
+from logging import getLogger
+from random import choice, getrandbits, randint, uniform
+from typing import Any, Dict, List, Optional
+from uuid import uuid4
+
+IGNORE = object()
+
+logger = getLogger(__name__)
+
+
+def get_valid_value(value_schema: Dict[str, Any]) -> Any:
+    """Return a random value that is valid under the provided value_schema."""
+    if from_enum := value_schema.get("enum", None):
+        return choice(from_enum)
+
+    value_type = value_schema["type"]
+
+    if value_type == "boolean":
+        return bool(getrandbits(1))
+    if value_type == "integer":
+        return get_random_int(value_schema=value_schema)
+    if value_type == "number":
+        return get_random_float(value_schema=value_schema)
+    if value_type == "string":
+        return get_random_string(value_schema=value_schema)
+    raise NotImplementedError(f"Type '{value_type}' is currently not supported")
+
+
+def get_invalid_value(
+    value_schema: Dict[str, Any],
+    current_value: Any,
+    values_from_constraint: Optional[List[Any]] = None,
+) -> Any:
+    """Return a random value that violates the provided value_schema."""
+
+    invalid_value: Any = None
+    value_type = value_schema["type"]
+
+    if values_from_constraint:
+        if (
+            invalid_value := get_invalid_value_from_constraint(
+                values_from_constraint=values_from_constraint,
+                value_type=value_type,
+            )
+        ) is not None:
+            return invalid_value
+    # if an enum is possible, combine the values from the enum to invalidate the value
+    if enum_values := value_schema.get("enum"):
+        if (
+            invalid_value := get_invalid_value_from_enum(
+                values=enum_values, value_type=value_type
+            )
+        ) is not None:
+            return invalid_value
+    # violate min / max values or length if possible
+    if (
+        invalid_value := get_value_out_of_bounds(
+            value_schema=value_schema, current_value=current_value
+        )
+    ) is not None:
+        return invalid_value
+    # no value constraints or min / max ranges to violate, so change the data type
+    if value_type == "string":
+        # since int / float / bool can always be cast to sting, change
+        # the string to a nested object
+        return [{"invalid": [None]}]
+    logger.debug(f"property type changed from {value_type} to random string")
+    return uuid4().hex
+
+
+def get_random_int(value_schema: Dict[str, Any]) -> int:
+    """Generate a random int within the min/max range of the schema, if specified."""
+    # Use int32 integers if "format" does not specify int64
+    property_format = value_schema.get("format", "int32")
+    if property_format == "int64":
+        min_int = -9223372036854775808
+        max_int = 9223372036854775807
+    else:
+        min_int = -2147483648
+        max_int = 2147483647
+    minimum = value_schema.get("minimum", min_int)
+    maximum = value_schema.get("maximum", max_int)
+    if value_schema.get("exclusiveMinimum", False):
+        minimum += 1
+    if value_schema.get("exclusiveMaximum", False):
+        maximum -= 1
+    return randint(minimum, maximum)
+
+
+def get_random_float(value_schema: Dict[str, Any]) -> float:
+    """Generate a random float within the min/max range of the schema, if specified."""
+    # Python floats are already double precision, so no check for "format"
+    minimum = value_schema.get("minimum")
+    maximum = value_schema.get("maximum")
+    if minimum is None:
+        if maximum is None:
+            minimum = -1.0
+            maximum = 1.0
+        else:
+            minimum = maximum - 1.0
+    else:
+        if maximum is None:
+            maximum = minimum + 1.0
+        if maximum < minimum:
+            raise ValueError(f"maximum of {maximum} is less than minimum of {minimum}")
+    # for simplicity's sake, exclude both boundaries if one boundary is exclusive
+    exclusive = value_schema.get("exclusiveMinimum", False) or value_schema.get(
+        "exclusiveMaximum", False
+    )
+    if exclusive:
+        if minimum == maximum:
+            raise ValueError(
+                f"maximum of {maximum} is equal to minimum of {minimum} and "
+                f"exclusiveMinimum or exclusiveMaximum is True"
+            )
+    while exclusive:
+        result = uniform(minimum, maximum)
+        if minimum < result < maximum:  # pragma: no cover
+            return result
+    return uniform(minimum, maximum)
+
+
+def get_random_string(value_schema: Dict[str, Any]) -> str:
+    """Generate a random string within the min/max length in the schema, if specified."""
+    # TODO: byte, binary, date, date-time based on "format"
+    minimum = value_schema.get("minLength", 0)
+    maximum = value_schema.get("maxLength", 36)
+    if minimum > maximum:
+        maximum = minimum
+    value = uuid4().hex
+    while len(value) < minimum:
+        value = value + uuid4().hex
+    if len(value) > maximum:
+        value = value[:maximum]
+    return value
+
+
+def get_invalid_value_from_constraint(
+    values_from_constraint: List[Any], value_type: str
+) -> Any:
+    """
+    Return a value of the same type as the values in the values_from_constraints that
+    is not in the values_from_constraints, if possible. Otherwise returns None.
+    """
+    # if IGNORE is in the values_from_constraints, the parameter needs to be
+    # ignored for an OK response so leaving the value at it's original value
+    # should result in the specified error response
+    if IGNORE in values_from_constraint:
+        return IGNORE
+    # if the value is forced True or False, return the opposite to invalidate
+    if len(values_from_constraint) == 1 and value_type == "boolean":
+        return not values_from_constraint[0]
+    if (
+        value_type not in ["string", "integer", "number", "array"]
+        or not values_from_constraint
+    ):
+        return None
+    invalid_values = 2 * values_from_constraint
+    # None for empty array
+    if not invalid_values:
+        return None
+    invalid_value = invalid_values.pop()
+    if value_type in ["integer", "number"]:
+        for value in invalid_values:
+            invalid_value = abs(invalid_value) + abs(value)
+        if not invalid_value:
+            invalid_value += 1
+        return invalid_value
+    for value in invalid_values:
+        invalid_value = invalid_value + value
+    # None for empty string
+    return invalid_value if invalid_value else None
+
+
+def get_invalid_value_from_enum(values: List[Any], value_type: str):
+    """Return a value not in the enum by combining the enum values."""
+    if value_type == "string":
+        invalid_value: Any = ""
+    elif value_type in ["integer", "number"]:
+        invalid_value = 0
+    elif value_type == "array":
+        invalid_value = []
+    elif value_type == "object":
+        # force creation of a new object since we will be modifing it
+        invalid_value = {**values[0]}
+    else:
+        logger.warning(f"Cannot invalidate enum value with type {value_type}")
+        return None
+    for value in values:
+        if value_type in ["integer", "number"]:
+            invalid_value += abs(value)
+        if value_type == "string":
+            invalid_value += value
+        if value_type == "array":
+            invalid_value.extend(value)
+        # objects are a special case, since they must be of the same type / class
+        # invalid_value.update(value) will end up with the last value in the list,
+        # which is a valid value, so another approach is needed
+        if value_type == "object":
+            for key in invalid_value.keys():
+                invalid_value[key] = value.get(key)
+                if invalid_value not in values:
+                    return invalid_value
+    return invalid_value
+
+
+def get_value_out_of_bounds(value_schema: Dict[str, Any], current_value: Any) -> Any:
+    """
+    Return a value just outside the value or length range if specified in the
+    provided schema, otherwise None is returned.
+    """
+    value_type = value_schema["type"]
+
+    if value_type in ["integer", "number"]:
+        if minimum := value_schema.get("minimum"):
+            return minimum - 1
+        if maximum := value_schema.get("maximum"):
+            return maximum + 1
+        if exclusive_minimum := value_schema.get("exclusiveMinimum"):
+            return exclusive_minimum
+        if exclusive_maximum := value_schema.get("exclusiveMaximum"):
+            return exclusive_maximum
+    if value_type == "string":
+        # if there is a minimum length, send 1 character less
+        if minimum := value_schema.get("minLength", 0):
+            return current_value[0 : minimum - 1]
+        # if there is a maximum length, send 1 character more
+        if maximum := value_schema.get("maxLength"):
+            invalid_value = current_value if current_value else "x"
+            # add random characters from the current value to prevent adding new characters
+            while len(invalid_value) <= maximum:
+                invalid_value += choice(invalid_value)
+            return invalid_value
+    return None
diff --git a/tasks.py b/tasks.py
index f199021..a595bff 100644
--- a/tasks.py
+++ b/tasks.py
@@ -15,7 +15,7 @@ def testserver(context):
 
 
 @task
-def tests(context):
+def utests(context):
     cmd = [
         "coverage",
         "run",
@@ -25,6 +25,10 @@ def tests(context):
         f"{project_root}/tests/unittests",
     ]
     subprocess.run(" ".join(cmd), shell=True)
+
+
+@task
+def atests(context):
     cmd = [
         "coverage",
         "run",
@@ -33,10 +37,14 @@ def tests(context):
         f"--argumentfile={project_root}/tests/rf_cli.args",
         f"--variable=root:{project_root}",
         f"--outputdir={project_root}/tests/logs",
-        f"--loglevel=TRACE:DEBUG",
+        "--loglevel=TRACE:DEBUG",
         f"{project_root}/tests/suites",
     ]
     subprocess.run(" ".join(cmd), shell=True)
+
+
+@task(utests, atests)
+def tests(context):
     subprocess.run("coverage combine", shell=True)
     subprocess.run("coverage report", shell=True)
     subprocess.run("coverage html", shell=True)
@@ -58,7 +66,7 @@ def format_code(context):
 @task
 def libdoc(context):
     json_file = f"{project_root}/tests/files/petstore_openapi.json"
-    source = f"{project_root}/src/OpenApiDriver/openapidriver.py::{json_file}"
+    source = f"OpenApiDriver::{json_file}"
     target = f"{project_root}/docs/openapidriver.html"
     cmd = [
         "python",
@@ -73,7 +81,7 @@ def libdoc(context):
 @task
 def libspec(context):
     json_file = f"{project_root}/tests/files/petstore_openapi.json"
-    source = f"{project_root}/src/OpenApiDriver/openapidriver.py::{json_file}"
+    source = f"OpenApiDriver::{json_file}"
     target = f"{project_root}/src/OpenApiDriver/openapidriver.libspec"
     cmd = [
         "python",
@@ -87,8 +95,19 @@ def libspec(context):
 
 @task
 def readme(context):
+    #     front_matter = (
+    # r"""---
+    # ![[Unit-tests](https://img.shields.io/github/workflow/status/MarketSquare/robotframework-openapidriver/Unit%20tests/main)](https://github.com/MarketSquare/robotframework-openapidriver/actions?query=workflow%3A%22Unit+tests%22 "GitHub Workflow Unit Tests Status")
+    # ![Codecov](https://img.shields.io/codecov/c/github/MarketSquare/robotframework-openapidriver/main "Code coverage on master branch")
+    # ![PyPI](https://img.shields.io/pypi/v/robotframework-openapidriver?label=version "PyPI package version")
+    # ![Python versions](https://img.shields.io/pypi/pyversions/robotframework-openapidriver "Supported Python versions")
+    # ![Licence](https://img.shields.io/pypi/l/robotframework-openapidriver "PyPI - License")
+    # ---
+    # """)
+    front_matter = """---\n---\n"""
     with open(f"{project_root}/docs/README.md", "w", encoding="utf-8") as readme:
         doc_string = openapidriver.__doc__
+        readme.write(front_matter)
         readme.write(str(doc_string).replace("\\", "\\\\").replace("\\\\*", "\\*"))
 
 
diff --git a/tests/unittests/test_value_utils.py b/tests/unittests/test_value_utils.py
new file mode 100644
index 0000000..1ec8d1f
--- /dev/null
+++ b/tests/unittests/test_value_utils.py
@@ -0,0 +1,657 @@
+import unittest
+from sys import float_info
+
+EPSILON = float_info.epsilon
+
+from OpenApiDriver import IGNORE, value_utils
+
+
+class TestRandomInteger(unittest.TestCase):
+    def test_default_min_max(self):
+        schema = {"maximum": -2147483648}
+        value = value_utils.get_random_int(schema)
+        self.assertEqual(value, -2147483648)
+
+        schema = {"minimum": 2147483647}
+        value = value_utils.get_random_int(schema)
+        self.assertEqual(value, 2147483647)
+
+    def test_exclusive_min_max(self):
+        schema = {"maximum": -2147483647, "exclusiveMaximum": True}
+        value = value_utils.get_random_int(schema)
+        self.assertEqual(value, -2147483648)
+
+        schema = {"minimum": 2147483646, "exclusiveMinimum": True}
+        value = value_utils.get_random_int(schema)
+        self.assertEqual(value, 2147483647)
+
+    def test_min_max(self):
+        schema = {"minimum": 42, "maximum": 42}
+        value = value_utils.get_random_int(schema)
+        self.assertEqual(value, 42)
+
+        schema = {"minimum": -42, "maximum": -42}
+        value = value_utils.get_random_int(schema)
+        self.assertEqual(value, -42)
+
+        schema = {
+            "minimum": 41,
+            "maximum": 43,
+            "exclusiveMinimum": True,
+            "exclusiveMaximum": True,
+        }
+        value = value_utils.get_random_int(schema)
+        self.assertEqual(value, 42)
+
+        schema = {
+            "minimum": -43,
+            "maximum": -41,
+            "exclusiveMinimum": True,
+            "exclusiveMaximum": True,
+        }
+        value = value_utils.get_random_int(schema)
+        self.assertEqual(value, -42)
+
+    def test_int64(self):
+        schema = {"maximum": -9223372036854775808, "format": "int64"}
+        value = value_utils.get_random_int(schema)
+        self.assertEqual(value, -9223372036854775808)
+
+        schema = {"minimum": 9223372036854775807, "format": "int64"}
+        value = value_utils.get_random_int(schema)
+        self.assertEqual(value, 9223372036854775807)
+
+
+class TestRandomFloat(unittest.TestCase):
+    def test_default_min_max(self):
+        schema = {}
+        value = value_utils.get_random_float(schema)
+        self.assertGreaterEqual(value, -1.0)
+        self.assertLessEqual(value, 1.0)
+
+        schema = {"minimum": -2.0}
+        value = value_utils.get_random_float(schema)
+        self.assertGreaterEqual(value, -2.0)
+        self.assertLessEqual(value, -1.0)
+
+        schema = {"maximum": -2.0}
+        value = value_utils.get_random_float(schema)
+        self.assertGreaterEqual(value, -3.0)
+        self.assertLessEqual(value, -2.0)
+
+    def test_exclusive_min_max(self):
+        schema = {
+            "minimum": 1.0 - EPSILON,
+            "maximum": 1.0 + EPSILON,
+            "exclusiveMinimum": True,
+        }
+        value = value_utils.get_random_float(schema)
+        self.assertAlmostEqual(value, 1.0)
+
+        schema = {
+            "minimum": -1.0 - EPSILON,
+            "maximum": -1.0 + EPSILON,
+            "exclusiveMaximum": True,
+        }
+        value = value_utils.get_random_float(schema)
+        self.assertAlmostEqual(value, -1.0)
+
+    def test_raises(self):
+        schema = {"minimum": 1.0 + EPSILON, "maximum": 1.0}
+        self.assertRaises(ValueError, value_utils.get_random_float, schema)
+
+        schema = {"minimum": -1.0, "maximum": -1.0 - EPSILON}
+        self.assertRaises(ValueError, value_utils.get_random_float, schema)
+
+        schema = {"minimum": 1.0, "maximum": 1.0, "exclusiveMinimum": True}
+        self.assertRaises(ValueError, value_utils.get_random_float, schema)
+
+        schema = {"minimum": 1.0, "maximum": 1.0, "exclusiveMaximum": True}
+        self.assertRaises(ValueError, value_utils.get_random_float, schema)
+
+    def test_min_max(self):
+        schema = {"minimum": 1.1, "maximum": 1.1}
+        value = value_utils.get_random_float(schema)
+        self.assertEqual(value, 1.1)
+
+        schema = {"minimum": -1.1, "maximum": -1.1}
+        value = value_utils.get_random_float(schema)
+        self.assertEqual(value, -1.1)
+
+        schema = {"minimum": 2.1, "maximum": 2.2, "exclusiveMinimum": True}
+        value = value_utils.get_random_float(schema)
+        self.assertGreater(value, 2.1)
+        self.assertLess(value, 2.2)
+
+        schema = {"minimum": -0.2, "maximum": -0.1, "exclusiveMaximum": True}
+        value = value_utils.get_random_float(schema)
+        self.assertGreater(value, -0.2)
+        self.assertLess(value, -0.1)
+
+
+class TestRandomString(unittest.TestCase):
+    def test_default_min_max(self):
+        schema = {"maxLength": 0}
+        value = value_utils.get_random_string(schema)
+        self.assertEqual(value, "")
+
+        schema = {"minLength": 36}
+        value = value_utils.get_random_string(schema)
+        self.assertEqual(len(value), 36)
+
+    def test_min_max(self):
+        schema = {"minLength": 42, "maxLength": 42}
+        value = value_utils.get_random_string(schema)
+        self.assertEqual(len(value), 42)
+
+        schema = {"minLength": 42}
+        value = value_utils.get_random_string(schema)
+        self.assertEqual(len(value), 42)
+
+
+class TestGetValidValue(unittest.TestCase):
+    def test_enum(self):
+        schema = {"enum": ["foo", "bar"]}
+        value = value_utils.get_valid_value(schema)
+        self.assertIn(value, ["foo", "bar"])
+
+    def test_bool(self):
+        schema = {"type": "boolean"}
+        value = value_utils.get_valid_value(schema)
+        self.assertIsInstance(value, bool)
+
+    def test_integer(self):
+        schema = {"type": "integer"}
+        value = value_utils.get_valid_value(schema)
+        self.assertIsInstance(value, int)
+
+    def test_number(self):
+        schema = {"type": "number"}
+        value = value_utils.get_valid_value(schema)
+        self.assertIsInstance(value, float)
+
+    def test_string(self):
+        schema = {"type": "string"}
+        value = value_utils.get_valid_value(schema)
+        self.assertIsInstance(value, str)
+
+    def test_raises(self):
+        schema = {"type": "array"}
+        self.assertRaises(NotImplementedError, value_utils.get_valid_value, schema)
+
+
+class TestInvalidValueFromConstraint(unittest.TestCase):
+    def test_ignore(self):
+        values = [42, IGNORE]
+        value = value_utils.get_invalid_value_from_constraint(
+            values_from_constraint=values,
+            value_type="irrelevant",
+        )
+        self.assertEqual(value, IGNORE)
+
+    def test_unsupported(self):
+        values = [{"red": 255, "green": 255, "blue": 255}]
+        value = value_utils.get_invalid_value_from_constraint(
+            values_from_constraint=values,
+            value_type="object",
+        )
+        self.assertEqual(value, None)
+
+    def test_bool(self):
+        values = [True]
+        value = value_utils.get_invalid_value_from_constraint(
+            values_from_constraint=values,
+            value_type="boolean",
+        )
+        self.assertNotIn(value, values)
+        self.assertIsInstance(value, bool)
+
+        values = [False]
+        value = value_utils.get_invalid_value_from_constraint(
+            values_from_constraint=values,
+            value_type="boolean",
+        )
+        self.assertNotIn(value, values)
+        self.assertIsInstance(value, bool)
+
+        values = [True, False]
+        value = value_utils.get_invalid_value_from_constraint(
+            values_from_constraint=values,
+            value_type="boolean",
+        )
+        self.assertEqual(value, None)
+
+    def test_string(self):
+        values = ["foo"]
+        value = value_utils.get_invalid_value_from_constraint(
+            values_from_constraint=values,
+            value_type="string",
+        )
+        self.assertNotIn(value, values)
+        self.assertIsInstance(value, str)
+
+        values = ["foo", "bar", "baz"]
+        value = value_utils.get_invalid_value_from_constraint(
+            values_from_constraint=values,
+            value_type="string",
+        )
+        self.assertNotIn(value, values)
+        self.assertIsInstance(value, str)
+
+        values = [""]
+        value = value_utils.get_invalid_value_from_constraint(
+            values_from_constraint=values,
+            value_type="string",
+        )
+        self.assertEqual(value, None)
+
+    def test_integer(self):
+        values = [0]
+        value = value_utils.get_invalid_value_from_constraint(
+            values_from_constraint=values,
+            value_type="integer",
+        )
+        self.assertNotIn(value, values)
+        self.assertIsInstance(value, int)
+
+        values = [-3, 0, 3]
+        value = value_utils.get_invalid_value_from_constraint(
+            values_from_constraint=values,
+            value_type="integer",
+        )
+        self.assertNotIn(value, values)
+        self.assertIsInstance(value, int)
+
+    def test_number(self):
+        values = [0.0]
+        value = value_utils.get_invalid_value_from_constraint(
+            values_from_constraint=values,
+            value_type="number",
+        )
+        self.assertNotIn(value, values)
+        self.assertIsInstance(value, float)
+
+        values = [-0.1, 0.0, 0.1]
+        value = value_utils.get_invalid_value_from_constraint(
+            values_from_constraint=values,
+            value_type="number",
+        )
+        self.assertNotIn(value, values)
+        self.assertIsInstance(value, float)
+
+    def test_array(self):
+        values = [[42]]
+        value = value_utils.get_invalid_value_from_constraint(
+            values_from_constraint=values,
+            value_type="array",
+        )
+        self.assertNotIn(value, values)
+
+        values = [["spam"], ["ham", "eggs"]]
+        value = value_utils.get_invalid_value_from_constraint(
+            values_from_constraint=values,
+            value_type="array",
+        )
+        self.assertNotIn(value, values)
+
+        values = []
+        value = value_utils.get_invalid_value_from_constraint(
+            values_from_constraint=values,
+            value_type="array",
+        )
+        self.assertEqual(value, None)
+
+
+class TestInvalidValueFromEnum(unittest.TestCase):
+    def test_string(self):
+        value_list = ["foo", "bar"]
+        result = value_utils.get_invalid_value_from_enum(
+            values=value_list,
+            value_type="string",
+        )
+        self.assertNotIn(result, value_list)
+
+    def test_integer(self):
+        value_list = [-1, 0, 1]
+        result = value_utils.get_invalid_value_from_enum(
+            values=value_list,
+            value_type="integer",
+        )
+        self.assertNotIn(result, value_list)
+
+    def test_float(self):
+        value_list = [-0.1, 0, 0.1]
+        result = value_utils.get_invalid_value_from_enum(
+            values=value_list,
+            value_type="integer",
+        )
+        self.assertNotIn(result, value_list)
+
+    def test_array(self):
+        value_list = [["foo", "bar", "baz"], ["spam", "ham", "eggs"]]
+        result = value_utils.get_invalid_value_from_enum(
+            values=value_list,
+            value_type="array",
+        )
+        self.assertNotIn(result, value_list)
+
+    def test_object(self):
+        value_list = [
+            {
+                "red": 255,
+                "blue": 0,
+                "green": 0,
+            },
+            {
+                "red": 0,
+                "blue": 255,
+                "green": 0,
+            },
+            {
+                "red": 0,
+                "blue": 0,
+                "green": 255,
+            },
+        ]
+        result = value_utils.get_invalid_value_from_enum(
+            values=value_list,
+            value_type="object",
+        )
+        self.assertNotIn(result, value_list)
+
+    def test_unsupported(self):
+        value_list = [True, False]
+        result = value_utils.get_invalid_value_from_enum(
+            values=value_list,
+            value_type="bool",
+        )
+        self.assertEqual(result, None)
+
+
+class TestValueOutOfBounds(unittest.TestCase):
+    def test_minimum_integer(self):
+        minimum = -42
+        value_schema = {"type": "integer", "minimum": minimum}
+        current_value = "irrelevant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertLess(value, minimum)
+        self.assertIsInstance(value, int)
+
+        minimum = 3
+        value_schema = {"type": "integer", "minimum": minimum}
+        current_value = "irrelevant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertLess(value, minimum)
+        self.assertIsInstance(value, int)
+
+    def test_minimum_number(self):
+        minimum = -0.6
+        value_schema = {"type": "integer", "minimum": minimum}
+        current_value = "irrelevant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertLess(value, minimum)
+        self.assertIsInstance(value, float)
+
+        minimum = 3.14159
+        value_schema = {"type": "integer", "minimum": minimum}
+        current_value = "irrelevant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertLess(value, minimum)
+        self.assertIsInstance(value, float)
+
+    def test_maximum_integer(self):
+        maximum = -42
+        value_schema = {"type": "integer", "maximum": maximum}
+        current_value = "irrelevant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertGreater(value, maximum)
+        self.assertIsInstance(value, int)
+
+        maximum = 3
+        value_schema = {"type": "integer", "maximum": maximum}
+        current_value = "irrelevant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertGreater(value, maximum)
+        self.assertIsInstance(value, int)
+
+    def test_maximum_number(self):
+        maximum = -0.6
+        value_schema = {"type": "integer", "maximum": maximum}
+        current_value = "irrelevant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertGreater(value, maximum)
+        self.assertIsInstance(value, float)
+
+        maximum = 3.14159
+        value_schema = {"type": "integer", "maximum": maximum}
+        current_value = "irrelevant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertGreater(value, maximum)
+        self.assertIsInstance(value, float)
+
+    def test_exclusive_minimum_integer(self):
+        minimum = -42
+        value_schema = {"type": "integer", "exclusiveMinimum": minimum}
+        current_value = "irrelevant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertEqual(value, minimum)
+        self.assertIsInstance(value, int)
+
+    def test_exclusive_minimum_number(self):
+        minimum = 3.14159
+        value_schema = {"type": "integer", "exclusiveMinimum": minimum}
+        current_value = "irrelevant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertEqual(value, minimum)
+        self.assertIsInstance(value, float)
+
+    def test_exclusive_maximum_integer(self):
+        maximum = -42
+        value_schema = {"type": "integer", "exclusiveMaximum": maximum}
+        current_value = "irrelevant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertEqual(value, maximum)
+        self.assertIsInstance(value, int)
+
+    def test_exclusive_maximum_number(self):
+        maximum = -273.15
+        value_schema = {"type": "integer", "exclusiveMinimum": maximum}
+        current_value = "irrelevant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertEqual(value, maximum)
+        self.assertIsInstance(value, float)
+
+    def test_minimum_length(self):
+        minimum = 1
+        value_schema = {"type": "string", "minLength": minimum}
+        current_value = "irrelevant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertLess(len(value), minimum)
+        self.assertIsInstance(value, str)
+
+    def test_maximum_length(self):
+        maximum = 7
+        value_schema = {"type": "string", "maxLength": maximum}
+        current_value = "valid"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertGreater(len(value), maximum)
+        self.assertIsInstance(value, str)
+
+        maximum = 7
+        value_schema = {"type": "string", "maxLength": maximum}
+        current_value = ""
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertGreater(len(value), maximum)
+        self.assertIsInstance(value, str)
+
+    def test_minimum_zero(self):
+        minimum = 0
+        value_schema = {"type": "string", "minLength": minimum}
+        current_value = "irrelevant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertEqual(value, None)
+
+    def test_maximum_zero(self):
+        maximum = 0
+        value_schema = {"type": "string", "maxLength": maximum}
+        current_value = "irrelevant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertEqual(value, None)
+
+    def test_unbound(self):
+        value_schema = {"type": "integer"}
+        current_value = "irrelvant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertEqual(value, None)
+
+        value_schema = {"type": "number"}
+        current_value = "irrelvant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertEqual(value, None)
+
+        value_schema = {"type": "string"}
+        current_value = "irrelvant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertEqual(value, None)
+
+    def test_unsupported(self):
+        value_schema = {"type": "boolean"}
+        current_value = "irrelevant"
+        value = value_utils.get_value_out_of_bounds(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertEqual(value, None)
+
+
+class TestGetInvalidValue(unittest.TestCase):
+    def test_invalid_from_constraint(self):
+        current_value = "irrelevant"
+        values_from_constraints = [42]
+
+        value_schema = {"type": "integer"}
+        value = value_utils.get_invalid_value(
+            value_schema=value_schema,
+            current_value=current_value,
+            values_from_constraint=values_from_constraints,
+        )
+        self.assertNotIn(value, values_from_constraints)
+        self.assertIsInstance(value, int)
+
+        value_schema = {"type": None}
+        value = value_utils.get_invalid_value(
+            value_schema=value_schema,
+            current_value=current_value,
+            values_from_constraint=values_from_constraints,
+        )
+        self.assertIsInstance(value, str)
+
+    def test_invalid_from_enum(self):
+        enum_values = [0.1, 0.3]
+        current_value = "irrelevant"
+
+        value_schema = {"type": "number", "enum": enum_values}
+        value = value_utils.get_invalid_value(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertNotIn(value, enum_values)
+        self.assertIsInstance(value, float)
+
+        value_schema = {"type": None, "enum": enum_values}
+        value = value_utils.get_invalid_value(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertIsInstance(value, str)
+
+    def test_invalid_from_bounds(self):
+        min_length = 7
+        current_value = "long enough"
+        value_schema = {"type": "string", "minLength": min_length}
+        value = value_utils.get_invalid_value(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertLess(len(value), min_length)
+        self.assertIsInstance(value, str)
+
+        value_schema = {"type": "bytes", "minLength": min_length}
+        value = value_utils.get_invalid_value(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertIsInstance(value, str)
+
+    def test_invalid_string(self):
+        value_schema = {"type": "string"}
+        current_value = "irrelevant"
+        value = value_utils.get_invalid_value(
+            value_schema=value_schema,
+            current_value=current_value,
+        )
+        self.assertNotIsInstance(value, str)
+
+
+if __name__ == "__main__":
+    unittest.main()