chore(rocie-{server,client}): Format code

20 files changed, 970 insertions, 340 deletions

diff --git a/crates/rocie-client/src/apis/api_get_auth_inventory_api.rs b/crates/rocie-client/src/apis/api_get_auth_inventory_api.rs
index 1fd4481..c039b48 100644
--- a/crates/rocie-client/src/apis/api_get_auth_inventory_api.rs
+++ b/crates/rocie-client/src/apis/api_get_auth_inventory_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`amount_by_id`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -35,12 +33,18 @@ pub enum AmountByIdError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn amount_by_id(configuration: &configuration::Configuration, id: models::ProductId) -> Result<models::ProductAmount, Error<AmountByIdError>> {
+pub async fn amount_by_id(
+    configuration: &configuration::Configuration,
+    id: models::ProductId,
+) -> Result<models::ProductAmount, Error<AmountByIdError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_id = id;
 
-    let uri_str = format!("{}/inventory/{id}", configuration.base_path, id=p_path_id.to_string());
+    let uri_str = format!(
+        "{}/inventory/{id}",
+        configuration.base_path,
+        id = p_path_id.to_string()
+    );
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -62,13 +66,24 @@ pub async fn amount_by_id(configuration: &configuration::Configuration, id: mode
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProductAmount`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProductAmount`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `models::ProductAmount`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `models::ProductAmount`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<AmountByIdError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_get_auth_product_api.rs b/crates/rocie-client/src/apis/api_get_auth_product_api.rs
index 5e9b282..50bca5b 100644
--- a/crates/rocie-client/src/apis/api_get_auth_product_api.rs
+++ b/crates/rocie-client/src/apis/api_get_auth_product_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`product_by_id`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -101,12 +99,18 @@ pub enum ProductsWithoutProductParentError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn product_by_id(configuration: &configuration::Configuration, id: models::ProductId) -> Result<models::Product, Error<ProductByIdError>> {
+pub async fn product_by_id(
+    configuration: &configuration::Configuration,
+    id: models::ProductId,
+) -> Result<models::Product, Error<ProductByIdError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_id = id;
 
-    let uri_str = format!("{}/product/by-id/{id}", configuration.base_path, id=p_path_id.to_string());
+    let uri_str = format!(
+        "{}/product/by-id/{id}",
+        configuration.base_path,
+        id = p_path_id.to_string()
+    );
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -128,21 +132,40 @@ pub async fn product_by_id(configuration: &configuration::Configuration, id: mod
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Product`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Product`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `models::Product`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `models::Product`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<ProductByIdError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn product_by_name(configuration: &configuration::Configuration, name: &str) -> Result<models::Product, Error<ProductByNameError>> {
+pub async fn product_by_name(
+    configuration: &configuration::Configuration,
+    name: &str,
+) -> Result<models::Product, Error<ProductByNameError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_name = name;
 
-    let uri_str = format!("{}/product/by-name/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name));
+    let uri_str = format!(
+        "{}/product/by-name/{name}",
+        configuration.base_path,
+        name = crate::apis::urlencode(p_path_name)
+    );
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -164,21 +187,40 @@ pub async fn product_by_name(configuration: &configuration::Configuration, name:
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Product`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Product`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `models::Product`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `models::Product`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<ProductByNameError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn product_suggestion_by_name(configuration: &configuration::Configuration, name: &str) -> Result<Vec<models::Product>, Error<ProductSuggestionByNameError>> {
+pub async fn product_suggestion_by_name(
+    configuration: &configuration::Configuration,
+    name: &str,
+) -> Result<Vec<models::Product>, Error<ProductSuggestionByNameError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_name = name;
 
-    let uri_str = format!("{}/product/by-part-name/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name));
+    let uri_str = format!(
+        "{}/product/by-part-name/{name}",
+        configuration.base_path,
+        name = crate::apis::urlencode(p_path_name)
+    );
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -200,22 +242,41 @@ pub async fn product_suggestion_by_name(configuration: &configuration::Configura
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Product&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Product&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Product&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Product&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<ProductSuggestionByNameError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
 /// This will only return products directly associated with this product parent id
-pub async fn products_by_product_parent_id_direct(configuration: &configuration::Configuration, id: models::ProductParentId) -> Result<Vec<models::Product>, Error<ProductsByProductParentIdDirectError>> {
+pub async fn products_by_product_parent_id_direct(
+    configuration: &configuration::Configuration,
+    id: models::ProductParentId,
+) -> Result<Vec<models::Product>, Error<ProductsByProductParentIdDirectError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_id = id;
 
-    let uri_str = format!("{}/product/by-product-parent-id-direct/{id}", configuration.base_path, id=p_path_id.to_string());
+    let uri_str = format!(
+        "{}/product/by-product-parent-id-direct/{id}",
+        configuration.base_path,
+        id = p_path_id.to_string()
+    );
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -237,22 +298,42 @@ pub async fn products_by_product_parent_id_direct(configuration: &configuration:
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Product&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Product&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Product&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Product&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
-        let entity: Option<ProductsByProductParentIdDirectError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        let entity: Option<ProductsByProductParentIdDirectError> =
+            serde_json::from_str(&content).ok();
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
 /// This will also return all products below this product parent id
-pub async fn products_by_product_parent_id_indirect(configuration: &configuration::Configuration, id: models::ProductParentId) -> Result<Vec<models::Product>, Error<ProductsByProductParentIdIndirectError>> {
+pub async fn products_by_product_parent_id_indirect(
+    configuration: &configuration::Configuration,
+    id: models::ProductParentId,
+) -> Result<Vec<models::Product>, Error<ProductsByProductParentIdIndirectError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_id = id;
 
-    let uri_str = format!("{}/product/by-product-parent-id-indirect/{id}", configuration.base_path, id=p_path_id.to_string());
+    let uri_str = format!(
+        "{}/product/by-product-parent-id-indirect/{id}",
+        configuration.base_path,
+        id = p_path_id.to_string()
+    );
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -274,18 +355,32 @@ pub async fn products_by_product_parent_id_indirect(configuration: &configuratio
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Product&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Product&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Product&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Product&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
-        let entity: Option<ProductsByProductParentIdIndirectError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        let entity: Option<ProductsByProductParentIdIndirectError> =
+            serde_json::from_str(&content).ok();
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn products_in_storage(configuration: &configuration::Configuration, ) -> Result<Vec<models::Product>, Error<ProductsInStorageError>> {
-
+pub async fn products_in_storage(
+    configuration: &configuration::Configuration,
+) -> Result<Vec<models::Product>, Error<ProductsInStorageError>> {
     let uri_str = format!("{}/products_in_storage/", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
@@ -308,18 +403,31 @@ pub async fn products_in_storage(configuration: &configuration::Configuration, )
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Product&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Product&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Product&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Product&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<ProductsInStorageError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn products_registered(configuration: &configuration::Configuration, ) -> Result<Vec<models::Product>, Error<ProductsRegisteredError>> {
-
+pub async fn products_registered(
+    configuration: &configuration::Configuration,
+) -> Result<Vec<models::Product>, Error<ProductsRegisteredError>> {
     let uri_str = format!("{}/products_registered/", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
@@ -342,19 +450,32 @@ pub async fn products_registered(configuration: &configuration::Configuration, )
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Product&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Product&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Product&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Product&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<ProductsRegisteredError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
 /// This will only return products without a product parent associated with it
-pub async fn products_without_product_parent(configuration: &configuration::Configuration, ) -> Result<Vec<models::Product>, Error<ProductsWithoutProductParentError>> {
-
+pub async fn products_without_product_parent(
+    configuration: &configuration::Configuration,
+) -> Result<Vec<models::Product>, Error<ProductsWithoutProductParentError>> {
     let uri_str = format!("{}/product/without-product-parent", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
@@ -377,13 +498,24 @@ pub async fn products_without_product_parent(configuration: &configuration::Conf
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Product&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Product&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Product&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Product&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<ProductsWithoutProductParentError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_get_auth_product_parent_api.rs b/crates/rocie-client/src/apis/api_get_auth_product_parent_api.rs
index f244dd1..c087a64 100644
--- a/crates/rocie-client/src/apis/api_get_auth_product_parent_api.rs
+++ b/crates/rocie-client/src/apis/api_get_auth_product_parent_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`product_parents`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -52,9 +50,9 @@ pub enum ProductParentsUnderError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn product_parents(configuration: &configuration::Configuration, ) -> Result<Vec<models::ProductParent>, Error<ProductParentsError>> {
-
+pub async fn product_parents(
+    configuration: &configuration::Configuration,
+) -> Result<Vec<models::ProductParent>, Error<ProductParentsError>> {
     let uri_str = format!("{}/product_parents/", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
@@ -77,18 +75,31 @@ pub async fn product_parents(configuration: &configuration::Configuration, ) ->
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::ProductParent&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::ProductParent&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::ProductParent&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::ProductParent&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<ProductParentsError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn product_parents_toplevel(configuration: &configuration::Configuration, ) -> Result<Vec<models::ProductParent>, Error<ProductParentsToplevelError>> {
-
+pub async fn product_parents_toplevel(
+    configuration: &configuration::Configuration,
+) -> Result<Vec<models::ProductParent>, Error<ProductParentsToplevelError>> {
     let uri_str = format!("{}/product_parents_toplevel/", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
@@ -111,21 +122,40 @@ pub async fn product_parents_toplevel(configuration: &configuration::Configurati
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::ProductParent&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::ProductParent&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::ProductParent&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::ProductParent&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<ProductParentsToplevelError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn product_parents_under(configuration: &configuration::Configuration, id: models::ProductParentId) -> Result<Vec<models::ProductParent>, Error<ProductParentsUnderError>> {
+pub async fn product_parents_under(
+    configuration: &configuration::Configuration,
+    id: models::ProductParentId,
+) -> Result<Vec<models::ProductParent>, Error<ProductParentsUnderError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_id = id;
 
-    let uri_str = format!("{}/product_parents_under/{id}", configuration.base_path, id=p_path_id.to_string());
+    let uri_str = format!(
+        "{}/product_parents_under/{id}",
+        configuration.base_path,
+        id = p_path_id.to_string()
+    );
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -147,13 +177,24 @@ pub async fn product_parents_under(configuration: &configuration::Configuration,
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::ProductParent&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::ProductParent&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::ProductParent&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::ProductParent&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<ProductParentsUnderError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_get_auth_recipe_api.rs b/crates/rocie-client/src/apis/api_get_auth_recipe_api.rs
index e93ab4e..f74eea5 100644
--- a/crates/rocie-client/src/apis/api_get_auth_recipe_api.rs
+++ b/crates/rocie-client/src/apis/api_get_auth_recipe_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`recipe_by_id`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -83,12 +81,18 @@ pub enum RecipesWithoutRecipeParentError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn recipe_by_id(configuration: &configuration::Configuration, id: models::RecipeId) -> Result<models::Recipe, Error<RecipeByIdError>> {
+pub async fn recipe_by_id(
+    configuration: &configuration::Configuration,
+    id: models::RecipeId,
+) -> Result<models::Recipe, Error<RecipeByIdError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_id = id;
 
-    let uri_str = format!("{}/recipe/by-id/{id}", configuration.base_path, id=p_path_id.to_string());
+    let uri_str = format!(
+        "{}/recipe/by-id/{id}",
+        configuration.base_path,
+        id = p_path_id.to_string()
+    );
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -110,21 +114,40 @@ pub async fn recipe_by_id(configuration: &configuration::Configuration, id: mode
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Recipe`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Recipe`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `models::Recipe`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `models::Recipe`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<RecipeByIdError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn recipe_by_name(configuration: &configuration::Configuration, name: &str) -> Result<models::Recipe, Error<RecipeByNameError>> {
+pub async fn recipe_by_name(
+    configuration: &configuration::Configuration,
+    name: &str,
+) -> Result<models::Recipe, Error<RecipeByNameError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_name = name;
 
-    let uri_str = format!("{}/recipe/by-name/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name));
+    let uri_str = format!(
+        "{}/recipe/by-name/{name}",
+        configuration.base_path,
+        name = crate::apis::urlencode(p_path_name)
+    );
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -146,18 +169,31 @@ pub async fn recipe_by_name(configuration: &configuration::Configuration, name:
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Recipe`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Recipe`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `models::Recipe`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `models::Recipe`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<RecipeByNameError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn recipes(configuration: &configuration::Configuration, ) -> Result<Vec<models::Recipe>, Error<RecipesError>> {
-
+pub async fn recipes(
+    configuration: &configuration::Configuration,
+) -> Result<Vec<models::Recipe>, Error<RecipesError>> {
     let uri_str = format!("{}/recipe/all", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
@@ -180,22 +216,41 @@ pub async fn recipes(configuration: &configuration::Configuration, ) -> Result<V
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Recipe&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Recipe&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Recipe&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Recipe&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<RecipesError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
 /// This will only return recipes directly associated with this recipe parent id
-pub async fn recipes_by_recipe_parent_id_direct(configuration: &configuration::Configuration, id: models::RecipeParentId) -> Result<Vec<models::Recipe>, Error<RecipesByRecipeParentIdDirectError>> {
+pub async fn recipes_by_recipe_parent_id_direct(
+    configuration: &configuration::Configuration,
+    id: models::RecipeParentId,
+) -> Result<Vec<models::Recipe>, Error<RecipesByRecipeParentIdDirectError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_id = id;
 
-    let uri_str = format!("{}/recipe/by-recipe-parent-id-direct/{id}", configuration.base_path, id=p_path_id.to_string());
+    let uri_str = format!(
+        "{}/recipe/by-recipe-parent-id-direct/{id}",
+        configuration.base_path,
+        id = p_path_id.to_string()
+    );
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -217,22 +272,42 @@ pub async fn recipes_by_recipe_parent_id_direct(configuration: &configuration::C
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Recipe&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Recipe&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Recipe&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Recipe&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
-        let entity: Option<RecipesByRecipeParentIdDirectError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        let entity: Option<RecipesByRecipeParentIdDirectError> =
+            serde_json::from_str(&content).ok();
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
 /// This will also return all recipes below this recipe parent id
-pub async fn recipes_by_recipe_parent_id_indirect(configuration: &configuration::Configuration, id: models::RecipeParentId) -> Result<Vec<models::Recipe>, Error<RecipesByRecipeParentIdIndirectError>> {
+pub async fn recipes_by_recipe_parent_id_indirect(
+    configuration: &configuration::Configuration,
+    id: models::RecipeParentId,
+) -> Result<Vec<models::Recipe>, Error<RecipesByRecipeParentIdIndirectError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_id = id;
 
-    let uri_str = format!("{}/recipe/by-recipe-parent-id-indirect/{id}", configuration.base_path, id=p_path_id.to_string());
+    let uri_str = format!(
+        "{}/recipe/by-recipe-parent-id-indirect/{id}",
+        configuration.base_path,
+        id = p_path_id.to_string()
+    );
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -254,19 +329,33 @@ pub async fn recipes_by_recipe_parent_id_indirect(configuration: &configuration:
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Recipe&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Recipe&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Recipe&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Recipe&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
-        let entity: Option<RecipesByRecipeParentIdIndirectError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        let entity: Option<RecipesByRecipeParentIdIndirectError> =
+            serde_json::from_str(&content).ok();
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
 /// This will only return recipes without a recipe parent associated with it
-pub async fn recipes_without_recipe_parent(configuration: &configuration::Configuration, ) -> Result<Vec<models::Recipe>, Error<RecipesWithoutRecipeParentError>> {
-
+pub async fn recipes_without_recipe_parent(
+    configuration: &configuration::Configuration,
+) -> Result<Vec<models::Recipe>, Error<RecipesWithoutRecipeParentError>> {
     let uri_str = format!("{}/recipe/without-recipe-parent", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
@@ -289,13 +378,24 @@ pub async fn recipes_without_recipe_parent(configuration: &configuration::Config
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Recipe&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Recipe&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Recipe&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Recipe&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<RecipesWithoutRecipeParentError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_get_auth_recipe_parent_api.rs b/crates/rocie-client/src/apis/api_get_auth_recipe_parent_api.rs
index 9faf35e..174cc78 100644
--- a/crates/rocie-client/src/apis/api_get_auth_recipe_parent_api.rs
+++ b/crates/rocie-client/src/apis/api_get_auth_recipe_parent_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`recipe_parents`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -52,9 +50,9 @@ pub enum RecipeParentsUnderError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn recipe_parents(configuration: &configuration::Configuration, ) -> Result<Vec<models::RecipeParent>, Error<RecipeParentsError>> {
-
+pub async fn recipe_parents(
+    configuration: &configuration::Configuration,
+) -> Result<Vec<models::RecipeParent>, Error<RecipeParentsError>> {
     let uri_str = format!("{}/recipe_parents/", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
@@ -77,18 +75,31 @@ pub async fn recipe_parents(configuration: &configuration::Configuration, ) -> R
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::RecipeParent&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::RecipeParent&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::RecipeParent&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::RecipeParent&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<RecipeParentsError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn recipe_parents_toplevel(configuration: &configuration::Configuration, ) -> Result<Vec<models::RecipeParent>, Error<RecipeParentsToplevelError>> {
-
+pub async fn recipe_parents_toplevel(
+    configuration: &configuration::Configuration,
+) -> Result<Vec<models::RecipeParent>, Error<RecipeParentsToplevelError>> {
     let uri_str = format!("{}/recipe_parents_toplevel/", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
@@ -111,21 +122,40 @@ pub async fn recipe_parents_toplevel(configuration: &configuration::Configuratio
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::RecipeParent&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::RecipeParent&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::RecipeParent&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::RecipeParent&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<RecipeParentsToplevelError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn recipe_parents_under(configuration: &configuration::Configuration, id: models::RecipeParentId) -> Result<Vec<models::RecipeParent>, Error<RecipeParentsUnderError>> {
+pub async fn recipe_parents_under(
+    configuration: &configuration::Configuration,
+    id: models::RecipeParentId,
+) -> Result<Vec<models::RecipeParent>, Error<RecipeParentsUnderError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_id = id;
 
-    let uri_str = format!("{}/recipe_parents_under/{id}", configuration.base_path, id=p_path_id.to_string());
+    let uri_str = format!(
+        "{}/recipe_parents_under/{id}",
+        configuration.base_path,
+        id = p_path_id.to_string()
+    );
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -147,13 +177,24 @@ pub async fn recipe_parents_under(configuration: &configuration::Configuration,
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::RecipeParent&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::RecipeParent&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::RecipeParent&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::RecipeParent&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<RecipeParentsUnderError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_get_auth_refined_recipe_api.rs b/crates/rocie-client/src/apis/api_get_auth_refined_recipe_api.rs
index 9e73d20..0d5f0f8 100644
--- a/crates/rocie-client/src/apis/api_get_auth_refined_recipe_api.rs
+++ b/crates/rocie-client/src/apis/api_get_auth_refined_recipe_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`refined_recipe_by_id`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -35,12 +33,18 @@ pub enum RefinedRecipeByIdError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn refined_recipe_by_id(configuration: &configuration::Configuration, id: models::RecipeId) -> Result<models::RefinedRecipe, Error<RefinedRecipeByIdError>> {
+pub async fn refined_recipe_by_id(
+    configuration: &configuration::Configuration,
+    id: models::RecipeId,
+) -> Result<models::RefinedRecipe, Error<RefinedRecipeByIdError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_id = id;
 
-    let uri_str = format!("{}/refined-recipe/by-id/{id}", configuration.base_path, id=p_path_id.to_string());
+    let uri_str = format!(
+        "{}/refined-recipe/by-id/{id}",
+        configuration.base_path,
+        id = p_path_id.to_string()
+    );
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -62,13 +66,24 @@ pub async fn refined_recipe_by_id(configuration: &configuration::Configuration,
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RefinedRecipe`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RefinedRecipe`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `models::RefinedRecipe`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `models::RefinedRecipe`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<RefinedRecipeByIdError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_get_auth_unit_api.rs b/crates/rocie-client/src/apis/api_get_auth_unit_api.rs
index ded03f4..498d77d 100644
--- a/crates/rocie-client/src/apis/api_get_auth_unit_api.rs
+++ b/crates/rocie-client/src/apis/api_get_auth_unit_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`unit_by_id`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -53,12 +51,18 @@ pub enum UnitsByPropertyIdError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn unit_by_id(configuration: &configuration::Configuration, id: models::UnitId) -> Result<models::Unit, Error<UnitByIdError>> {
+pub async fn unit_by_id(
+    configuration: &configuration::Configuration,
+    id: models::UnitId,
+) -> Result<models::Unit, Error<UnitByIdError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_id = id;
 
-    let uri_str = format!("{}/unit/{id}", configuration.base_path, id=p_path_id.to_string());
+    let uri_str = format!(
+        "{}/unit/{id}",
+        configuration.base_path,
+        id = p_path_id.to_string()
+    );
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -80,18 +84,31 @@ pub async fn unit_by_id(configuration: &configuration::Configuration, id: models
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Unit`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Unit`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `models::Unit`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `models::Unit`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<UnitByIdError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn units(configuration: &configuration::Configuration, ) -> Result<Vec<models::Unit>, Error<UnitsError>> {
-
+pub async fn units(
+    configuration: &configuration::Configuration,
+) -> Result<Vec<models::Unit>, Error<UnitsError>> {
     let uri_str = format!("{}/units/", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
@@ -114,21 +131,40 @@ pub async fn units(configuration: &configuration::Configuration, ) -> Result<Vec
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Unit&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Unit&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Unit&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Unit&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<UnitsError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn units_by_property_id(configuration: &configuration::Configuration, id: models::UnitPropertyId) -> Result<Vec<models::Unit>, Error<UnitsByPropertyIdError>> {
+pub async fn units_by_property_id(
+    configuration: &configuration::Configuration,
+    id: models::UnitPropertyId,
+) -> Result<Vec<models::Unit>, Error<UnitsByPropertyIdError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_id = id;
 
-    let uri_str = format!("{}/units-by-property/{id}", configuration.base_path, id=p_path_id.to_string());
+    let uri_str = format!(
+        "{}/units-by-property/{id}",
+        configuration.base_path,
+        id = p_path_id.to_string()
+    );
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -150,13 +186,24 @@ pub async fn units_by_property_id(configuration: &configuration::Configuration,
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Unit&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Unit&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Unit&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Unit&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<UnitsByPropertyIdError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_get_auth_unit_property_api.rs b/crates/rocie-client/src/apis/api_get_auth_unit_property_api.rs
index 76d5e4f..eab0684 100644
--- a/crates/rocie-client/src/apis/api_get_auth_unit_property_api.rs
+++ b/crates/rocie-client/src/apis/api_get_auth_unit_property_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`unit_properties`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -44,9 +42,9 @@ pub enum UnitPropertyByIdError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn unit_properties(configuration: &configuration::Configuration, ) -> Result<Vec<models::UnitProperty>, Error<UnitPropertiesError>> {
-
+pub async fn unit_properties(
+    configuration: &configuration::Configuration,
+) -> Result<Vec<models::UnitProperty>, Error<UnitPropertiesError>> {
     let uri_str = format!("{}/unit-properties/", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
@@ -69,21 +67,40 @@ pub async fn unit_properties(configuration: &configuration::Configuration, ) ->
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::UnitProperty&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::UnitProperty&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::UnitProperty&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::UnitProperty&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<UnitPropertiesError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn unit_property_by_id(configuration: &configuration::Configuration, id: models::UnitPropertyId) -> Result<models::UnitProperty, Error<UnitPropertyByIdError>> {
+pub async fn unit_property_by_id(
+    configuration: &configuration::Configuration,
+    id: models::UnitPropertyId,
+) -> Result<models::UnitProperty, Error<UnitPropertyByIdError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_id = id;
 
-    let uri_str = format!("{}/unit-property/{id}", configuration.base_path, id=p_path_id.to_string());
+    let uri_str = format!(
+        "{}/unit-property/{id}",
+        configuration.base_path,
+        id = p_path_id.to_string()
+    );
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -105,13 +122,24 @@ pub async fn unit_property_by_id(configuration: &configuration::Configuration, i
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UnitProperty`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UnitProperty`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `models::UnitProperty`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `models::UnitProperty`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<UnitPropertyByIdError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_get_auth_user_api.rs b/crates/rocie-client/src/apis/api_get_auth_user_api.rs
index 97091aa..da4ce28 100644
--- a/crates/rocie-client/src/apis/api_get_auth_user_api.rs
+++ b/crates/rocie-client/src/apis/api_get_auth_user_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`user_by_id`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -45,12 +43,18 @@ pub enum UsersError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn user_by_id(configuration: &configuration::Configuration, id: models::UserId) -> Result<models::User, Error<UserByIdError>> {
+pub async fn user_by_id(
+    configuration: &configuration::Configuration,
+    id: models::UserId,
+) -> Result<models::User, Error<UserByIdError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_id = id;
 
-    let uri_str = format!("{}/user/{id}", configuration.base_path, id=p_path_id.to_string());
+    let uri_str = format!(
+        "{}/user/{id}",
+        configuration.base_path,
+        id = p_path_id.to_string()
+    );
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -72,18 +76,31 @@ pub async fn user_by_id(configuration: &configuration::Configuration, id: models
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::User`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::User`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `models::User`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `models::User`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<UserByIdError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn users(configuration: &configuration::Configuration, ) -> Result<Vec<models::User>, Error<UsersError>> {
-
+pub async fn users(
+    configuration: &configuration::Configuration,
+) -> Result<Vec<models::User>, Error<UsersError>> {
     let uri_str = format!("{}/users", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
@@ -106,13 +123,24 @@ pub async fn users(configuration: &configuration::Configuration, ) -> Result<Vec
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::User&gt;`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::User&gt;`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `Vec&lt;models::User&gt;`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::User&gt;`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<UsersError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_get_no_auth_state_api.rs b/crates/rocie-client/src/apis/api_get_no_auth_state_api.rs
index 72dadc5..6eb8ad0 100644
--- a/crates/rocie-client/src/apis/api_get_no_auth_state_api.rs
+++ b/crates/rocie-client/src/apis/api_get_no_auth_state_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`can_be_provisioned`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -40,9 +38,9 @@ pub enum IsLoggedInError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn can_be_provisioned(configuration: &configuration::Configuration, ) -> Result<bool, Error<CanBeProvisionedError>> {
-
+pub async fn can_be_provisioned(
+    configuration: &configuration::Configuration,
+) -> Result<bool, Error<CanBeProvisionedError>> {
     let uri_str = format!("{}/can-be-provisioned", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
@@ -65,18 +63,31 @@ pub async fn can_be_provisioned(configuration: &configuration::Configuration, )
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `bool`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `bool`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<CanBeProvisionedError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn is_logged_in(configuration: &configuration::Configuration, ) -> Result<bool, Error<IsLoggedInError>> {
-
+pub async fn is_logged_in(
+    configuration: &configuration::Configuration,
+) -> Result<bool, Error<IsLoggedInError>> {
     let uri_str = format!("{}/is-logged-in", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
@@ -99,13 +110,24 @@ pub async fn is_logged_in(configuration: &configuration::Configuration, ) -> Res
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `bool`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `bool`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<IsLoggedInError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_set_auth_barcode_api.rs b/crates/rocie-client/src/apis/api_set_auth_barcode_api.rs
index 63c4a11..9984ab7 100644
--- a/crates/rocie-client/src/apis/api_set_auth_barcode_api.rs
+++ b/crates/rocie-client/src/apis/api_set_auth_barcode_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`buy_barcode`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -45,14 +43,24 @@ pub enum ConsumeBarcodeError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn buy_barcode(configuration: &configuration::Configuration, barcode_id: models::BarcodeId, times: u32) -> Result<(), Error<BuyBarcodeError>> {
+pub async fn buy_barcode(
+    configuration: &configuration::Configuration,
+    barcode_id: models::BarcodeId,
+    times: u32,
+) -> Result<(), Error<BuyBarcodeError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_barcode_id = barcode_id;
     let p_path_times = times;
 
-    let uri_str = format!("{}/barcode/{barcode_id}/buy/{times}", configuration.base_path, barcode_id=p_path_barcode_id.to_string(), times=p_path_times);
-    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
+    let uri_str = format!(
+        "{}/barcode/{barcode_id}/buy/{times}",
+        configuration.base_path,
+        barcode_id = p_path_barcode_id.to_string(),
+        times = p_path_times
+    );
+    let mut req_builder = configuration
+        .client
+        .request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
@@ -68,17 +76,31 @@ pub async fn buy_barcode(configuration: &configuration::Configuration, barcode_i
     } else {
         let content = resp.text().await?;
         let entity: Option<BuyBarcodeError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn consume_barcode(configuration: &configuration::Configuration, id: models::BarcodeId, unit_amount: models::UnitAmount) -> Result<(), Error<ConsumeBarcodeError>> {
+pub async fn consume_barcode(
+    configuration: &configuration::Configuration,
+    id: models::BarcodeId,
+    unit_amount: models::UnitAmount,
+) -> Result<(), Error<ConsumeBarcodeError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_id = id;
     let p_body_unit_amount = unit_amount;
 
-    let uri_str = format!("{}/barcode/{id}/consume", configuration.base_path, id=p_path_id.to_string());
-    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
+    let uri_str = format!(
+        "{}/barcode/{id}/consume",
+        configuration.base_path,
+        id = p_path_id.to_string()
+    );
+    let mut req_builder = configuration
+        .client
+        .request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
@@ -95,7 +117,10 @@ pub async fn consume_barcode(configuration: &configuration::Configuration, id: m
     } else {
         let content = resp.text().await?;
         let entity: Option<ConsumeBarcodeError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_set_auth_product_api.rs b/crates/rocie-client/src/apis/api_set_auth_product_api.rs
index ace3ffa..ddfdb66 100644
--- a/crates/rocie-client/src/apis/api_set_auth_product_api.rs
+++ b/crates/rocie-client/src/apis/api_set_auth_product_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`associate_barcode`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -45,14 +43,23 @@ pub enum RegisterProductError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn associate_barcode(configuration: &configuration::Configuration, id: models::ProductId, barcode: models::Barcode) -> Result<(), Error<AssociateBarcodeError>> {
+pub async fn associate_barcode(
+    configuration: &configuration::Configuration,
+    id: models::ProductId,
+    barcode: models::Barcode,
+) -> Result<(), Error<AssociateBarcodeError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_path_id = id;
     let p_body_barcode = barcode;
 
-    let uri_str = format!("{}/product/{id}/associate", configuration.base_path, id=p_path_id.to_string());
-    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
+    let uri_str = format!(
+        "{}/product/{id}/associate",
+        configuration.base_path,
+        id = p_path_id.to_string()
+    );
+    let mut req_builder = configuration
+        .client
+        .request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
@@ -69,16 +76,25 @@ pub async fn associate_barcode(configuration: &configuration::Configuration, id:
     } else {
         let content = resp.text().await?;
         let entity: Option<AssociateBarcodeError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn register_product(configuration: &configuration::Configuration, product_stub: models::ProductStub) -> Result<models::ProductId, Error<RegisterProductError>> {
+pub async fn register_product(
+    configuration: &configuration::Configuration,
+    product_stub: models::ProductStub,
+) -> Result<models::ProductId, Error<RegisterProductError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_body_product_stub = product_stub;
 
     let uri_str = format!("{}/product/new", configuration.base_path);
-    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
+    let mut req_builder = configuration
+        .client
+        .request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
@@ -100,13 +116,24 @@ pub async fn register_product(configuration: &configuration::Configuration, prod
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProductId`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProductId`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `models::ProductId`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `models::ProductId`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<RegisterProductError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_set_auth_product_parent_api.rs b/crates/rocie-client/src/apis/api_set_auth_product_parent_api.rs
index 9524b4d..e51a8d1 100644
--- a/crates/rocie-client/src/apis/api_set_auth_product_parent_api.rs
+++ b/crates/rocie-client/src/apis/api_set_auth_product_parent_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`register_product_parent`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -34,13 +32,17 @@ pub enum RegisterProductParentError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn register_product_parent(configuration: &configuration::Configuration, product_parent_stub: models::ProductParentStub) -> Result<models::ProductParentId, Error<RegisterProductParentError>> {
+pub async fn register_product_parent(
+    configuration: &configuration::Configuration,
+    product_parent_stub: models::ProductParentStub,
+) -> Result<models::ProductParentId, Error<RegisterProductParentError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_body_product_parent_stub = product_parent_stub;
 
     let uri_str = format!("{}/product_parent/new", configuration.base_path);
-    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
+    let mut req_builder = configuration
+        .client
+        .request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
@@ -62,13 +64,24 @@ pub async fn register_product_parent(configuration: &configuration::Configuratio
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProductParentId`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProductParentId`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `models::ProductParentId`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `models::ProductParentId`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<RegisterProductParentError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_set_auth_recipe_api.rs b/crates/rocie-client/src/apis/api_set_auth_recipe_api.rs
index da57874..589e165 100644
--- a/crates/rocie-client/src/apis/api_set_auth_recipe_api.rs
+++ b/crates/rocie-client/src/apis/api_set_auth_recipe_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`add_recipe`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -34,13 +32,17 @@ pub enum AddRecipeError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn add_recipe(configuration: &configuration::Configuration, recipe_stub: models::RecipeStub) -> Result<models::RecipeId, Error<AddRecipeError>> {
+pub async fn add_recipe(
+    configuration: &configuration::Configuration,
+    recipe_stub: models::RecipeStub,
+) -> Result<models::RecipeId, Error<AddRecipeError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_body_recipe_stub = recipe_stub;
 
     let uri_str = format!("{}/recipe/new", configuration.base_path);
-    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
+    let mut req_builder = configuration
+        .client
+        .request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
@@ -62,13 +64,24 @@ pub async fn add_recipe(configuration: &configuration::Configuration, recipe_stu
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RecipeId`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RecipeId`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `models::RecipeId`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `models::RecipeId`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<AddRecipeError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_set_auth_recipe_parent_api.rs b/crates/rocie-client/src/apis/api_set_auth_recipe_parent_api.rs
index 790a57f..9e1b06b 100644
--- a/crates/rocie-client/src/apis/api_set_auth_recipe_parent_api.rs
+++ b/crates/rocie-client/src/apis/api_set_auth_recipe_parent_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`register_recipe_parent`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -34,13 +32,17 @@ pub enum RegisterRecipeParentError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn register_recipe_parent(configuration: &configuration::Configuration, recipe_parent_stub: models::RecipeParentStub) -> Result<models::RecipeParentId, Error<RegisterRecipeParentError>> {
+pub async fn register_recipe_parent(
+    configuration: &configuration::Configuration,
+    recipe_parent_stub: models::RecipeParentStub,
+) -> Result<models::RecipeParentId, Error<RegisterRecipeParentError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_body_recipe_parent_stub = recipe_parent_stub;
 
     let uri_str = format!("{}/recipe_parent/new", configuration.base_path);
-    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
+    let mut req_builder = configuration
+        .client
+        .request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
@@ -62,13 +64,24 @@ pub async fn register_recipe_parent(configuration: &configuration::Configuration
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RecipeParentId`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RecipeParentId`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `models::RecipeParentId`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `models::RecipeParentId`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<RegisterRecipeParentError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_set_auth_unit_api.rs b/crates/rocie-client/src/apis/api_set_auth_unit_api.rs
index 5207327..4a4b7cf 100644
--- a/crates/rocie-client/src/apis/api_set_auth_unit_api.rs
+++ b/crates/rocie-client/src/apis/api_set_auth_unit_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`register_unit`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -34,13 +32,17 @@ pub enum RegisterUnitError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn register_unit(configuration: &configuration::Configuration, unit_stub: models::UnitStub) -> Result<models::UnitId, Error<RegisterUnitError>> {
+pub async fn register_unit(
+    configuration: &configuration::Configuration,
+    unit_stub: models::UnitStub,
+) -> Result<models::UnitId, Error<RegisterUnitError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_body_unit_stub = unit_stub;
 
     let uri_str = format!("{}/unit/new", configuration.base_path);
-    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
+    let mut req_builder = configuration
+        .client
+        .request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
@@ -62,13 +64,24 @@ pub async fn register_unit(configuration: &configuration::Configuration, unit_st
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UnitId`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UnitId`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `models::UnitId`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `models::UnitId`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<RegisterUnitError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_set_auth_unit_property_api.rs b/crates/rocie-client/src/apis/api_set_auth_unit_property_api.rs
index b5e815e..5771670 100644
--- a/crates/rocie-client/src/apis/api_set_auth_unit_property_api.rs
+++ b/crates/rocie-client/src/apis/api_set_auth_unit_property_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`register_unit_property`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -34,13 +32,17 @@ pub enum RegisterUnitPropertyError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn register_unit_property(configuration: &configuration::Configuration, unit_property_stub: models::UnitPropertyStub) -> Result<models::UnitPropertyId, Error<RegisterUnitPropertyError>> {
+pub async fn register_unit_property(
+    configuration: &configuration::Configuration,
+    unit_property_stub: models::UnitPropertyStub,
+) -> Result<models::UnitPropertyId, Error<RegisterUnitPropertyError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_body_unit_property_stub = unit_property_stub;
 
     let uri_str = format!("{}/unit-property/new", configuration.base_path);
-    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
+    let mut req_builder = configuration
+        .client
+        .request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
@@ -62,13 +64,24 @@ pub async fn register_unit_property(configuration: &configuration::Configuration
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UnitPropertyId`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UnitPropertyId`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `models::UnitPropertyId`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `models::UnitPropertyId`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<RegisterUnitPropertyError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_set_auth_user_api.rs b/crates/rocie-client/src/apis/api_set_auth_user_api.rs
index 6cad709..3e683d5 100644
--- a/crates/rocie-client/src/apis/api_set_auth_user_api.rs
+++ b/crates/rocie-client/src/apis/api_set_auth_user_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`register_user`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -34,13 +32,17 @@ pub enum RegisterUserError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn register_user(configuration: &configuration::Configuration, user_stub: models::UserStub) -> Result<models::UserId, Error<RegisterUserError>> {
+pub async fn register_user(
+    configuration: &configuration::Configuration,
+    user_stub: models::UserStub,
+) -> Result<models::UserId, Error<RegisterUserError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_body_user_stub = user_stub;
 
     let uri_str = format!("{}/user/new", configuration.base_path);
-    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
+    let mut req_builder = configuration
+        .client
+        .request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
@@ -62,13 +64,24 @@ pub async fn register_user(configuration: &configuration::Configuration, user_st
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UserId`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UserId`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `models::UserId`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `models::UserId`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<RegisterUserError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/api_set_no_auth_user_api.rs b/crates/rocie-client/src/apis/api_set_no_auth_user_api.rs
index 492a2eb..82275cb 100644
--- a/crates/rocie-client/src/apis/api_set_no_auth_user_api.rs
+++ b/crates/rocie-client/src/apis/api_set_no_auth_user_api.rs
@@ -18,12 +18,10 @@
  * Generated by: https://openapi-generator.tech
  */
 
-
+use super::{ContentType, Error, configuration};
+use crate::{apis::ResponseContent, models};
 use reqwest;
 use serde::{Deserialize, Serialize, de::Error as _};
-use crate::{apis::ResponseContent, models};
-use super::{Error, configuration, ContentType};
-
 
 /// struct for typed errors of method [`login`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -52,13 +50,17 @@ pub enum ProvisionError {
     UnknownValue(serde_json::Value),
 }
 
-
-pub async fn login(configuration: &configuration::Configuration, login_info: models::LoginInfo) -> Result<(), Error<LoginError>> {
+pub async fn login(
+    configuration: &configuration::Configuration,
+    login_info: models::LoginInfo,
+) -> Result<(), Error<LoginError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_body_login_info = login_info;
 
     let uri_str = format!("{}/login", configuration.base_path);
-    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
+    let mut req_builder = configuration
+        .client
+        .request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
@@ -75,14 +77,21 @@ pub async fn login(configuration: &configuration::Configuration, login_info: mod
     } else {
         let content = resp.text().await?;
         let entity: Option<LoginError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
-pub async fn logout(configuration: &configuration::Configuration, ) -> Result<(), Error<LogoutError>> {
-
+pub async fn logout(
+    configuration: &configuration::Configuration,
+) -> Result<(), Error<LogoutError>> {
     let uri_str = format!("{}/logout", configuration.base_path);
-    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
+    let mut req_builder = configuration
+        .client
+        .request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
@@ -98,17 +107,26 @@ pub async fn logout(configuration: &configuration::Configuration, ) -> Result<()
     } else {
         let content = resp.text().await?;
         let entity: Option<LogoutError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
 
 /// This only works, if no users exist yet.
-pub async fn provision(configuration: &configuration::Configuration, provision_info: models::ProvisionInfo) -> Result<models::UserId, Error<ProvisionError>> {
+pub async fn provision(
+    configuration: &configuration::Configuration,
+    provision_info: models::ProvisionInfo,
+) -> Result<models::UserId, Error<ProvisionError>> {
     // add a prefix to parameters to efficiently prevent name collisions
     let p_body_provision_info = provision_info;
 
     let uri_str = format!("{}/provision", configuration.base_path);
-    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
+    let mut req_builder = configuration
+        .client
+        .request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
@@ -130,13 +148,24 @@ pub async fn provision(configuration: &configuration::Configuration, provision_i
         let content = resp.text().await?;
         match content_type {
             ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
-            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UserId`"))),
-            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UserId`")))),
+            ContentType::Text => {
+                return Err(Error::from(serde_json::Error::custom(
+                    "Received `text/plain` content type response that cannot be converted to `models::UserId`",
+                )));
+            }
+            ContentType::Unsupported(unknown_type) => {
+                return Err(Error::from(serde_json::Error::custom(format!(
+                    "Received `{unknown_type}` content type response that cannot be converted to `models::UserId`"
+                ))));
+            }
         }
     } else {
         let content = resp.text().await?;
         let entity: Option<ProvisionError> = serde_json::from_str(&content).ok();
-        Err(Error::ResponseError(ResponseContent { status, content, entity }))
+        Err(Error::ResponseError(ResponseContent {
+            status,
+            content,
+            entity,
+        }))
     }
 }
-
diff --git a/crates/rocie-client/src/apis/mod.rs b/crates/rocie-client/src/apis/mod.rs
index 5d2ccaf..c9d6e65 100644
--- a/crates/rocie-client/src/apis/mod.rs
+++ b/crates/rocie-client/src/apis/mod.rs
@@ -26,7 +26,7 @@ pub enum Error<T> {
     ResponseError(ResponseContent<T>),
 }
 
-impl <T> fmt::Display for Error<T> {
+impl<T> fmt::Display for Error<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let (module, e) = match self {
             Error::Reqwest(e) => ("reqwest", e.to_string()),
@@ -38,7 +38,7 @@ impl <T> fmt::Display for Error<T> {
     }
 }
 
-impl <T: fmt::Debug> error::Error for Error<T> {
+impl<T: fmt::Debug> error::Error for Error<T> {
     fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         Some(match self {
             Error::Reqwest(e) => e,
@@ -49,19 +49,19 @@ impl <T: fmt::Debug> error::Error for Error<T> {
     }
 }
 
-impl <T> From<reqwest::Error> for Error<T> {
+impl<T> From<reqwest::Error> for Error<T> {
     fn from(e: reqwest::Error) -> Self {
         Error::Reqwest(e)
     }
 }
 
-impl <T> From<serde_json::Error> for Error<T> {
+impl<T> From<serde_json::Error> for Error<T> {
     fn from(e: serde_json::Error) -> Self {
         Error::Serde(e)
     }
 }
 
-impl <T> From<std::io::Error> for Error<T> {
+impl<T> From<std::io::Error> for Error<T> {
     fn from(e: std::io::Error) -> Self {
         Error::Io(e)
     }
@@ -88,8 +88,10 @@ pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String
                             value,
                         ));
                     }
-                },
-                serde_json::Value::String(s) => params.push((format!("{}[{}]", prefix, key), s.clone())),
+                }
+                serde_json::Value::String(s) => {
+                    params.push((format!("{}[{}]", prefix, key), s.clone()))
+                }
                 _ => params.push((format!("{}[{}]", prefix, key), value.to_string())),
             }
         }
@@ -106,7 +108,7 @@ pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String
 enum ContentType {
     Json,
     Text,
-    Unsupported(String)
+    Unsupported(String),
 }
 
 impl From<&str> for ContentType {