fmt and cleanup

1 files changed, 1800 insertions, 797 deletions

diff --git a/rust/fatcat-api/src/server.rs b/rust/fatcat-api/src/server.rs
index cb307ad4..66539c55 100644
--- a/rust/fatcat-api/src/server.rs
+++ b/rust/fatcat-api/src/server.rs
@@ -1,34 +1,31 @@
 #![allow(unused_extern_crates)]
-extern crate serde_ignored;
+extern crate bodyparser;
+extern crate chrono;
 extern crate iron;
 extern crate router;
-extern crate bodyparser;
+extern crate serde_ignored;
 extern crate urlencoded;
 extern crate uuid;
-extern crate chrono;
-
 
-use futures::Future;
-use futures::future;
-use futures::{stream, Stream};
-use hyper;
-use hyper::header::{Headers, ContentType};
 use self::iron::prelude::*;
-use self::iron::{status, modifiers, BeforeMiddleware};
 use self::iron::url::percent_encoding::percent_decode;
+use self::iron::{modifiers, status, BeforeMiddleware};
 use self::router::Router;
 use self::urlencoded::UrlEncodedQuery;
+use futures::Future;
+use futures::future;
+use futures::{stream, Stream};
+use hyper;
+use hyper::header::{ContentType, Headers};
 use mimetypes;
 
-
 use serde_json;
 
-
 #[allow(unused_imports)]
-use std::collections::{HashMap, BTreeMap};
+use std::collections::{BTreeMap, HashMap};
+use std::io::Error;
 #[allow(unused_imports)]
 use swagger;
-use std::io::Error;
 
 #[allow(unused_imports)]
 use std::collections::BTreeSet;
@@ -37,34 +34,22 @@ pub use swagger::auth::Authorization;
 use swagger::auth::{AuthData, Scopes};
 use swagger::{ApiError, Context, XSpanId};
 
-use {Api,
-     ContainerIdGetResponse,
-     ContainerLookupGetResponse,
-     ContainerPostResponse,
-     CreatorIdGetResponse,
-     CreatorLookupGetResponse,
-     CreatorPostResponse,
-     EditgroupIdAcceptPostResponse,
-     EditgroupIdGetResponse,
-     EditgroupPostResponse,
-     EditorUsernameChangelogGetResponse,
-     EditorUsernameGetResponse,
-     FileIdGetResponse,
-     FileLookupGetResponse,
-     FilePostResponse,
-     ReleaseIdGetResponse,
-     ReleaseLookupGetResponse,
-     ReleasePostResponse,
-     WorkIdGetResponse,
-     WorkPostResponse
-     };
 #[allow(unused_imports)]
 use models;
+use {Api, ContainerIdGetResponse, ContainerLookupGetResponse, ContainerPostResponse,
+     CreatorIdGetResponse, CreatorLookupGetResponse, CreatorPostResponse,
+     EditgroupIdAcceptPostResponse, EditgroupIdGetResponse, EditgroupPostResponse,
+     EditorUsernameChangelogGetResponse, EditorUsernameGetResponse, FileIdGetResponse,
+     FileLookupGetResponse, FilePostResponse, ReleaseIdGetResponse, ReleaseLookupGetResponse,
+     ReleasePostResponse, WorkIdGetResponse, WorkPostResponse};
 
 header! { (Warning, "Warning") => [String] }
 
 /// Create a new router for `Api`
-pub fn router<T>(api: T) -> Router where T: Api + Send + Sync + Clone + 'static {
+pub fn router<T>(api: T) -> Router
+where
+    T: Api + Send + Sync + Clone + 'static,
+{
     let mut router = Router::new();
     add_routes(&mut router, api);
     router
@@ -90,14 +75,19 @@ pub fn router<T>(api: T) -> Router where T: Api + Send + Sync + Clone + 'static
 ///
 /// This function exists to allow legacy code, which doesn't separate its APIs properly, to make
 /// use of this crate.
-#[deprecated(note="APIs should not overlap - only for use in legacy code.")]
-pub fn route<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone + 'static {
+#[deprecated(note = "APIs should not overlap - only for use in legacy code.")]
+pub fn route<T>(router: &mut Router, api: T)
+where
+    T: Api + Send + Sync + Clone + 'static,
+{
     add_routes(router, api)
 }
 
 /// Add routes for `Api` to a provided router
-fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone + 'static {
-
+fn add_routes<T>(router: &mut Router, api: T)
+where
+    T: Api + Send + Sync + Clone + 'static,
+{
     let api_clone = api.clone();
     router.get(
         "/v0/container/:id",
@@ -105,75 +95,134 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
                 // Path parameters
                 let param_id = {
-                    let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))?
-                        .find("id").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter id".to_string())))?;
-                    percent_decode(param.as_bytes()).decode_utf8()
-                        .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))?
-                        .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter id: {}", e))))?
+                    let param = req.extensions
+                        .get::<Router>()
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::InternalServerError,
+                                "An internal error occurred".to_string(),
+                            ))
+                        })?
+                        .find("id")
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::BadRequest,
+                                "Missing path parameter id".to_string(),
+                            ))
+                        })?;
+                    percent_decode(param.as_bytes())
+                        .decode_utf8()
+                        .map_err(|_| {
+                            Response::with((
+                                status::BadRequest,
+                                format!(
+                                    "Couldn't percent-decode path parameter as UTF-8: {}",
+                                    param
+                                ),
+                            ))
+                        })?
+                        .parse()
+                        .map_err(|e| {
+                            Response::with((
+                                status::BadRequest,
+                                format!("Couldn't parse path parameter id: {}", e),
+                            ))
+                        })?
                 };
 
-
-
                 match api.container_id_get(param_id, context).wait() {
                     Ok(rsp) => match rsp {
                         ContainerIdGetResponse::FetchASingleContainerById(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(200), body_string));    
+                            let mut response =
+                                Response::with((status::Status::from_u16(200), body_string));
                             response.headers.set(ContentType(mimetypes::responses::CONTAINER_ID_GET_FETCH_A_SINGLE_CONTAINER_BY_ID.clone()));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         ContainerIdGetResponse::BadRequest(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
+                            let mut response =
+                                Response::with((status::Status::from_u16(400), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::CONTAINER_ID_GET_BAD_REQUEST.clone(),
+                            ));
 
-                            let mut response = Response::with((status::Status::from_u16(400), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CONTAINER_ID_GET_BAD_REQUEST.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         ContainerIdGetResponse::GenericErrorResponse(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CONTAINER_ID_GET_GENERIC_ERROR_RESPONSE.clone()));
+                            let mut response =
+                                Response::with((status::Status::from_u16(0), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::CONTAINER_ID_GET_GENERIC_ERROR_RESPONSE
+                                    .clone(),
+                            ));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                     },
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "ContainerIdGet");
+        "ContainerIdGet",
+    );
 
     let api_clone = api.clone();
     router.get(
@@ -182,84 +231,144 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
-
                 // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
                 let query_params = req.get::<UrlEncodedQuery>().unwrap_or_default();
-                let param_issn = query_params.get("issn")
-                    .ok_or_else(|| Response::with((status::BadRequest, "Missing required query parameter issn".to_string())))?
-                    .first().ok_or_else(|| Response::with((status::BadRequest, "Required query parameter issn was empty".to_string())))?
-                    .parse::<String>().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse query parameter issn - doesn't match schema: {}", e))))?;
-
+                let param_issn = query_params
+                    .get("issn")
+                    .ok_or_else(|| {
+                        Response::with((
+                            status::BadRequest,
+                            "Missing required query parameter issn".to_string(),
+                        ))
+                    })?
+                    .first()
+                    .ok_or_else(|| {
+                        Response::with((
+                            status::BadRequest,
+                            "Required query parameter issn was empty".to_string(),
+                        ))
+                    })?
+                    .parse::<String>()
+                    .map_err(|e| {
+                        Response::with((
+                            status::BadRequest,
+                            format!(
+                                "Couldn't parse query parameter issn - doesn't match schema: {}",
+                                e
+                            ),
+                        ))
+                    })?;
 
                 match api.container_lookup_get(param_issn, context).wait() {
-                    Ok(rsp) => match rsp {
-                        ContainerLookupGetResponse::FindASingleContainerByExternalIdentifer(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(200), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CONTAINER_LOOKUP_GET_FIND_A_SINGLE_CONTAINER_BY_EXTERNAL_IDENTIFER.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
-
-                            Ok(response)
-                        },
-                        ContainerLookupGetResponse::BadRequest(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(400), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CONTAINER_LOOKUP_GET_BAD_REQUEST.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
-
-                            Ok(response)
-                        },
-                        ContainerLookupGetResponse::NoSuchContainer(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(404), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CONTAINER_LOOKUP_GET_NO_SUCH_CONTAINER.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
-
-                            Ok(response)
-                        },
-                        ContainerLookupGetResponse::GenericErrorResponse(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
+                    Ok(rsp) => {
+                        match rsp {
+                            ContainerLookupGetResponse::FindASingleContainerByExternalIdentifer(
+                                body,
+                            ) => {
+                                let body_string = serde_json::to_string(&body)
+                                    .expect("impossible to fail to serialize");
+
+                                let mut response =
+                                    Response::with((status::Status::from_u16(200), body_string));
+                                response.headers.set(ContentType(mimetypes::responses::CONTAINER_LOOKUP_GET_FIND_A_SINGLE_CONTAINER_BY_EXTERNAL_IDENTIFER.clone()));
+
+                                context
+                                    .x_span_id
+                                    .as_ref()
+                                    .map(|header| response.headers.set(XSpanId(header.clone())));
+
+                                Ok(response)
+                            }
+                            ContainerLookupGetResponse::BadRequest(body) => {
+                                let body_string = serde_json::to_string(&body)
+                                    .expect("impossible to fail to serialize");
+
+                                let mut response =
+                                    Response::with((status::Status::from_u16(400), body_string));
+                                response.headers.set(ContentType(
+                                    mimetypes::responses::CONTAINER_LOOKUP_GET_BAD_REQUEST.clone(),
+                                ));
+
+                                context
+                                    .x_span_id
+                                    .as_ref()
+                                    .map(|header| response.headers.set(XSpanId(header.clone())));
+
+                                Ok(response)
+                            }
+                            ContainerLookupGetResponse::NoSuchContainer(body) => {
+                                let body_string = serde_json::to_string(&body)
+                                    .expect("impossible to fail to serialize");
+
+                                let mut response =
+                                    Response::with((status::Status::from_u16(404), body_string));
+                                response.headers.set(ContentType(
+                                    mimetypes::responses::CONTAINER_LOOKUP_GET_NO_SUCH_CONTAINER
+                                        .clone(),
+                                ));
+
+                                context
+                                    .x_span_id
+                                    .as_ref()
+                                    .map(|header| response.headers.set(XSpanId(header.clone())));
+
+                                Ok(response)
+                            }
+                            ContainerLookupGetResponse::GenericErrorResponse(body) => {
+                                let body_string = serde_json::to_string(&body)
+                                    .expect("impossible to fail to serialize");
 
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CONTAINER_LOOKUP_GET_GENERIC_ERROR_RESPONSE.clone()));
+                                let mut response =
+                                    Response::with((status::Status::from_u16(0), body_string));
+                                response.headers.set(ContentType(mimetypes::responses::CONTAINER_LOOKUP_GET_GENERIC_ERROR_RESPONSE.clone()));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                                context
+                                    .x_span_id
+                                    .as_ref()
+                                    .map(|header| response.headers.set(XSpanId(header.clone())));
 
-                            Ok(response)
-                        },
-                    },
+                                Ok(response)
+                            }
+                        }
+                    }
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "ContainerLookupGet");
+        "ContainerLookupGet",
+    );
 
     let api_clone = api.clone();
     router.post(
@@ -268,15 +377,23 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
-
                 // Body parameters (note that non-required body parameters will ignore garbage
                 // values, rather than causing a 400 response). Produce warning header and logs for
                 // any unused fields.
@@ -285,10 +402,11 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
 
                 let mut unused_elements = Vec::new();
 
-                let param_body = if let Some(param_body_raw) = param_body { 
+                let param_body = if let Some(param_body_raw) = param_body {
                     let deserializer = &mut serde_json::Deserializer::from_str(&param_body_raw);
 
-                    let param_body: Option<models::ContainerEntity> = serde_ignored::deserialize(deserializer, |path| {
+                    let param_body: Option<models::ContainerEntity> =
+                        serde_ignored::deserialize(deserializer, |path| {
                             warn!("Ignoring unknown field in body: {}", path);
                             unused_elements.push(path.to_string());
                         }).unwrap_or(None);
@@ -296,65 +414,98 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
                     param_body
                 } else {
                     None
-                };;
-
+                };
 
                 match api.container_post(param_body, context).wait() {
                     Ok(rsp) => match rsp {
                         ContainerPostResponse::Created(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(201), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CONTAINER_POST_CREATED.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
+
+                            let mut response =
+                                Response::with((status::Status::from_u16(201), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::CONTAINER_POST_CREATED.clone(),
+                            ));
+
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
                             if !unused_elements.is_empty() {
-                                response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements)));
+                                response.headers.set(Warning(format!(
+                                    "Ignoring unknown fields in body: {:?}",
+                                    unused_elements
+                                )));
                             }
                             Ok(response)
-                        },
+                        }
                         ContainerPostResponse::BadRequest(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(400), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CONTAINER_POST_BAD_REQUEST.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
+
+                            let mut response =
+                                Response::with((status::Status::from_u16(400), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::CONTAINER_POST_BAD_REQUEST.clone(),
+                            ));
+
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
                             if !unused_elements.is_empty() {
-                                response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements)));
+                                response.headers.set(Warning(format!(
+                                    "Ignoring unknown fields in body: {:?}",
+                                    unused_elements
+                                )));
                             }
                             Ok(response)
-                        },
+                        }
                         ContainerPostResponse::GenericErrorResponse(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CONTAINER_POST_GENERIC_ERROR_RESPONSE.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
+
+                            let mut response =
+                                Response::with((status::Status::from_u16(0), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::CONTAINER_POST_GENERIC_ERROR_RESPONSE.clone(),
+                            ));
+
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
                             if !unused_elements.is_empty() {
-                                response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements)));
+                                response.headers.set(Warning(format!(
+                                    "Ignoring unknown fields in body: {:?}",
+                                    unused_elements
+                                )));
                             }
                             Ok(response)
-                        },
+                        }
                     },
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "ContainerPost");
+        "ContainerPost",
+    );
 
     let api_clone = api.clone();
     router.get(
@@ -363,75 +514,136 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
                 // Path parameters
                 let param_id = {
-                    let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))?
-                        .find("id").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter id".to_string())))?;
-                    percent_decode(param.as_bytes()).decode_utf8()
-                        .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))?
-                        .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter id: {}", e))))?
+                    let param = req.extensions
+                        .get::<Router>()
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::InternalServerError,
+                                "An internal error occurred".to_string(),
+                            ))
+                        })?
+                        .find("id")
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::BadRequest,
+                                "Missing path parameter id".to_string(),
+                            ))
+                        })?;
+                    percent_decode(param.as_bytes())
+                        .decode_utf8()
+                        .map_err(|_| {
+                            Response::with((
+                                status::BadRequest,
+                                format!(
+                                    "Couldn't percent-decode path parameter as UTF-8: {}",
+                                    param
+                                ),
+                            ))
+                        })?
+                        .parse()
+                        .map_err(|e| {
+                            Response::with((
+                                status::BadRequest,
+                                format!("Couldn't parse path parameter id: {}", e),
+                            ))
+                        })?
                 };
 
-
-
                 match api.creator_id_get(param_id, context).wait() {
-                    Ok(rsp) => match rsp {
-                        CreatorIdGetResponse::FetchASingleCreatorById(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(200), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CREATOR_ID_GET_FETCH_A_SINGLE_CREATOR_BY_ID.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
-
-                            Ok(response)
-                        },
-                        CreatorIdGetResponse::BadRequest(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(400), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CREATOR_ID_GET_BAD_REQUEST.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
-
-                            Ok(response)
-                        },
-                        CreatorIdGetResponse::GenericErrorResponse(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CREATOR_ID_GET_GENERIC_ERROR_RESPONSE.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
-
-                            Ok(response)
-                        },
-                    },
+                    Ok(rsp) => {
+                        match rsp {
+                            CreatorIdGetResponse::FetchASingleCreatorById(body) => {
+                                let body_string = serde_json::to_string(&body)
+                                    .expect("impossible to fail to serialize");
+
+                                let mut response =
+                                    Response::with((status::Status::from_u16(200), body_string));
+                                response.headers.set(ContentType(mimetypes::responses::CREATOR_ID_GET_FETCH_A_SINGLE_CREATOR_BY_ID.clone()));
+
+                                context
+                                    .x_span_id
+                                    .as_ref()
+                                    .map(|header| response.headers.set(XSpanId(header.clone())));
+
+                                Ok(response)
+                            }
+                            CreatorIdGetResponse::BadRequest(body) => {
+                                let body_string = serde_json::to_string(&body)
+                                    .expect("impossible to fail to serialize");
+
+                                let mut response =
+                                    Response::with((status::Status::from_u16(400), body_string));
+                                response.headers.set(ContentType(
+                                    mimetypes::responses::CREATOR_ID_GET_BAD_REQUEST.clone(),
+                                ));
+
+                                context
+                                    .x_span_id
+                                    .as_ref()
+                                    .map(|header| response.headers.set(XSpanId(header.clone())));
+
+                                Ok(response)
+                            }
+                            CreatorIdGetResponse::GenericErrorResponse(body) => {
+                                let body_string = serde_json::to_string(&body)
+                                    .expect("impossible to fail to serialize");
+
+                                let mut response =
+                                    Response::with((status::Status::from_u16(0), body_string));
+                                response.headers.set(ContentType(
+                                    mimetypes::responses::CREATOR_ID_GET_GENERIC_ERROR_RESPONSE
+                                        .clone(),
+                                ));
+
+                                context
+                                    .x_span_id
+                                    .as_ref()
+                                    .map(|header| response.headers.set(XSpanId(header.clone())));
+
+                                Ok(response)
+                            }
+                        }
+                    }
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "CreatorIdGet");
+        "CreatorIdGet",
+    );
 
     let api_clone = api.clone();
     router.get(
@@ -440,84 +652,142 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
-
                 // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
                 let query_params = req.get::<UrlEncodedQuery>().unwrap_or_default();
-                let param_orcid = query_params.get("orcid")
-                    .ok_or_else(|| Response::with((status::BadRequest, "Missing required query parameter orcid".to_string())))?
-                    .first().ok_or_else(|| Response::with((status::BadRequest, "Required query parameter orcid was empty".to_string())))?
-                    .parse::<String>().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse query parameter orcid - doesn't match schema: {}", e))))?;
-
+                let param_orcid = query_params
+                    .get("orcid")
+                    .ok_or_else(|| {
+                        Response::with((
+                            status::BadRequest,
+                            "Missing required query parameter orcid".to_string(),
+                        ))
+                    })?
+                    .first()
+                    .ok_or_else(|| {
+                        Response::with((
+                            status::BadRequest,
+                            "Required query parameter orcid was empty".to_string(),
+                        ))
+                    })?
+                    .parse::<String>()
+                    .map_err(|e| {
+                        Response::with((
+                            status::BadRequest,
+                            format!(
+                                "Couldn't parse query parameter orcid - doesn't match schema: {}",
+                                e
+                            ),
+                        ))
+                    })?;
 
                 match api.creator_lookup_get(param_orcid, context).wait() {
                     Ok(rsp) => match rsp {
                         CreatorLookupGetResponse::FindASingleCreatorByExternalIdentifer(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(200), body_string));    
+                            let mut response =
+                                Response::with((status::Status::from_u16(200), body_string));
                             response.headers.set(ContentType(mimetypes::responses::CREATOR_LOOKUP_GET_FIND_A_SINGLE_CREATOR_BY_EXTERNAL_IDENTIFER.clone()));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         CreatorLookupGetResponse::BadRequest(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(400), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CREATOR_LOOKUP_GET_BAD_REQUEST.clone()));
+                            let mut response =
+                                Response::with((status::Status::from_u16(400), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::CREATOR_LOOKUP_GET_BAD_REQUEST.clone(),
+                            ));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         CreatorLookupGetResponse::NoSuchCreator(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
+                            let mut response =
+                                Response::with((status::Status::from_u16(404), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::CREATOR_LOOKUP_GET_NO_SUCH_CREATOR.clone(),
+                            ));
 
-                            let mut response = Response::with((status::Status::from_u16(404), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CREATOR_LOOKUP_GET_NO_SUCH_CREATOR.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         CreatorLookupGetResponse::GenericErrorResponse(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CREATOR_LOOKUP_GET_GENERIC_ERROR_RESPONSE.clone()));
+                            let mut response =
+                                Response::with((status::Status::from_u16(0), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::CREATOR_LOOKUP_GET_GENERIC_ERROR_RESPONSE
+                                    .clone(),
+                            ));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                     },
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "CreatorLookupGet");
+        "CreatorLookupGet",
+    );
 
     let api_clone = api.clone();
     router.post(
@@ -526,15 +796,23 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
-
                 // Body parameters (note that non-required body parameters will ignore garbage
                 // values, rather than causing a 400 response). Produce warning header and logs for
                 // any unused fields.
@@ -543,10 +821,11 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
 
                 let mut unused_elements = Vec::new();
 
-                let param_body = if let Some(param_body_raw) = param_body { 
+                let param_body = if let Some(param_body_raw) = param_body {
                     let deserializer = &mut serde_json::Deserializer::from_str(&param_body_raw);
 
-                    let param_body: Option<models::CreatorEntity> = serde_ignored::deserialize(deserializer, |path| {
+                    let param_body: Option<models::CreatorEntity> =
+                        serde_ignored::deserialize(deserializer, |path| {
                             warn!("Ignoring unknown field in body: {}", path);
                             unused_elements.push(path.to_string());
                         }).unwrap_or(None);
@@ -554,65 +833,98 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
                     param_body
                 } else {
                     None
-                };;
-
+                };
 
                 match api.creator_post(param_body, context).wait() {
                     Ok(rsp) => match rsp {
                         CreatorPostResponse::Created(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(201), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CREATOR_POST_CREATED.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
+
+                            let mut response =
+                                Response::with((status::Status::from_u16(201), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::CREATOR_POST_CREATED.clone(),
+                            ));
+
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
                             if !unused_elements.is_empty() {
-                                response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements)));
+                                response.headers.set(Warning(format!(
+                                    "Ignoring unknown fields in body: {:?}",
+                                    unused_elements
+                                )));
                             }
                             Ok(response)
-                        },
+                        }
                         CreatorPostResponse::BadRequest(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(400), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CREATOR_POST_BAD_REQUEST.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
+
+                            let mut response =
+                                Response::with((status::Status::from_u16(400), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::CREATOR_POST_BAD_REQUEST.clone(),
+                            ));
+
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
                             if !unused_elements.is_empty() {
-                                response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements)));
+                                response.headers.set(Warning(format!(
+                                    "Ignoring unknown fields in body: {:?}",
+                                    unused_elements
+                                )));
                             }
                             Ok(response)
-                        },
+                        }
                         CreatorPostResponse::GenericErrorResponse(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::CREATOR_POST_GENERIC_ERROR_RESPONSE.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
+
+                            let mut response =
+                                Response::with((status::Status::from_u16(0), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::CREATOR_POST_GENERIC_ERROR_RESPONSE.clone(),
+                            ));
+
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
                             if !unused_elements.is_empty() {
-                                response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements)));
+                                response.headers.set(Warning(format!(
+                                    "Ignoring unknown fields in body: {:?}",
+                                    unused_elements
+                                )));
                             }
                             Ok(response)
-                        },
+                        }
                     },
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "CreatorPost");
+        "CreatorPost",
+    );
 
     let api_clone = api.clone();
     router.post(
@@ -621,86 +933,146 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
                 // Path parameters
                 let param_id = {
-                    let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))?
-                        .find("id").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter id".to_string())))?;
-                    percent_decode(param.as_bytes()).decode_utf8()
-                        .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))?
-                        .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter id: {}", e))))?
+                    let param = req.extensions
+                        .get::<Router>()
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::InternalServerError,
+                                "An internal error occurred".to_string(),
+                            ))
+                        })?
+                        .find("id")
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::BadRequest,
+                                "Missing path parameter id".to_string(),
+                            ))
+                        })?;
+                    percent_decode(param.as_bytes())
+                        .decode_utf8()
+                        .map_err(|_| {
+                            Response::with((
+                                status::BadRequest,
+                                format!(
+                                    "Couldn't percent-decode path parameter as UTF-8: {}",
+                                    param
+                                ),
+                            ))
+                        })?
+                        .parse()
+                        .map_err(|e| {
+                            Response::with((
+                                status::BadRequest,
+                                format!("Couldn't parse path parameter id: {}", e),
+                            ))
+                        })?
                 };
 
-
-
                 match api.editgroup_id_accept_post(param_id, context).wait() {
-                    Ok(rsp) => match rsp {
-                        EditgroupIdAcceptPostResponse::MergedEditgroupSuccessfully_(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(200), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_MERGED_EDITGROUP_SUCCESSFULLY_.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
-
-                            Ok(response)
-                        },
-                        EditgroupIdAcceptPostResponse::EditgroupIsInAnUnmergableState(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(400), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_EDITGROUP_IS_IN_AN_UNMERGABLE_STATE.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                    Ok(rsp) => {
+                        match rsp {
+                            EditgroupIdAcceptPostResponse::MergedEditgroupSuccessfully_(body) => {
+                                let body_string = serde_json::to_string(&body)
+                                    .expect("impossible to fail to serialize");
+
+                                let mut response =
+                                    Response::with((status::Status::from_u16(200), body_string));
+                                response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_MERGED_EDITGROUP_SUCCESSFULLY_.clone()));
+
+                                context
+                                    .x_span_id
+                                    .as_ref()
+                                    .map(|header| response.headers.set(XSpanId(header.clone())));
+
+                                Ok(response)
+                            }
+                            EditgroupIdAcceptPostResponse::EditgroupIsInAnUnmergableState(body) => {
+                                let body_string = serde_json::to_string(&body)
+                                    .expect("impossible to fail to serialize");
 
-                            Ok(response)
-                        },
-                        EditgroupIdAcceptPostResponse::NoSuchEditgroup(body) => {
+                                let mut response =
+                                    Response::with((status::Status::from_u16(400), body_string));
+                                response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_EDITGROUP_IS_IN_AN_UNMERGABLE_STATE.clone()));
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
+                                context
+                                    .x_span_id
+                                    .as_ref()
+                                    .map(|header| response.headers.set(XSpanId(header.clone())));
 
-                            let mut response = Response::with((status::Status::from_u16(404), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_NO_SUCH_EDITGROUP.clone()));
+                                Ok(response)
+                            }
+                            EditgroupIdAcceptPostResponse::NoSuchEditgroup(body) => {
+                                let body_string = serde_json::to_string(&body)
+                                    .expect("impossible to fail to serialize");
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                                let mut response =
+                                    Response::with((status::Status::from_u16(404), body_string));
+                                response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_NO_SUCH_EDITGROUP.clone()));
 
-                            Ok(response)
-                        },
-                        EditgroupIdAcceptPostResponse::GenericErrorResponse(body) => {
+                                context
+                                    .x_span_id
+                                    .as_ref()
+                                    .map(|header| response.headers.set(XSpanId(header.clone())));
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
+                                Ok(response)
+                            }
+                            EditgroupIdAcceptPostResponse::GenericErrorResponse(body) => {
+                                let body_string = serde_json::to_string(&body)
+                                    .expect("impossible to fail to serialize");
 
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_GENERIC_ERROR_RESPONSE.clone()));
+                                let mut response =
+                                    Response::with((status::Status::from_u16(0), body_string));
+                                response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_GENERIC_ERROR_RESPONSE.clone()));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                                context
+                                    .x_span_id
+                                    .as_ref()
+                                    .map(|header| response.headers.set(XSpanId(header.clone())));
 
-                            Ok(response)
-                        },
-                    },
+                                Ok(response)
+                            }
+                        }
+                    }
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "EditgroupIdAcceptPost");
+        "EditgroupIdAcceptPost",
+    );
 
     let api_clone = api.clone();
     router.get(
@@ -709,75 +1081,134 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
                 // Path parameters
                 let param_id = {
-                    let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))?
-                        .find("id").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter id".to_string())))?;
-                    percent_decode(param.as_bytes()).decode_utf8()
-                        .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))?
-                        .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter id: {}", e))))?
+                    let param = req.extensions
+                        .get::<Router>()
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::InternalServerError,
+                                "An internal error occurred".to_string(),
+                            ))
+                        })?
+                        .find("id")
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::BadRequest,
+                                "Missing path parameter id".to_string(),
+                            ))
+                        })?;
+                    percent_decode(param.as_bytes())
+                        .decode_utf8()
+                        .map_err(|_| {
+                            Response::with((
+                                status::BadRequest,
+                                format!(
+                                    "Couldn't percent-decode path parameter as UTF-8: {}",
+                                    param
+                                ),
+                            ))
+                        })?
+                        .parse()
+                        .map_err(|e| {
+                            Response::with((
+                                status::BadRequest,
+                                format!("Couldn't parse path parameter id: {}", e),
+                            ))
+                        })?
                 };
 
-
-
                 match api.editgroup_id_get(param_id, context).wait() {
                     Ok(rsp) => match rsp {
                         EditgroupIdGetResponse::FetchEditgroupByIdentifier(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(200), body_string));    
+                            let mut response =
+                                Response::with((status::Status::from_u16(200), body_string));
                             response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_GET_FETCH_EDITGROUP_BY_IDENTIFIER.clone()));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         EditgroupIdGetResponse::NoSuchEditgroup(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
+                            let mut response =
+                                Response::with((status::Status::from_u16(404), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::EDITGROUP_ID_GET_NO_SUCH_EDITGROUP.clone(),
+                            ));
 
-                            let mut response = Response::with((status::Status::from_u16(404), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_GET_NO_SUCH_EDITGROUP.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         EditgroupIdGetResponse::GenericErrorResponse(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_GET_GENERIC_ERROR_RESPONSE.clone()));
+                            let mut response =
+                                Response::with((status::Status::from_u16(0), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::EDITGROUP_ID_GET_GENERIC_ERROR_RESPONSE
+                                    .clone(),
+                            ));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                     },
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "EditgroupIdGet");
+        "EditgroupIdGet",
+    );
 
     let api_clone = api.clone();
     router.post(
@@ -786,66 +1217,99 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
-
-
                 match api.editgroup_post(context).wait() {
                     Ok(rsp) => match rsp {
                         EditgroupPostResponse::SuccessfullyCreated(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
+                            let mut response =
+                                Response::with((status::Status::from_u16(201), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::EDITGROUP_POST_SUCCESSFULLY_CREATED.clone(),
+                            ));
 
-                            let mut response = Response::with((status::Status::from_u16(201), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::EDITGROUP_POST_SUCCESSFULLY_CREATED.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         EditgroupPostResponse::InvalidRequestParameters(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(400), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::EDITGROUP_POST_INVALID_REQUEST_PARAMETERS.clone()));
+                            let mut response =
+                                Response::with((status::Status::from_u16(400), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::EDITGROUP_POST_INVALID_REQUEST_PARAMETERS
+                                    .clone(),
+                            ));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         EditgroupPostResponse::GenericErrorResponse(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::EDITGROUP_POST_GENERIC_ERROR_RESPONSE.clone()));
+                            let mut response =
+                                Response::with((status::Status::from_u16(0), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::EDITGROUP_POST_GENERIC_ERROR_RESPONSE.clone(),
+                            ));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                     },
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "EditgroupPost");
+        "EditgroupPost",
+    );
 
     let api_clone = api.clone();
     router.get(
@@ -854,75 +1318,133 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
                 // Path parameters
                 let param_username = {
-                    let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))?
-                        .find("username").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter username".to_string())))?;
-                    percent_decode(param.as_bytes()).decode_utf8()
-                        .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))?
-                        .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter username: {}", e))))?
+                    let param = req.extensions
+                        .get::<Router>()
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::InternalServerError,
+                                "An internal error occurred".to_string(),
+                            ))
+                        })?
+                        .find("username")
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::BadRequest,
+                                "Missing path parameter username".to_string(),
+                            ))
+                        })?;
+                    percent_decode(param.as_bytes())
+                        .decode_utf8()
+                        .map_err(|_| {
+                            Response::with((
+                                status::BadRequest,
+                                format!(
+                                    "Couldn't percent-decode path parameter as UTF-8: {}",
+                                    param
+                                ),
+                            ))
+                        })?
+                        .parse()
+                        .map_err(|e| {
+                            Response::with((
+                                status::BadRequest,
+                                format!("Couldn't parse path parameter username: {}", e),
+                            ))
+                        })?
                 };
 
+                match api.editor_username_changelog_get(param_username, context)
+                    .wait()
+                {
+                    Ok(rsp) => {
+                        match rsp {
+                            EditorUsernameChangelogGetResponse::FindChanges_(body) => {
+                                let body_string = serde_json::to_string(&body)
+                                    .expect("impossible to fail to serialize");
+
+                                let mut response =
+                                    Response::with((status::Status::from_u16(200), body_string));
+                                response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_CHANGELOG_GET_FIND_CHANGES_.clone()));
+
+                                context
+                                    .x_span_id
+                                    .as_ref()
+                                    .map(|header| response.headers.set(XSpanId(header.clone())));
+
+                                Ok(response)
+                            }
+                            EditorUsernameChangelogGetResponse::UsernameNotFound(body) => {
+                                let body_string = serde_json::to_string(&body)
+                                    .expect("impossible to fail to serialize");
 
+                                let mut response =
+                                    Response::with((status::Status::from_u16(404), body_string));
+                                response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_CHANGELOG_GET_USERNAME_NOT_FOUND.clone()));
 
-                match api.editor_username_changelog_get(param_username, context).wait() {
-                    Ok(rsp) => match rsp {
-                        EditorUsernameChangelogGetResponse::FindChanges_(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(200), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_CHANGELOG_GET_FIND_CHANGES_.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
-
-                            Ok(response)
-                        },
-                        EditorUsernameChangelogGetResponse::UsernameNotFound(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(404), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_CHANGELOG_GET_USERNAME_NOT_FOUND.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
-
-                            Ok(response)
-                        },
-                        EditorUsernameChangelogGetResponse::GenericErrorResponse(body) => {
+                                context
+                                    .x_span_id
+                                    .as_ref()
+                                    .map(|header| response.headers.set(XSpanId(header.clone())));
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
+                                Ok(response)
+                            }
+                            EditorUsernameChangelogGetResponse::GenericErrorResponse(body) => {
+                                let body_string = serde_json::to_string(&body)
+                                    .expect("impossible to fail to serialize");
 
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_CHANGELOG_GET_GENERIC_ERROR_RESPONSE.clone()));
+                                let mut response =
+                                    Response::with((status::Status::from_u16(0), body_string));
+                                response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_CHANGELOG_GET_GENERIC_ERROR_RESPONSE.clone()));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                                context
+                                    .x_span_id
+                                    .as_ref()
+                                    .map(|header| response.headers.set(XSpanId(header.clone())));
 
-                            Ok(response)
-                        },
-                    },
+                                Ok(response)
+                            }
+                        }
+                    }
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "EditorUsernameChangelogGet");
+        "EditorUsernameChangelogGet",
+    );
 
     let api_clone = api.clone();
     router.get(
@@ -931,75 +1453,135 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
                 // Path parameters
                 let param_username = {
-                    let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))?
-                        .find("username").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter username".to_string())))?;
-                    percent_decode(param.as_bytes()).decode_utf8()
-                        .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))?
-                        .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter username: {}", e))))?
+                    let param = req.extensions
+                        .get::<Router>()
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::InternalServerError,
+                                "An internal error occurred".to_string(),
+                            ))
+                        })?
+                        .find("username")
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::BadRequest,
+                                "Missing path parameter username".to_string(),
+                            ))
+                        })?;
+                    percent_decode(param.as_bytes())
+                        .decode_utf8()
+                        .map_err(|_| {
+                            Response::with((
+                                status::BadRequest,
+                                format!(
+                                    "Couldn't percent-decode path parameter as UTF-8: {}",
+                                    param
+                                ),
+                            ))
+                        })?
+                        .parse()
+                        .map_err(|e| {
+                            Response::with((
+                                status::BadRequest,
+                                format!("Couldn't parse path parameter username: {}", e),
+                            ))
+                        })?
                 };
 
-
-
                 match api.editor_username_get(param_username, context).wait() {
                     Ok(rsp) => match rsp {
                         EditorUsernameGetResponse::FetchGenericInformationAboutAnEditor(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(200), body_string));    
+                            let mut response =
+                                Response::with((status::Status::from_u16(200), body_string));
                             response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_GET_FETCH_GENERIC_INFORMATION_ABOUT_AN_EDITOR.clone()));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         EditorUsernameGetResponse::UsernameNotFound(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(404), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_GET_USERNAME_NOT_FOUND.clone()));
+                            let mut response =
+                                Response::with((status::Status::from_u16(404), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::EDITOR_USERNAME_GET_USERNAME_NOT_FOUND
+                                    .clone(),
+                            ));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         EditorUsernameGetResponse::GenericErrorResponse(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
+                            let mut response =
+                                Response::with((status::Status::from_u16(0), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::EDITOR_USERNAME_GET_GENERIC_ERROR_RESPONSE
+                                    .clone(),
+                            ));
 
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_GET_GENERIC_ERROR_RESPONSE.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                     },
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "EditorUsernameGet");
+        "EditorUsernameGet",
+    );
 
     let api_clone = api.clone();
     router.get(
@@ -1008,75 +1590,135 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
                 // Path parameters
                 let param_id = {
-                    let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))?
-                        .find("id").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter id".to_string())))?;
-                    percent_decode(param.as_bytes()).decode_utf8()
-                        .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))?
-                        .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter id: {}", e))))?
+                    let param = req.extensions
+                        .get::<Router>()
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::InternalServerError,
+                                "An internal error occurred".to_string(),
+                            ))
+                        })?
+                        .find("id")
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::BadRequest,
+                                "Missing path parameter id".to_string(),
+                            ))
+                        })?;
+                    percent_decode(param.as_bytes())
+                        .decode_utf8()
+                        .map_err(|_| {
+                            Response::with((
+                                status::BadRequest,
+                                format!(
+                                    "Couldn't percent-decode path parameter as UTF-8: {}",
+                                    param
+                                ),
+                            ))
+                        })?
+                        .parse()
+                        .map_err(|e| {
+                            Response::with((
+                                status::BadRequest,
+                                format!("Couldn't parse path parameter id: {}", e),
+                            ))
+                        })?
                 };
 
-
-
                 match api.file_id_get(param_id, context).wait() {
                     Ok(rsp) => match rsp {
                         FileIdGetResponse::FetchASingleFileById(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(200), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::FILE_ID_GET_FETCH_A_SINGLE_FILE_BY_ID.clone()));
+                            let mut response =
+                                Response::with((status::Status::from_u16(200), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::FILE_ID_GET_FETCH_A_SINGLE_FILE_BY_ID.clone(),
+                            ));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         FileIdGetResponse::BadRequest(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
+                            let mut response =
+                                Response::with((status::Status::from_u16(400), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::FILE_ID_GET_BAD_REQUEST.clone(),
+                            ));
 
-                            let mut response = Response::with((status::Status::from_u16(400), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::FILE_ID_GET_BAD_REQUEST.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         FileIdGetResponse::GenericErrorResponse(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::FILE_ID_GET_GENERIC_ERROR_RESPONSE.clone()));
+                            let mut response =
+                                Response::with((status::Status::from_u16(0), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::FILE_ID_GET_GENERIC_ERROR_RESPONSE.clone(),
+                            ));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                     },
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "FileIdGet");
+        "FileIdGet",
+    );
 
     let api_clone = api.clone();
     router.get(
@@ -1085,84 +1727,142 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
-
                 // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
                 let query_params = req.get::<UrlEncodedQuery>().unwrap_or_default();
-                let param_sha1 = query_params.get("sha1")
-                    .ok_or_else(|| Response::with((status::BadRequest, "Missing required query parameter sha1".to_string())))?
-                    .first().ok_or_else(|| Response::with((status::BadRequest, "Required query parameter sha1 was empty".to_string())))?
-                    .parse::<String>().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse query parameter sha1 - doesn't match schema: {}", e))))?;
-
+                let param_sha1 = query_params
+                    .get("sha1")
+                    .ok_or_else(|| {
+                        Response::with((
+                            status::BadRequest,
+                            "Missing required query parameter sha1".to_string(),
+                        ))
+                    })?
+                    .first()
+                    .ok_or_else(|| {
+                        Response::with((
+                            status::BadRequest,
+                            "Required query parameter sha1 was empty".to_string(),
+                        ))
+                    })?
+                    .parse::<String>()
+                    .map_err(|e| {
+                        Response::with((
+                            status::BadRequest,
+                            format!(
+                                "Couldn't parse query parameter sha1 - doesn't match schema: {}",
+                                e
+                            ),
+                        ))
+                    })?;
 
                 match api.file_lookup_get(param_sha1, context).wait() {
                     Ok(rsp) => match rsp {
                         FileLookupGetResponse::FindASingleFileByExternalIdentifer(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(200), body_string));    
+                            let mut response =
+                                Response::with((status::Status::from_u16(200), body_string));
                             response.headers.set(ContentType(mimetypes::responses::FILE_LOOKUP_GET_FIND_A_SINGLE_FILE_BY_EXTERNAL_IDENTIFER.clone()));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         FileLookupGetResponse::BadRequest(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(400), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::FILE_LOOKUP_GET_BAD_REQUEST.clone()));
+                            let mut response =
+                                Response::with((status::Status::from_u16(400), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::FILE_LOOKUP_GET_BAD_REQUEST.clone(),
+                            ));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         FileLookupGetResponse::NoSuchFile(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
+                            let mut response =
+                                Response::with((status::Status::from_u16(404), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::FILE_LOOKUP_GET_NO_SUCH_FILE.clone(),
+                            ));
 
-                            let mut response = Response::with((status::Status::from_u16(404), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::FILE_LOOKUP_GET_NO_SUCH_FILE.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         FileLookupGetResponse::GenericErrorResponse(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::FILE_LOOKUP_GET_GENERIC_ERROR_RESPONSE.clone()));
+                            let mut response =
+                                Response::with((status::Status::from_u16(0), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::FILE_LOOKUP_GET_GENERIC_ERROR_RESPONSE
+                                    .clone(),
+                            ));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                     },
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "FileLookupGet");
+        "FileLookupGet",
+    );
 
     let api_clone = api.clone();
     router.post(
@@ -1171,15 +1871,23 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
-
                 // Body parameters (note that non-required body parameters will ignore garbage
                 // values, rather than causing a 400 response). Produce warning header and logs for
                 // any unused fields.
@@ -1188,10 +1896,11 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
 
                 let mut unused_elements = Vec::new();
 
-                let param_body = if let Some(param_body_raw) = param_body { 
+                let param_body = if let Some(param_body_raw) = param_body {
                     let deserializer = &mut serde_json::Deserializer::from_str(&param_body_raw);
 
-                    let param_body: Option<models::FileEntity> = serde_ignored::deserialize(deserializer, |path| {
+                    let param_body: Option<models::FileEntity> =
+                        serde_ignored::deserialize(deserializer, |path| {
                             warn!("Ignoring unknown field in body: {}", path);
                             unused_elements.push(path.to_string());
                         }).unwrap_or(None);
@@ -1199,65 +1908,98 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
                     param_body
                 } else {
                     None
-                };;
-
+                };
 
                 match api.file_post(param_body, context).wait() {
                     Ok(rsp) => match rsp {
                         FilePostResponse::Created(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(201), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::FILE_POST_CREATED.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
+
+                            let mut response =
+                                Response::with((status::Status::from_u16(201), body_string));
+                            response
+                                .headers
+                                .set(ContentType(mimetypes::responses::FILE_POST_CREATED.clone()));
+
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
                             if !unused_elements.is_empty() {
-                                response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements)));
+                                response.headers.set(Warning(format!(
+                                    "Ignoring unknown fields in body: {:?}",
+                                    unused_elements
+                                )));
                             }
                             Ok(response)
-                        },
+                        }
                         FilePostResponse::BadRequest(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(400), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::FILE_POST_BAD_REQUEST.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
+
+                            let mut response =
+                                Response::with((status::Status::from_u16(400), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::FILE_POST_BAD_REQUEST.clone(),
+                            ));
+
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
                             if !unused_elements.is_empty() {
-                                response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements)));
+                                response.headers.set(Warning(format!(
+                                    "Ignoring unknown fields in body: {:?}",
+                                    unused_elements
+                                )));
                             }
                             Ok(response)
-                        },
+                        }
                         FilePostResponse::GenericErrorResponse(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::FILE_POST_GENERIC_ERROR_RESPONSE.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
+
+                            let mut response =
+                                Response::with((status::Status::from_u16(0), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::FILE_POST_GENERIC_ERROR_RESPONSE.clone(),
+                            ));
+
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
                             if !unused_elements.is_empty() {
-                                response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements)));
+                                response.headers.set(Warning(format!(
+                                    "Ignoring unknown fields in body: {:?}",
+                                    unused_elements
+                                )));
                             }
                             Ok(response)
-                        },
+                        }
                     },
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "FilePost");
+        "FilePost",
+    );
 
     let api_clone = api.clone();
     router.get(
@@ -1266,75 +2008,136 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
                 // Path parameters
                 let param_id = {
-                    let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))?
-                        .find("id").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter id".to_string())))?;
-                    percent_decode(param.as_bytes()).decode_utf8()
-                        .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))?
-                        .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter id: {}", e))))?
+                    let param = req.extensions
+                        .get::<Router>()
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::InternalServerError,
+                                "An internal error occurred".to_string(),
+                            ))
+                        })?
+                        .find("id")
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::BadRequest,
+                                "Missing path parameter id".to_string(),
+                            ))
+                        })?;
+                    percent_decode(param.as_bytes())
+                        .decode_utf8()
+                        .map_err(|_| {
+                            Response::with((
+                                status::BadRequest,
+                                format!(
+                                    "Couldn't percent-decode path parameter as UTF-8: {}",
+                                    param
+                                ),
+                            ))
+                        })?
+                        .parse()
+                        .map_err(|e| {
+                            Response::with((
+                                status::BadRequest,
+                                format!("Couldn't parse path parameter id: {}", e),
+                            ))
+                        })?
                 };
 
-
-
                 match api.release_id_get(param_id, context).wait() {
-                    Ok(rsp) => match rsp {
-                        ReleaseIdGetResponse::FetchASingleReleaseById(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(200), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::RELEASE_ID_GET_FETCH_A_SINGLE_RELEASE_BY_ID.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
-
-                            Ok(response)
-                        },
-                        ReleaseIdGetResponse::BadRequest(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(400), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::RELEASE_ID_GET_BAD_REQUEST.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
-
-                            Ok(response)
-                        },
-                        ReleaseIdGetResponse::GenericErrorResponse(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::RELEASE_ID_GET_GENERIC_ERROR_RESPONSE.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
-
-                            Ok(response)
-                        },
-                    },
+                    Ok(rsp) => {
+                        match rsp {
+                            ReleaseIdGetResponse::FetchASingleReleaseById(body) => {
+                                let body_string = serde_json::to_string(&body)
+                                    .expect("impossible to fail to serialize");
+
+                                let mut response =
+                                    Response::with((status::Status::from_u16(200), body_string));
+                                response.headers.set(ContentType(mimetypes::responses::RELEASE_ID_GET_FETCH_A_SINGLE_RELEASE_BY_ID.clone()));
+
+                                context
+                                    .x_span_id
+                                    .as_ref()
+                                    .map(|header| response.headers.set(XSpanId(header.clone())));
+
+                                Ok(response)
+                            }
+                            ReleaseIdGetResponse::BadRequest(body) => {
+                                let body_string = serde_json::to_string(&body)
+                                    .expect("impossible to fail to serialize");
+
+                                let mut response =
+                                    Response::with((status::Status::from_u16(400), body_string));
+                                response.headers.set(ContentType(
+                                    mimetypes::responses::RELEASE_ID_GET_BAD_REQUEST.clone(),
+                                ));
+
+                                context
+                                    .x_span_id
+                                    .as_ref()
+                                    .map(|header| response.headers.set(XSpanId(header.clone())));
+
+                                Ok(response)
+                            }
+                            ReleaseIdGetResponse::GenericErrorResponse(body) => {
+                                let body_string = serde_json::to_string(&body)
+                                    .expect("impossible to fail to serialize");
+
+                                let mut response =
+                                    Response::with((status::Status::from_u16(0), body_string));
+                                response.headers.set(ContentType(
+                                    mimetypes::responses::RELEASE_ID_GET_GENERIC_ERROR_RESPONSE
+                                        .clone(),
+                                ));
+
+                                context
+                                    .x_span_id
+                                    .as_ref()
+                                    .map(|header| response.headers.set(XSpanId(header.clone())));
+
+                                Ok(response)
+                            }
+                        }
+                    }
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "ReleaseIdGet");
+        "ReleaseIdGet",
+    );
 
     let api_clone = api.clone();
     router.get(
@@ -1343,84 +2146,142 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
-
                 // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
                 let query_params = req.get::<UrlEncodedQuery>().unwrap_or_default();
-                let param_doi = query_params.get("doi")
-                    .ok_or_else(|| Response::with((status::BadRequest, "Missing required query parameter doi".to_string())))?
-                    .first().ok_or_else(|| Response::with((status::BadRequest, "Required query parameter doi was empty".to_string())))?
-                    .parse::<String>().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse query parameter doi - doesn't match schema: {}", e))))?;
-
+                let param_doi = query_params
+                    .get("doi")
+                    .ok_or_else(|| {
+                        Response::with((
+                            status::BadRequest,
+                            "Missing required query parameter doi".to_string(),
+                        ))
+                    })?
+                    .first()
+                    .ok_or_else(|| {
+                        Response::with((
+                            status::BadRequest,
+                            "Required query parameter doi was empty".to_string(),
+                        ))
+                    })?
+                    .parse::<String>()
+                    .map_err(|e| {
+                        Response::with((
+                            status::BadRequest,
+                            format!(
+                                "Couldn't parse query parameter doi - doesn't match schema: {}",
+                                e
+                            ),
+                        ))
+                    })?;
 
                 match api.release_lookup_get(param_doi, context).wait() {
                     Ok(rsp) => match rsp {
                         ReleaseLookupGetResponse::FindASingleReleaseByExternalIdentifer(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(200), body_string));    
+                            let mut response =
+                                Response::with((status::Status::from_u16(200), body_string));
                             response.headers.set(ContentType(mimetypes::responses::RELEASE_LOOKUP_GET_FIND_A_SINGLE_RELEASE_BY_EXTERNAL_IDENTIFER.clone()));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         ReleaseLookupGetResponse::BadRequest(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
+                            let mut response =
+                                Response::with((status::Status::from_u16(400), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::RELEASE_LOOKUP_GET_BAD_REQUEST.clone(),
+                            ));
 
-                            let mut response = Response::with((status::Status::from_u16(400), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::RELEASE_LOOKUP_GET_BAD_REQUEST.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         ReleaseLookupGetResponse::NoSuchRelease(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(404), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::RELEASE_LOOKUP_GET_NO_SUCH_RELEASE.clone()));
+                            let mut response =
+                                Response::with((status::Status::from_u16(404), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::RELEASE_LOOKUP_GET_NO_SUCH_RELEASE.clone(),
+                            ));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         ReleaseLookupGetResponse::GenericErrorResponse(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
+                            let mut response =
+                                Response::with((status::Status::from_u16(0), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::RELEASE_LOOKUP_GET_GENERIC_ERROR_RESPONSE
+                                    .clone(),
+                            ));
 
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::RELEASE_LOOKUP_GET_GENERIC_ERROR_RESPONSE.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                     },
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "ReleaseLookupGet");
+        "ReleaseLookupGet",
+    );
 
     let api_clone = api.clone();
     router.post(
@@ -1429,15 +2290,23 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
-
                 // Body parameters (note that non-required body parameters will ignore garbage
                 // values, rather than causing a 400 response). Produce warning header and logs for
                 // any unused fields.
@@ -1446,10 +2315,11 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
 
                 let mut unused_elements = Vec::new();
 
-                let param_body = if let Some(param_body_raw) = param_body { 
+                let param_body = if let Some(param_body_raw) = param_body {
                     let deserializer = &mut serde_json::Deserializer::from_str(&param_body_raw);
 
-                    let param_body: Option<models::ReleaseEntity> = serde_ignored::deserialize(deserializer, |path| {
+                    let param_body: Option<models::ReleaseEntity> =
+                        serde_ignored::deserialize(deserializer, |path| {
                             warn!("Ignoring unknown field in body: {}", path);
                             unused_elements.push(path.to_string());
                         }).unwrap_or(None);
@@ -1457,65 +2327,98 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
                     param_body
                 } else {
                     None
-                };;
-
+                };
 
                 match api.release_post(param_body, context).wait() {
                     Ok(rsp) => match rsp {
                         ReleasePostResponse::Created(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(201), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::RELEASE_POST_CREATED.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
+
+                            let mut response =
+                                Response::with((status::Status::from_u16(201), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::RELEASE_POST_CREATED.clone(),
+                            ));
+
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
                             if !unused_elements.is_empty() {
-                                response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements)));
+                                response.headers.set(Warning(format!(
+                                    "Ignoring unknown fields in body: {:?}",
+                                    unused_elements
+                                )));
                             }
                             Ok(response)
-                        },
+                        }
                         ReleasePostResponse::BadRequest(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(400), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::RELEASE_POST_BAD_REQUEST.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
+
+                            let mut response =
+                                Response::with((status::Status::from_u16(400), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::RELEASE_POST_BAD_REQUEST.clone(),
+                            ));
+
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
                             if !unused_elements.is_empty() {
-                                response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements)));
+                                response.headers.set(Warning(format!(
+                                    "Ignoring unknown fields in body: {:?}",
+                                    unused_elements
+                                )));
                             }
                             Ok(response)
-                        },
+                        }
                         ReleasePostResponse::GenericErrorResponse(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::RELEASE_POST_GENERIC_ERROR_RESPONSE.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
+
+                            let mut response =
+                                Response::with((status::Status::from_u16(0), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::RELEASE_POST_GENERIC_ERROR_RESPONSE.clone(),
+                            ));
+
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
                             if !unused_elements.is_empty() {
-                                response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements)));
+                                response.headers.set(Warning(format!(
+                                    "Ignoring unknown fields in body: {:?}",
+                                    unused_elements
+                                )));
                             }
                             Ok(response)
-                        },
+                        }
                     },
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "ReleasePost");
+        "ReleasePost",
+    );
 
     let api_clone = api.clone();
     router.get(
@@ -1524,75 +2427,135 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
                 // Path parameters
                 let param_id = {
-                    let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))?
-                        .find("id").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter id".to_string())))?;
-                    percent_decode(param.as_bytes()).decode_utf8()
-                        .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))?
-                        .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter id: {}", e))))?
+                    let param = req.extensions
+                        .get::<Router>()
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::InternalServerError,
+                                "An internal error occurred".to_string(),
+                            ))
+                        })?
+                        .find("id")
+                        .ok_or_else(|| {
+                            Response::with((
+                                status::BadRequest,
+                                "Missing path parameter id".to_string(),
+                            ))
+                        })?;
+                    percent_decode(param.as_bytes())
+                        .decode_utf8()
+                        .map_err(|_| {
+                            Response::with((
+                                status::BadRequest,
+                                format!(
+                                    "Couldn't percent-decode path parameter as UTF-8: {}",
+                                    param
+                                ),
+                            ))
+                        })?
+                        .parse()
+                        .map_err(|e| {
+                            Response::with((
+                                status::BadRequest,
+                                format!("Couldn't parse path parameter id: {}", e),
+                            ))
+                        })?
                 };
 
-
-
                 match api.work_id_get(param_id, context).wait() {
                     Ok(rsp) => match rsp {
                         WorkIdGetResponse::FetchASingleWorkById(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
+                            let mut response =
+                                Response::with((status::Status::from_u16(200), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::WORK_ID_GET_FETCH_A_SINGLE_WORK_BY_ID.clone(),
+                            ));
 
-                            let mut response = Response::with((status::Status::from_u16(200), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::WORK_ID_GET_FETCH_A_SINGLE_WORK_BY_ID.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         WorkIdGetResponse::BadRequest(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(400), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::WORK_ID_GET_BAD_REQUEST.clone()));
+                            let mut response =
+                                Response::with((status::Status::from_u16(400), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::WORK_ID_GET_BAD_REQUEST.clone(),
+                            ));
 
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                         WorkIdGetResponse::GenericErrorResponse(body) => {
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
 
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
+                            let mut response =
+                                Response::with((status::Status::from_u16(0), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::WORK_ID_GET_GENERIC_ERROR_RESPONSE.clone(),
+                            ));
 
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::WORK_ID_GET_GENERIC_ERROR_RESPONSE.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
 
                             Ok(response)
-                        },
+                        }
                     },
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "WorkIdGet");
+        "WorkIdGet",
+    );
 
     let api_clone = api.clone();
     router.post(
@@ -1601,15 +2564,23 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
             let mut context = Context::default();
 
             // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
-            fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api {
-
-                context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
+            fn handle_request<T>(
+                req: &mut Request,
+                api: &T,
+                context: &mut Context,
+            ) -> Result<Response, Response>
+            where
+                T: Api,
+            {
+                context.x_span_id = Some(
+                    req.headers
+                        .get::<XSpanId>()
+                        .map(XSpanId::to_string)
+                        .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()),
+                );
                 context.auth_data = req.extensions.remove::<AuthData>();
                 context.authorization = req.extensions.remove::<Authorization>();
 
-
-
-
                 // Body parameters (note that non-required body parameters will ignore garbage
                 // values, rather than causing a 400 response). Produce warning header and logs for
                 // any unused fields.
@@ -1618,10 +2589,11 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
 
                 let mut unused_elements = Vec::new();
 
-                let param_body = if let Some(param_body_raw) = param_body { 
+                let param_body = if let Some(param_body_raw) = param_body {
                     let deserializer = &mut serde_json::Deserializer::from_str(&param_body_raw);
 
-                    let param_body: Option<models::WorkEntity> = serde_ignored::deserialize(deserializer, |path| {
+                    let param_body: Option<models::WorkEntity> =
+                        serde_ignored::deserialize(deserializer, |path| {
                             warn!("Ignoring unknown field in body: {}", path);
                             unused_elements.push(path.to_string());
                         }).unwrap_or(None);
@@ -1629,66 +2601,98 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone
                     param_body
                 } else {
                     None
-                };;
-
+                };
 
                 match api.work_post(param_body, context).wait() {
                     Ok(rsp) => match rsp {
                         WorkPostResponse::Created(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(201), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::WORK_POST_CREATED.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
+
+                            let mut response =
+                                Response::with((status::Status::from_u16(201), body_string));
+                            response
+                                .headers
+                                .set(ContentType(mimetypes::responses::WORK_POST_CREATED.clone()));
+
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
                             if !unused_elements.is_empty() {
-                                response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements)));
+                                response.headers.set(Warning(format!(
+                                    "Ignoring unknown fields in body: {:?}",
+                                    unused_elements
+                                )));
                             }
                             Ok(response)
-                        },
+                        }
                         WorkPostResponse::BadRequest(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(400), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::WORK_POST_BAD_REQUEST.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
+
+                            let mut response =
+                                Response::with((status::Status::from_u16(400), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::WORK_POST_BAD_REQUEST.clone(),
+                            ));
+
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
                             if !unused_elements.is_empty() {
-                                response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements)));
+                                response.headers.set(Warning(format!(
+                                    "Ignoring unknown fields in body: {:?}",
+                                    unused_elements
+                                )));
                             }
                             Ok(response)
-                        },
+                        }
                         WorkPostResponse::GenericErrorResponse(body) => {
-
-                            let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize");
-
-                            let mut response = Response::with((status::Status::from_u16(0), body_string));    
-                            response.headers.set(ContentType(mimetypes::responses::WORK_POST_GENERIC_ERROR_RESPONSE.clone()));
-
-                            context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                            let body_string = serde_json::to_string(&body)
+                                .expect("impossible to fail to serialize");
+
+                            let mut response =
+                                Response::with((status::Status::from_u16(0), body_string));
+                            response.headers.set(ContentType(
+                                mimetypes::responses::WORK_POST_GENERIC_ERROR_RESPONSE.clone(),
+                            ));
+
+                            context
+                                .x_span_id
+                                .as_ref()
+                                .map(|header| response.headers.set(XSpanId(header.clone())));
                             if !unused_elements.is_empty() {
-                                response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements)));
+                                response.headers.set(Warning(format!(
+                                    "Ignoring unknown fields in body: {:?}",
+                                    unused_elements
+                                )));
                             }
                             Ok(response)
-                        },
+                        }
                     },
                     Err(_) => {
                         // Application code returned an error. This should not happen, as the implementation should
                         // return a valid response.
-                        Err(Response::with((status::InternalServerError, "An internal error occurred".to_string())))
+                        Err(Response::with((
+                            status::InternalServerError,
+                            "An internal error occurred".to_string(),
+                        )))
                     }
                 }
             }
 
             handle_request(req, &api_clone, &mut context).or_else(|mut response| {
-                context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone())));
+                context
+                    .x_span_id
+                    .as_ref()
+                    .map(|header| response.headers.set(XSpanId(header.clone())));
                 Ok(response)
             })
         },
-        "WorkPost");
-
+        "WorkPost",
+    );
 }
 
 /// Middleware to extract authentication data from request
@@ -1696,7 +2700,6 @@ pub struct ExtractAuthData;
 
 impl BeforeMiddleware for ExtractAuthData {
     fn before(&self, req: &mut Request) -> IronResult<()> {
-
         Ok(())
     }
 }