move source code to top-level directory

6 files changed, 0 insertions, 43745 deletions

diff --git a/rust/fatcat-openapi/src/client/mod.rs b/rust/fatcat-openapi/src/client/mod.rs
deleted file mode 100644
index bb1cee8..0000000
--- a/rust/fatcat-openapi/src/client/mod.rs
+++ /dev/null
@@ -1,16107 +0,0 @@
-use async_trait::async_trait;
-use futures::{
-    future, future::BoxFuture, future::FutureExt, future::TryFutureExt, stream, stream::StreamExt,
-    Stream,
-};
-use hyper::header::{HeaderName, HeaderValue, CONTENT_TYPE};
-use hyper::{service::Service, Body, Request, Response, Uri};
-use percent_encoding::{utf8_percent_encode, AsciiSet};
-use std::borrow::Cow;
-use std::convert::TryInto;
-use std::error::Error;
-use std::fmt;
-use std::future::Future;
-use std::io::{ErrorKind, Read};
-use std::marker::PhantomData;
-use std::path::Path;
-use std::str;
-use std::str::FromStr;
-use std::string::ToString;
-use std::sync::{Arc, Mutex};
-use std::task::{Context, Poll};
-use swagger::{ApiError, AuthData, BodyExt, Connector, DropContextService, Has, XSpanIdString};
-use url::form_urlencoded;
-
-use crate::header;
-use crate::models;
-
-/// https://url.spec.whatwg.org/#fragment-percent-encode-set
-#[allow(dead_code)]
-const FRAGMENT_ENCODE_SET: &AsciiSet = &percent_encoding::CONTROLS
-    .add(b' ')
-    .add(b'"')
-    .add(b'<')
-    .add(b'>')
-    .add(b'`');
-
-/// This encode set is used for object IDs
-///
-/// Aside from the special characters defined in the `PATH_SEGMENT_ENCODE_SET`,
-/// the vertical bar (|) is encoded.
-#[allow(dead_code)]
-const ID_ENCODE_SET: &AsciiSet = &FRAGMENT_ENCODE_SET.add(b'|');
-
-use crate::{
-    AcceptEditgroupResponse, Api, AuthCheckResponse, AuthOidcResponse, CreateAuthTokenResponse,
-    CreateContainerAutoBatchResponse, CreateContainerResponse, CreateCreatorAutoBatchResponse,
-    CreateCreatorResponse, CreateEditgroupAnnotationResponse, CreateEditgroupResponse,
-    CreateFileAutoBatchResponse, CreateFileResponse, CreateFilesetAutoBatchResponse,
-    CreateFilesetResponse, CreateReleaseAutoBatchResponse, CreateReleaseResponse,
-    CreateWebcaptureAutoBatchResponse, CreateWebcaptureResponse, CreateWorkAutoBatchResponse,
-    CreateWorkResponse, DeleteContainerEditResponse, DeleteContainerResponse,
-    DeleteCreatorEditResponse, DeleteCreatorResponse, DeleteFileEditResponse, DeleteFileResponse,
-    DeleteFilesetEditResponse, DeleteFilesetResponse, DeleteReleaseEditResponse,
-    DeleteReleaseResponse, DeleteWebcaptureEditResponse, DeleteWebcaptureResponse,
-    DeleteWorkEditResponse, DeleteWorkResponse, GetChangelogEntryResponse, GetChangelogResponse,
-    GetContainerEditResponse, GetContainerHistoryResponse, GetContainerRedirectsResponse,
-    GetContainerResponse, GetContainerRevisionResponse, GetCreatorEditResponse,
-    GetCreatorHistoryResponse, GetCreatorRedirectsResponse, GetCreatorReleasesResponse,
-    GetCreatorResponse, GetCreatorRevisionResponse, GetEditgroupAnnotationsResponse,
-    GetEditgroupResponse, GetEditgroupsReviewableResponse, GetEditorAnnotationsResponse,
-    GetEditorEditgroupsResponse, GetEditorResponse, GetFileEditResponse, GetFileHistoryResponse,
-    GetFileRedirectsResponse, GetFileResponse, GetFileRevisionResponse, GetFilesetEditResponse,
-    GetFilesetHistoryResponse, GetFilesetRedirectsResponse, GetFilesetResponse,
-    GetFilesetRevisionResponse, GetReleaseEditResponse, GetReleaseFilesResponse,
-    GetReleaseFilesetsResponse, GetReleaseHistoryResponse, GetReleaseRedirectsResponse,
-    GetReleaseResponse, GetReleaseRevisionResponse, GetReleaseWebcapturesResponse,
-    GetWebcaptureEditResponse, GetWebcaptureHistoryResponse, GetWebcaptureRedirectsResponse,
-    GetWebcaptureResponse, GetWebcaptureRevisionResponse, GetWorkEditResponse,
-    GetWorkHistoryResponse, GetWorkRedirectsResponse, GetWorkReleasesResponse, GetWorkResponse,
-    GetWorkRevisionResponse, LookupContainerResponse, LookupCreatorResponse, LookupFileResponse,
-    LookupReleaseResponse, UpdateContainerResponse, UpdateCreatorResponse, UpdateEditgroupResponse,
-    UpdateEditorResponse, UpdateFileResponse, UpdateFilesetResponse, UpdateReleaseResponse,
-    UpdateWebcaptureResponse, UpdateWorkResponse,
-};
-
-/// Convert input into a base path, e.g. "http://example:123". Also checks the scheme as it goes.
-fn into_base_path(
-    input: impl TryInto<Uri, Error = hyper::http::uri::InvalidUri>,
-    correct_scheme: Option<&'static str>,
-) -> Result<String, ClientInitError> {
-    // First convert to Uri, since a base path is a subset of Uri.
-    let uri = input.try_into()?;
-
-    let scheme = uri.scheme_str().ok_or(ClientInitError::InvalidScheme)?;
-
-    // Check the scheme if necessary
-    if let Some(correct_scheme) = correct_scheme {
-        if scheme != correct_scheme {
-            return Err(ClientInitError::InvalidScheme);
-        }
-    }
-
-    let host = uri.host().ok_or_else(|| ClientInitError::MissingHost)?;
-    let port = uri
-        .port_u16()
-        .map(|x| format!(":{}", x))
-        .unwrap_or_default();
-    Ok(format!(
-        "{}://{}{}{}",
-        scheme,
-        host,
-        port,
-        uri.path().trim_end_matches('/')
-    ))
-}
-
-/// A client that implements the API by making HTTP calls out to a server.
-pub struct Client<S, C>
-where
-    S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static,
-    S::Future: Send + 'static,
-    S::Error: Into<crate::ServiceError> + fmt::Display,
-    C: Clone + Send + Sync + 'static,
-{
-    /// Inner service
-    client_service: S,
-
-    /// Base path of the API
-    base_path: String,
-
-    /// Marker
-    marker: PhantomData<fn(C)>,
-}
-
-impl<S, C> fmt::Debug for Client<S, C>
-where
-    S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static,
-    S::Future: Send + 'static,
-    S::Error: Into<crate::ServiceError> + fmt::Display,
-    C: Clone + Send + Sync + 'static,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Client {{ base_path: {} }}", self.base_path)
-    }
-}
-
-impl<S, C> Clone for Client<S, C>
-where
-    S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static,
-    S::Future: Send + 'static,
-    S::Error: Into<crate::ServiceError> + fmt::Display,
-    C: Clone + Send + Sync + 'static,
-{
-    fn clone(&self) -> Self {
-        Self {
-            client_service: self.client_service.clone(),
-            base_path: self.base_path.clone(),
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<Connector, C> Client<DropContextService<hyper::client::Client<Connector, Body>, C>, C>
-where
-    Connector: hyper::client::connect::Connect + Clone + Send + Sync + 'static,
-    C: Clone + Send + Sync + 'static,
-{
-    /// Create a client with a custom implementation of hyper::client::Connect.
-    ///
-    /// Intended for use with custom implementations of connect for e.g. protocol logging
-    /// or similar functionality which requires wrapping the transport layer. When wrapping a TCP connection,
-    /// this function should be used in conjunction with `swagger::Connector::builder()`.
-    ///
-    /// For ordinary tcp connections, prefer the use of `try_new_http`, `try_new_https`
-    /// and `try_new_https_mutual`, to avoid introducing a dependency on the underlying transport layer.
-    ///
-    /// # Arguments
-    ///
-    /// * `base_path` - base path of the client API, i.e. "http://www.my-api-implementation.com"
-    /// * `protocol` - Which protocol to use when constructing the request url, e.g. `Some("http")`
-    /// * `connector` - Implementation of `hyper::client::Connect` to use for the client
-    pub fn try_new_with_connector(
-        base_path: &str,
-        protocol: Option<&'static str>,
-        connector: Connector,
-    ) -> Result<Self, ClientInitError> {
-        let client_service = hyper::client::Client::builder().build(connector);
-        let client_service = DropContextService::new(client_service);
-
-        Ok(Self {
-            client_service,
-            base_path: into_base_path(base_path, protocol)?,
-            marker: PhantomData,
-        })
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum HyperClient {
-    Http(hyper::client::Client<hyper::client::HttpConnector, Body>),
-    Https(hyper::client::Client<HttpsConnector, Body>),
-}
-
-impl Service<Request<Body>> for HyperClient {
-    type Response = Response<Body>;
-    type Error = hyper::Error;
-    type Future = hyper::client::ResponseFuture;
-
-    fn poll_ready(&mut self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
-        match self {
-            HyperClient::Http(client) => client.poll_ready(cx),
-            HyperClient::Https(client) => client.poll_ready(cx),
-        }
-    }
-
-    fn call(&mut self, req: Request<Body>) -> Self::Future {
-        match self {
-            HyperClient::Http(client) => client.call(req),
-            HyperClient::Https(client) => client.call(req),
-        }
-    }
-}
-
-impl<C> Client<DropContextService<HyperClient, C>, C>
-where
-    C: Clone + Send + Sync + 'static,
-{
-    /// Create an HTTP client.
-    ///
-    /// # Arguments
-    /// * `base_path` - base path of the client API, i.e. "http://www.my-api-implementation.com"
-    pub fn try_new(base_path: &str) -> Result<Self, ClientInitError> {
-        let uri = Uri::from_str(base_path)?;
-
-        let scheme = uri.scheme_str().ok_or(ClientInitError::InvalidScheme)?;
-        let scheme = scheme.to_ascii_lowercase();
-
-        let connector = Connector::builder();
-
-        let client_service = match scheme.as_str() {
-            "http" => HyperClient::Http(hyper::client::Client::builder().build(connector.build())),
-            "https" => {
-                let connector = connector
-                    .https()
-                    .build()
-                    .map_err(|e| ClientInitError::SslError(e))?;
-                HyperClient::Https(hyper::client::Client::builder().build(connector))
-            }
-            _ => {
-                return Err(ClientInitError::InvalidScheme);
-            }
-        };
-
-        let client_service = DropContextService::new(client_service);
-
-        Ok(Self {
-            client_service,
-            base_path: into_base_path(base_path, None)?,
-            marker: PhantomData,
-        })
-    }
-}
-
-impl<C> Client<DropContextService<hyper::client::Client<hyper::client::HttpConnector, Body>, C>, C>
-where
-    C: Clone + Send + Sync + 'static,
-{
-    /// Create an HTTP client.
-    ///
-    /// # Arguments
-    /// * `base_path` - base path of the client API, i.e. "http://www.my-api-implementation.com"
-    pub fn try_new_http(base_path: &str) -> Result<Self, ClientInitError> {
-        let http_connector = Connector::builder().build();
-
-        Self::try_new_with_connector(base_path, Some("http"), http_connector)
-    }
-}
-
-#[cfg(any(target_os = "macos", target_os = "windows", target_os = "ios"))]
-type HttpsConnector = hyper_tls::HttpsConnector<hyper::client::HttpConnector>;
-
-#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
-type HttpsConnector = hyper_openssl::HttpsConnector<hyper::client::HttpConnector>;
-
-impl<C> Client<DropContextService<hyper::client::Client<HttpsConnector, Body>, C>, C>
-where
-    C: Clone + Send + Sync + 'static,
-{
-    /// Create a client with a TLS connection to the server
-    ///
-    /// # Arguments
-    /// * `base_path` - base path of the client API, i.e. "https://www.my-api-implementation.com"
-    pub fn try_new_https(base_path: &str) -> Result<Self, ClientInitError> {
-        let https_connector = Connector::builder()
-            .https()
-            .build()
-            .map_err(|e| ClientInitError::SslError(e))?;
-        Self::try_new_with_connector(base_path, Some("https"), https_connector)
-    }
-
-    /// Create a client with a TLS connection to the server using a pinned certificate
-    ///
-    /// # Arguments
-    /// * `base_path` - base path of the client API, i.e. "https://www.my-api-implementation.com"
-    /// * `ca_certificate` - Path to CA certificate used to authenticate the server
-    #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
-    pub fn try_new_https_pinned<CA>(
-        base_path: &str,
-        ca_certificate: CA,
-    ) -> Result<Self, ClientInitError>
-    where
-        CA: AsRef<Path>,
-    {
-        let https_connector = Connector::builder()
-            .https()
-            .pin_server_certificate(ca_certificate)
-            .build()
-            .map_err(|e| ClientInitError::SslError(e))?;
-        Self::try_new_with_connector(base_path, Some("https"), https_connector)
-    }
-
-    /// Create a client with a mutually authenticated TLS connection to the server.
-    ///
-    /// # Arguments
-    /// * `base_path` - base path of the client API, i.e. "https://www.my-api-implementation.com"
-    /// * `ca_certificate` - Path to CA certificate used to authenticate the server
-    /// * `client_key` - Path to the client private key
-    /// * `client_certificate` - Path to the client's public certificate associated with the private key
-    #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
-    pub fn try_new_https_mutual<CA, K, D>(
-        base_path: &str,
-        ca_certificate: CA,
-        client_key: K,
-        client_certificate: D,
-    ) -> Result<Self, ClientInitError>
-    where
-        CA: AsRef<Path>,
-        K: AsRef<Path>,
-        D: AsRef<Path>,
-    {
-        let https_connector = Connector::builder()
-            .https()
-            .pin_server_certificate(ca_certificate)
-            .client_authentication(client_key, client_certificate)
-            .build()
-            .map_err(|e| ClientInitError::SslError(e))?;
-        Self::try_new_with_connector(base_path, Some("https"), https_connector)
-    }
-}
-
-impl<S, C> Client<S, C>
-where
-    S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static,
-    S::Future: Send + 'static,
-    S::Error: Into<crate::ServiceError> + fmt::Display,
-    C: Clone + Send + Sync + 'static,
-{
-    /// Constructor for creating a `Client` by passing in a pre-made `hyper::service::Service` /
-    /// `tower::Service`
-    ///
-    /// This allows adding custom wrappers around the underlying transport, for example for logging.
-    pub fn try_new_with_client_service(
-        client_service: S,
-        base_path: &str,
-    ) -> Result<Self, ClientInitError> {
-        Ok(Self {
-            client_service,
-            base_path: into_base_path(base_path, None)?,
-            marker: PhantomData,
-        })
-    }
-}
-
-/// Error type failing to create a Client
-#[derive(Debug)]
-pub enum ClientInitError {
-    /// Invalid URL Scheme
-    InvalidScheme,
-
-    /// Invalid URI
-    InvalidUri(hyper::http::uri::InvalidUri),
-
-    /// Missing Hostname
-    MissingHost,
-
-    /// SSL Connection Error
-    #[cfg(any(target_os = "macos", target_os = "windows", target_os = "ios"))]
-    SslError(native_tls::Error),
-
-    /// SSL Connection Error
-    #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
-    SslError(openssl::error::ErrorStack),
-}
-
-impl From<hyper::http::uri::InvalidUri> for ClientInitError {
-    fn from(err: hyper::http::uri::InvalidUri) -> ClientInitError {
-        ClientInitError::InvalidUri(err)
-    }
-}
-
-impl fmt::Display for ClientInitError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let s: &dyn fmt::Debug = self;
-        s.fmt(f)
-    }
-}
-
-impl Error for ClientInitError {
-    fn description(&self) -> &str {
-        "Failed to produce a hyper client."
-    }
-}
-
-#[async_trait]
-impl<S, C> Api<C> for Client<S, C>
-where
-    S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static,
-    S::Future: Send + 'static,
-    S::Error: Into<crate::ServiceError> + fmt::Display,
-    C: Has<XSpanIdString> + Has<Option<AuthData>> + Clone + Send + Sync + 'static,
-{
-    fn poll_ready(&self, cx: &mut Context) -> Poll<Result<(), crate::ServiceError>> {
-        match self.client_service.clone().poll_ready(cx) {
-            Poll::Ready(Err(e)) => Poll::Ready(Err(e.into())),
-            Poll::Ready(Ok(o)) => Poll::Ready(Ok(o)),
-            Poll::Pending => Poll::Pending,
-        }
-    }
-
-    async fn accept_editgroup(
-        &self,
-        param_editgroup_id: String,
-        context: &C,
-    ) -> Result<AcceptEditgroupResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/accept",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Success>(body)?;
-                Ok(AcceptEditgroupResponse::MergedSuccessfully(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(AcceptEditgroupResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(AcceptEditgroupResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(AcceptEditgroupResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(AcceptEditgroupResponse::NotFound(body))
-            }
-            409 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(AcceptEditgroupResponse::EditConflict(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(AcceptEditgroupResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn auth_check(
-        &self,
-        param_role: Option<String>,
-        context: &C,
-    ) -> Result<AuthCheckResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!("{}/v0/auth/check", self.base_path);
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_role) = param_role {
-                query_string.append_pair("role", &param_role.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Success>(body)?;
-                Ok(AuthCheckResponse::Success(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(AuthCheckResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(AuthCheckResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(AuthCheckResponse::Forbidden(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(AuthCheckResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn auth_oidc(
-        &self,
-        param_auth_oidc: models::AuthOidc,
-        context: &C,
-    ) -> Result<AuthOidcResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!("{}/v0/auth/oidc", self.base_path);
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body =
-            serde_json::to_string(&param_auth_oidc).expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::AuthOidcResult>(body)?;
-                Ok(AuthOidcResponse::Found(body))
-            }
-            201 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::AuthOidcResult>(body)?;
-                Ok(AuthOidcResponse::Created(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(AuthOidcResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(AuthOidcResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(AuthOidcResponse::Forbidden(body))
-            }
-            409 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(AuthOidcResponse::Conflict(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(AuthOidcResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn create_auth_token(
-        &self,
-        param_editor_id: String,
-        param_duration_seconds: Option<i32>,
-        context: &C,
-    ) -> Result<CreateAuthTokenResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/auth/token/{editor_id}",
-            self.base_path,
-            editor_id = utf8_percent_encode(&param_editor_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_duration_seconds) = param_duration_seconds {
-                query_string.append_pair("duration_seconds", &param_duration_seconds.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::AuthTokenResult>(body)?;
-                Ok(CreateAuthTokenResponse::Success(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateAuthTokenResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateAuthTokenResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateAuthTokenResponse::Forbidden(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateAuthTokenResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn create_container(
-        &self,
-        param_editgroup_id: String,
-        param_container_entity: models::ContainerEntity,
-        context: &C,
-    ) -> Result<CreateContainerResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/container",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body = serde_json::to_string(&param_container_entity)
-            .expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            201 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(CreateContainerResponse::CreatedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateContainerResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateContainerResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateContainerResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateContainerResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateContainerResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn create_container_auto_batch(
-        &self,
-        param_container_auto_batch: models::ContainerAutoBatch,
-        context: &C,
-    ) -> Result<CreateContainerAutoBatchResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!("{}/v0/editgroup/auto/container/batch", self.base_path);
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body = serde_json::to_string(&param_container_auto_batch)
-            .expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            201 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Editgroup>(body)?;
-                Ok(CreateContainerAutoBatchResponse::CreatedEditgroup(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateContainerAutoBatchResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateContainerAutoBatchResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateContainerAutoBatchResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateContainerAutoBatchResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateContainerAutoBatchResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn create_creator(
-        &self,
-        param_editgroup_id: String,
-        param_creator_entity: models::CreatorEntity,
-        context: &C,
-    ) -> Result<CreateCreatorResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/creator",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body =
-            serde_json::to_string(&param_creator_entity).expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            201 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(CreateCreatorResponse::CreatedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateCreatorResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateCreatorResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateCreatorResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateCreatorResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateCreatorResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn create_creator_auto_batch(
-        &self,
-        param_creator_auto_batch: models::CreatorAutoBatch,
-        context: &C,
-    ) -> Result<CreateCreatorAutoBatchResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!("{}/v0/editgroup/auto/creator/batch", self.base_path);
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body = serde_json::to_string(&param_creator_auto_batch)
-            .expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            201 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Editgroup>(body)?;
-                Ok(CreateCreatorAutoBatchResponse::CreatedEditgroup(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateCreatorAutoBatchResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateCreatorAutoBatchResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateCreatorAutoBatchResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateCreatorAutoBatchResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateCreatorAutoBatchResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn create_editgroup(
-        &self,
-        param_editgroup: models::Editgroup,
-        context: &C,
-    ) -> Result<CreateEditgroupResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!("{}/v0/editgroup", self.base_path);
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body =
-            serde_json::to_string(&param_editgroup).expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            201 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Editgroup>(body)?;
-                Ok(CreateEditgroupResponse::SuccessfullyCreated(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateEditgroupResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateEditgroupResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateEditgroupResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateEditgroupResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateEditgroupResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn create_editgroup_annotation(
-        &self,
-        param_editgroup_id: String,
-        param_editgroup_annotation: models::EditgroupAnnotation,
-        context: &C,
-    ) -> Result<CreateEditgroupAnnotationResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/annotation",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body = serde_json::to_string(&param_editgroup_annotation)
-            .expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            201 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EditgroupAnnotation>(body)?;
-                Ok(CreateEditgroupAnnotationResponse::Created(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateEditgroupAnnotationResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateEditgroupAnnotationResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateEditgroupAnnotationResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateEditgroupAnnotationResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateEditgroupAnnotationResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn create_file(
-        &self,
-        param_editgroup_id: String,
-        param_file_entity: models::FileEntity,
-        context: &C,
-    ) -> Result<CreateFileResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/file",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body =
-            serde_json::to_string(&param_file_entity).expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            201 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(CreateFileResponse::CreatedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFileResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFileResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFileResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFileResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFileResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn create_file_auto_batch(
-        &self,
-        param_file_auto_batch: models::FileAutoBatch,
-        context: &C,
-    ) -> Result<CreateFileAutoBatchResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!("{}/v0/editgroup/auto/file/batch", self.base_path);
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body =
-            serde_json::to_string(&param_file_auto_batch).expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            201 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Editgroup>(body)?;
-                Ok(CreateFileAutoBatchResponse::CreatedEditgroup(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFileAutoBatchResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFileAutoBatchResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFileAutoBatchResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFileAutoBatchResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFileAutoBatchResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn create_fileset(
-        &self,
-        param_editgroup_id: String,
-        param_fileset_entity: models::FilesetEntity,
-        context: &C,
-    ) -> Result<CreateFilesetResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/fileset",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body =
-            serde_json::to_string(&param_fileset_entity).expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            201 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(CreateFilesetResponse::CreatedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFilesetResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFilesetResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFilesetResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFilesetResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFilesetResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn create_fileset_auto_batch(
-        &self,
-        param_fileset_auto_batch: models::FilesetAutoBatch,
-        context: &C,
-    ) -> Result<CreateFilesetAutoBatchResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!("{}/v0/editgroup/auto/fileset/batch", self.base_path);
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body = serde_json::to_string(&param_fileset_auto_batch)
-            .expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            201 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Editgroup>(body)?;
-                Ok(CreateFilesetAutoBatchResponse::CreatedEditgroup(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFilesetAutoBatchResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFilesetAutoBatchResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFilesetAutoBatchResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFilesetAutoBatchResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateFilesetAutoBatchResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn create_release(
-        &self,
-        param_editgroup_id: String,
-        param_release_entity: models::ReleaseEntity,
-        context: &C,
-    ) -> Result<CreateReleaseResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/release",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body =
-            serde_json::to_string(&param_release_entity).expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            201 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(CreateReleaseResponse::CreatedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateReleaseResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateReleaseResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateReleaseResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateReleaseResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateReleaseResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn create_release_auto_batch(
-        &self,
-        param_release_auto_batch: models::ReleaseAutoBatch,
-        context: &C,
-    ) -> Result<CreateReleaseAutoBatchResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!("{}/v0/editgroup/auto/release/batch", self.base_path);
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body = serde_json::to_string(&param_release_auto_batch)
-            .expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            201 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Editgroup>(body)?;
-                Ok(CreateReleaseAutoBatchResponse::CreatedEditgroup(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateReleaseAutoBatchResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateReleaseAutoBatchResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateReleaseAutoBatchResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateReleaseAutoBatchResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateReleaseAutoBatchResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn create_webcapture(
-        &self,
-        param_editgroup_id: String,
-        param_webcapture_entity: models::WebcaptureEntity,
-        context: &C,
-    ) -> Result<CreateWebcaptureResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/webcapture",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body = serde_json::to_string(&param_webcapture_entity)
-            .expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            201 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(CreateWebcaptureResponse::CreatedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWebcaptureResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWebcaptureResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWebcaptureResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWebcaptureResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWebcaptureResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn create_webcapture_auto_batch(
-        &self,
-        param_webcapture_auto_batch: models::WebcaptureAutoBatch,
-        context: &C,
-    ) -> Result<CreateWebcaptureAutoBatchResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!("{}/v0/editgroup/auto/webcapture/batch", self.base_path);
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body = serde_json::to_string(&param_webcapture_auto_batch)
-            .expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            201 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Editgroup>(body)?;
-                Ok(CreateWebcaptureAutoBatchResponse::CreatedEditgroup(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWebcaptureAutoBatchResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWebcaptureAutoBatchResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWebcaptureAutoBatchResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWebcaptureAutoBatchResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWebcaptureAutoBatchResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn create_work(
-        &self,
-        param_editgroup_id: String,
-        param_work_entity: models::WorkEntity,
-        context: &C,
-    ) -> Result<CreateWorkResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/work",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body =
-            serde_json::to_string(&param_work_entity).expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            201 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(CreateWorkResponse::CreatedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWorkResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWorkResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWorkResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWorkResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWorkResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn create_work_auto_batch(
-        &self,
-        param_work_auto_batch: models::WorkAutoBatch,
-        context: &C,
-    ) -> Result<CreateWorkAutoBatchResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!("{}/v0/editgroup/auto/work/batch", self.base_path);
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("POST")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body =
-            serde_json::to_string(&param_work_auto_batch).expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            201 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Editgroup>(body)?;
-                Ok(CreateWorkAutoBatchResponse::CreatedEditgroup(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWorkAutoBatchResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWorkAutoBatchResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWorkAutoBatchResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWorkAutoBatchResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(CreateWorkAutoBatchResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn delete_container(
-        &self,
-        param_editgroup_id: String,
-        param_ident: String,
-        context: &C,
-    ) -> Result<DeleteContainerResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/container/{ident}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("DELETE")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(DeleteContainerResponse::DeletedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteContainerResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteContainerResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteContainerResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteContainerResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteContainerResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn delete_container_edit(
-        &self,
-        param_editgroup_id: String,
-        param_edit_id: String,
-        context: &C,
-    ) -> Result<DeleteContainerEditResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/container/edit/{edit_id}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            edit_id = utf8_percent_encode(&param_edit_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("DELETE")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Success>(body)?;
-                Ok(DeleteContainerEditResponse::DeletedEdit(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteContainerEditResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteContainerEditResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteContainerEditResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteContainerEditResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteContainerEditResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn delete_creator(
-        &self,
-        param_editgroup_id: String,
-        param_ident: String,
-        context: &C,
-    ) -> Result<DeleteCreatorResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/creator/{ident}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("DELETE")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(DeleteCreatorResponse::DeletedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteCreatorResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteCreatorResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteCreatorResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteCreatorResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteCreatorResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn delete_creator_edit(
-        &self,
-        param_editgroup_id: String,
-        param_edit_id: String,
-        context: &C,
-    ) -> Result<DeleteCreatorEditResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/creator/edit/{edit_id}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            edit_id = utf8_percent_encode(&param_edit_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("DELETE")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Success>(body)?;
-                Ok(DeleteCreatorEditResponse::DeletedEdit(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteCreatorEditResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteCreatorEditResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteCreatorEditResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteCreatorEditResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteCreatorEditResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn delete_file(
-        &self,
-        param_editgroup_id: String,
-        param_ident: String,
-        context: &C,
-    ) -> Result<DeleteFileResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/file/{ident}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("DELETE")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(DeleteFileResponse::DeletedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFileResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFileResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFileResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFileResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFileResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn delete_file_edit(
-        &self,
-        param_editgroup_id: String,
-        param_edit_id: String,
-        context: &C,
-    ) -> Result<DeleteFileEditResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/file/edit/{edit_id}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            edit_id = utf8_percent_encode(&param_edit_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("DELETE")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Success>(body)?;
-                Ok(DeleteFileEditResponse::DeletedEdit(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFileEditResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFileEditResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFileEditResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFileEditResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFileEditResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn delete_fileset(
-        &self,
-        param_editgroup_id: String,
-        param_ident: String,
-        context: &C,
-    ) -> Result<DeleteFilesetResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/fileset/{ident}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("DELETE")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(DeleteFilesetResponse::DeletedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFilesetResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFilesetResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFilesetResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFilesetResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFilesetResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn delete_fileset_edit(
-        &self,
-        param_editgroup_id: String,
-        param_edit_id: String,
-        context: &C,
-    ) -> Result<DeleteFilesetEditResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/fileset/edit/{edit_id}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            edit_id = utf8_percent_encode(&param_edit_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("DELETE")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Success>(body)?;
-                Ok(DeleteFilesetEditResponse::DeletedEdit(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFilesetEditResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFilesetEditResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFilesetEditResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFilesetEditResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteFilesetEditResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn delete_release(
-        &self,
-        param_editgroup_id: String,
-        param_ident: String,
-        context: &C,
-    ) -> Result<DeleteReleaseResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/release/{ident}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("DELETE")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(DeleteReleaseResponse::DeletedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteReleaseResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteReleaseResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteReleaseResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteReleaseResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteReleaseResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn delete_release_edit(
-        &self,
-        param_editgroup_id: String,
-        param_edit_id: String,
-        context: &C,
-    ) -> Result<DeleteReleaseEditResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/release/edit/{edit_id}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            edit_id = utf8_percent_encode(&param_edit_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("DELETE")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Success>(body)?;
-                Ok(DeleteReleaseEditResponse::DeletedEdit(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteReleaseEditResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteReleaseEditResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteReleaseEditResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteReleaseEditResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteReleaseEditResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn delete_webcapture(
-        &self,
-        param_editgroup_id: String,
-        param_ident: String,
-        context: &C,
-    ) -> Result<DeleteWebcaptureResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/webcapture/{ident}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("DELETE")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(DeleteWebcaptureResponse::DeletedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWebcaptureResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWebcaptureResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWebcaptureResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWebcaptureResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWebcaptureResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn delete_webcapture_edit(
-        &self,
-        param_editgroup_id: String,
-        param_edit_id: String,
-        context: &C,
-    ) -> Result<DeleteWebcaptureEditResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/webcapture/edit/{edit_id}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            edit_id = utf8_percent_encode(&param_edit_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("DELETE")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Success>(body)?;
-                Ok(DeleteWebcaptureEditResponse::DeletedEdit(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWebcaptureEditResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWebcaptureEditResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWebcaptureEditResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWebcaptureEditResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWebcaptureEditResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn delete_work(
-        &self,
-        param_editgroup_id: String,
-        param_ident: String,
-        context: &C,
-    ) -> Result<DeleteWorkResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/work/{ident}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("DELETE")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(DeleteWorkResponse::DeletedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWorkResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWorkResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWorkResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWorkResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWorkResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn delete_work_edit(
-        &self,
-        param_editgroup_id: String,
-        param_edit_id: String,
-        context: &C,
-    ) -> Result<DeleteWorkEditResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/work/edit/{edit_id}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            edit_id = utf8_percent_encode(&param_edit_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("DELETE")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Success>(body)?;
-                Ok(DeleteWorkEditResponse::DeletedEdit(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWorkEditResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWorkEditResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWorkEditResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWorkEditResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(DeleteWorkEditResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_changelog(
-        &self,
-        param_limit: Option<i64>,
-        context: &C,
-    ) -> Result<GetChangelogResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!("{}/v0/changelog", self.base_path);
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_limit) = param_limit {
-                query_string.append_pair("limit", &param_limit.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<models::ChangelogEntry>>(body)?;
-                Ok(GetChangelogResponse::Success(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetChangelogResponse::BadRequest(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetChangelogResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_changelog_entry(
-        &self,
-        param_index: i64,
-        context: &C,
-    ) -> Result<GetChangelogEntryResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/changelog/{index}",
-            self.base_path,
-            index = utf8_percent_encode(&param_index.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ChangelogEntry>(body)?;
-                Ok(GetChangelogEntryResponse::FoundChangelogEntry(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetChangelogEntryResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetChangelogEntryResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetChangelogEntryResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_container(
-        &self,
-        param_ident: String,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetContainerResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/container/{ident}",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ContainerEntity>(body)?;
-                Ok(GetContainerResponse::FoundEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetContainerResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetContainerResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetContainerResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_container_edit(
-        &self,
-        param_edit_id: String,
-        context: &C,
-    ) -> Result<GetContainerEditResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/container/edit/{edit_id}",
-            self.base_path,
-            edit_id = utf8_percent_encode(&param_edit_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(GetContainerEditResponse::FoundEdit(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetContainerEditResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetContainerEditResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetContainerEditResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_container_history(
-        &self,
-        param_ident: String,
-        param_limit: Option<i64>,
-        context: &C,
-    ) -> Result<GetContainerHistoryResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/container/{ident}/history",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_limit) = param_limit {
-                query_string.append_pair("limit", &param_limit.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<models::EntityHistoryEntry>>(body)?;
-                Ok(GetContainerHistoryResponse::FoundEntityHistory(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetContainerHistoryResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetContainerHistoryResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetContainerHistoryResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_container_redirects(
-        &self,
-        param_ident: String,
-        context: &C,
-    ) -> Result<GetContainerRedirectsResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/container/{ident}/redirects",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<String>>(body)?;
-                Ok(GetContainerRedirectsResponse::FoundEntityRedirects(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetContainerRedirectsResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetContainerRedirectsResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetContainerRedirectsResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_container_revision(
-        &self,
-        param_rev_id: String,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetContainerRevisionResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/container/rev/{rev_id}",
-            self.base_path,
-            rev_id = utf8_percent_encode(&param_rev_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ContainerEntity>(body)?;
-                Ok(GetContainerRevisionResponse::FoundEntityRevision(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetContainerRevisionResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetContainerRevisionResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetContainerRevisionResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_creator(
-        &self,
-        param_ident: String,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetCreatorResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/creator/{ident}",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::CreatorEntity>(body)?;
-                Ok(GetCreatorResponse::FoundEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_creator_edit(
-        &self,
-        param_edit_id: String,
-        context: &C,
-    ) -> Result<GetCreatorEditResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/creator/edit/{edit_id}",
-            self.base_path,
-            edit_id = utf8_percent_encode(&param_edit_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(GetCreatorEditResponse::FoundEdit(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorEditResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorEditResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorEditResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_creator_history(
-        &self,
-        param_ident: String,
-        param_limit: Option<i64>,
-        context: &C,
-    ) -> Result<GetCreatorHistoryResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/creator/{ident}/history",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_limit) = param_limit {
-                query_string.append_pair("limit", &param_limit.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<models::EntityHistoryEntry>>(body)?;
-                Ok(GetCreatorHistoryResponse::FoundEntityHistory(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorHistoryResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorHistoryResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorHistoryResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_creator_redirects(
-        &self,
-        param_ident: String,
-        context: &C,
-    ) -> Result<GetCreatorRedirectsResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/creator/{ident}/redirects",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<String>>(body)?;
-                Ok(GetCreatorRedirectsResponse::FoundEntityRedirects(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorRedirectsResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorRedirectsResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorRedirectsResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_creator_releases(
-        &self,
-        param_ident: String,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetCreatorReleasesResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/creator/{ident}/releases",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<models::ReleaseEntity>>(body)?;
-                Ok(GetCreatorReleasesResponse::Found(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorReleasesResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorReleasesResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorReleasesResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_creator_revision(
-        &self,
-        param_rev_id: String,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetCreatorRevisionResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/creator/rev/{rev_id}",
-            self.base_path,
-            rev_id = utf8_percent_encode(&param_rev_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::CreatorEntity>(body)?;
-                Ok(GetCreatorRevisionResponse::FoundEntityRevision(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorRevisionResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorRevisionResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetCreatorRevisionResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_editgroup(
-        &self,
-        param_editgroup_id: String,
-        context: &C,
-    ) -> Result<GetEditgroupResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Editgroup>(body)?;
-                Ok(GetEditgroupResponse::Found(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditgroupResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditgroupResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditgroupResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_editgroup_annotations(
-        &self,
-        param_editgroup_id: String,
-        param_expand: Option<String>,
-        context: &C,
-    ) -> Result<GetEditgroupAnnotationsResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/annotations",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<models::EditgroupAnnotation>>(body)?;
-                Ok(GetEditgroupAnnotationsResponse::Success(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditgroupAnnotationsResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditgroupAnnotationsResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditgroupAnnotationsResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditgroupAnnotationsResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditgroupAnnotationsResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_editgroups_reviewable(
-        &self,
-        param_expand: Option<String>,
-        param_limit: Option<i64>,
-        param_before: Option<chrono::DateTime<chrono::Utc>>,
-        param_since: Option<chrono::DateTime<chrono::Utc>>,
-        context: &C,
-    ) -> Result<GetEditgroupsReviewableResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!("{}/v0/editgroup/reviewable", self.base_path);
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_limit) = param_limit {
-                query_string.append_pair("limit", &param_limit.to_string());
-            }
-            if let Some(param_before) = param_before {
-                query_string.append_pair("before", &param_before.to_string());
-            }
-            if let Some(param_since) = param_since {
-                query_string.append_pair("since", &param_since.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<models::Editgroup>>(body)?;
-                Ok(GetEditgroupsReviewableResponse::Found(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditgroupsReviewableResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditgroupsReviewableResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditgroupsReviewableResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_editor(
-        &self,
-        param_editor_id: String,
-        context: &C,
-    ) -> Result<GetEditorResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editor/{editor_id}",
-            self.base_path,
-            editor_id = utf8_percent_encode(&param_editor_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Editor>(body)?;
-                Ok(GetEditorResponse::Found(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditorResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditorResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditorResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_editor_annotations(
-        &self,
-        param_editor_id: String,
-        param_limit: Option<i64>,
-        param_before: Option<chrono::DateTime<chrono::Utc>>,
-        param_since: Option<chrono::DateTime<chrono::Utc>>,
-        context: &C,
-    ) -> Result<GetEditorAnnotationsResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editor/{editor_id}/annotations",
-            self.base_path,
-            editor_id = utf8_percent_encode(&param_editor_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_limit) = param_limit {
-                query_string.append_pair("limit", &param_limit.to_string());
-            }
-            if let Some(param_before) = param_before {
-                query_string.append_pair("before", &param_before.to_string());
-            }
-            if let Some(param_since) = param_since {
-                query_string.append_pair("since", &param_since.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<models::EditgroupAnnotation>>(body)?;
-                Ok(GetEditorAnnotationsResponse::Success(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditorAnnotationsResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditorAnnotationsResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditorAnnotationsResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditorAnnotationsResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditorAnnotationsResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_editor_editgroups(
-        &self,
-        param_editor_id: String,
-        param_limit: Option<i64>,
-        param_before: Option<chrono::DateTime<chrono::Utc>>,
-        param_since: Option<chrono::DateTime<chrono::Utc>>,
-        context: &C,
-    ) -> Result<GetEditorEditgroupsResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editor/{editor_id}/editgroups",
-            self.base_path,
-            editor_id = utf8_percent_encode(&param_editor_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_limit) = param_limit {
-                query_string.append_pair("limit", &param_limit.to_string());
-            }
-            if let Some(param_before) = param_before {
-                query_string.append_pair("before", &param_before.to_string());
-            }
-            if let Some(param_since) = param_since {
-                query_string.append_pair("since", &param_since.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<models::Editgroup>>(body)?;
-                Ok(GetEditorEditgroupsResponse::Found(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditorEditgroupsResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditorEditgroupsResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetEditorEditgroupsResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_file(
-        &self,
-        param_ident: String,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetFileResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/file/{ident}",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::FileEntity>(body)?;
-                Ok(GetFileResponse::FoundEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFileResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFileResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFileResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_file_edit(
-        &self,
-        param_edit_id: String,
-        context: &C,
-    ) -> Result<GetFileEditResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/file/edit/{edit_id}",
-            self.base_path,
-            edit_id = utf8_percent_encode(&param_edit_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(GetFileEditResponse::FoundEdit(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFileEditResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFileEditResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFileEditResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_file_history(
-        &self,
-        param_ident: String,
-        param_limit: Option<i64>,
-        context: &C,
-    ) -> Result<GetFileHistoryResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/file/{ident}/history",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_limit) = param_limit {
-                query_string.append_pair("limit", &param_limit.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<models::EntityHistoryEntry>>(body)?;
-                Ok(GetFileHistoryResponse::FoundEntityHistory(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFileHistoryResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFileHistoryResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFileHistoryResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_file_redirects(
-        &self,
-        param_ident: String,
-        context: &C,
-    ) -> Result<GetFileRedirectsResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/file/{ident}/redirects",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<String>>(body)?;
-                Ok(GetFileRedirectsResponse::FoundEntityRedirects(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFileRedirectsResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFileRedirectsResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFileRedirectsResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_file_revision(
-        &self,
-        param_rev_id: String,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetFileRevisionResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/file/rev/{rev_id}",
-            self.base_path,
-            rev_id = utf8_percent_encode(&param_rev_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::FileEntity>(body)?;
-                Ok(GetFileRevisionResponse::FoundEntityRevision(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFileRevisionResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFileRevisionResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFileRevisionResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_fileset(
-        &self,
-        param_ident: String,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetFilesetResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/fileset/{ident}",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::FilesetEntity>(body)?;
-                Ok(GetFilesetResponse::FoundEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFilesetResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFilesetResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFilesetResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_fileset_edit(
-        &self,
-        param_edit_id: String,
-        context: &C,
-    ) -> Result<GetFilesetEditResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/fileset/edit/{edit_id}",
-            self.base_path,
-            edit_id = utf8_percent_encode(&param_edit_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(GetFilesetEditResponse::FoundEdit(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFilesetEditResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFilesetEditResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFilesetEditResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_fileset_history(
-        &self,
-        param_ident: String,
-        param_limit: Option<i64>,
-        context: &C,
-    ) -> Result<GetFilesetHistoryResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/fileset/{ident}/history",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_limit) = param_limit {
-                query_string.append_pair("limit", &param_limit.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<models::EntityHistoryEntry>>(body)?;
-                Ok(GetFilesetHistoryResponse::FoundEntityHistory(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFilesetHistoryResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFilesetHistoryResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFilesetHistoryResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_fileset_redirects(
-        &self,
-        param_ident: String,
-        context: &C,
-    ) -> Result<GetFilesetRedirectsResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/fileset/{ident}/redirects",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<String>>(body)?;
-                Ok(GetFilesetRedirectsResponse::FoundEntityRedirects(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFilesetRedirectsResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFilesetRedirectsResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFilesetRedirectsResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_fileset_revision(
-        &self,
-        param_rev_id: String,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetFilesetRevisionResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/fileset/rev/{rev_id}",
-            self.base_path,
-            rev_id = utf8_percent_encode(&param_rev_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::FilesetEntity>(body)?;
-                Ok(GetFilesetRevisionResponse::FoundEntityRevision(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFilesetRevisionResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFilesetRevisionResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetFilesetRevisionResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_release(
-        &self,
-        param_ident: String,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetReleaseResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/release/{ident}",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ReleaseEntity>(body)?;
-                Ok(GetReleaseResponse::FoundEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_release_edit(
-        &self,
-        param_edit_id: String,
-        context: &C,
-    ) -> Result<GetReleaseEditResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/release/edit/{edit_id}",
-            self.base_path,
-            edit_id = utf8_percent_encode(&param_edit_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(GetReleaseEditResponse::FoundEdit(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseEditResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseEditResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseEditResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_release_files(
-        &self,
-        param_ident: String,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetReleaseFilesResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/release/{ident}/files",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<models::FileEntity>>(body)?;
-                Ok(GetReleaseFilesResponse::Found(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseFilesResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseFilesResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseFilesResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_release_filesets(
-        &self,
-        param_ident: String,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetReleaseFilesetsResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/release/{ident}/filesets",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<models::FilesetEntity>>(body)?;
-                Ok(GetReleaseFilesetsResponse::Found(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseFilesetsResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseFilesetsResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseFilesetsResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_release_history(
-        &self,
-        param_ident: String,
-        param_limit: Option<i64>,
-        context: &C,
-    ) -> Result<GetReleaseHistoryResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/release/{ident}/history",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_limit) = param_limit {
-                query_string.append_pair("limit", &param_limit.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<models::EntityHistoryEntry>>(body)?;
-                Ok(GetReleaseHistoryResponse::FoundEntityHistory(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseHistoryResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseHistoryResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseHistoryResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_release_redirects(
-        &self,
-        param_ident: String,
-        context: &C,
-    ) -> Result<GetReleaseRedirectsResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/release/{ident}/redirects",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<String>>(body)?;
-                Ok(GetReleaseRedirectsResponse::FoundEntityRedirects(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseRedirectsResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseRedirectsResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseRedirectsResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_release_revision(
-        &self,
-        param_rev_id: String,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetReleaseRevisionResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/release/rev/{rev_id}",
-            self.base_path,
-            rev_id = utf8_percent_encode(&param_rev_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ReleaseEntity>(body)?;
-                Ok(GetReleaseRevisionResponse::FoundEntityRevision(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseRevisionResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseRevisionResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseRevisionResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_release_webcaptures(
-        &self,
-        param_ident: String,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetReleaseWebcapturesResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/release/{ident}/webcaptures",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<models::WebcaptureEntity>>(body)?;
-                Ok(GetReleaseWebcapturesResponse::Found(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseWebcapturesResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseWebcapturesResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetReleaseWebcapturesResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_webcapture(
-        &self,
-        param_ident: String,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetWebcaptureResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/webcapture/{ident}",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::WebcaptureEntity>(body)?;
-                Ok(GetWebcaptureResponse::FoundEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWebcaptureResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWebcaptureResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWebcaptureResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_webcapture_edit(
-        &self,
-        param_edit_id: String,
-        context: &C,
-    ) -> Result<GetWebcaptureEditResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/webcapture/edit/{edit_id}",
-            self.base_path,
-            edit_id = utf8_percent_encode(&param_edit_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(GetWebcaptureEditResponse::FoundEdit(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWebcaptureEditResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWebcaptureEditResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWebcaptureEditResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_webcapture_history(
-        &self,
-        param_ident: String,
-        param_limit: Option<i64>,
-        context: &C,
-    ) -> Result<GetWebcaptureHistoryResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/webcapture/{ident}/history",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_limit) = param_limit {
-                query_string.append_pair("limit", &param_limit.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<models::EntityHistoryEntry>>(body)?;
-                Ok(GetWebcaptureHistoryResponse::FoundEntityHistory(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWebcaptureHistoryResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWebcaptureHistoryResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWebcaptureHistoryResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_webcapture_redirects(
-        &self,
-        param_ident: String,
-        context: &C,
-    ) -> Result<GetWebcaptureRedirectsResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/webcapture/{ident}/redirects",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<String>>(body)?;
-                Ok(GetWebcaptureRedirectsResponse::FoundEntityRedirects(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWebcaptureRedirectsResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWebcaptureRedirectsResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWebcaptureRedirectsResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_webcapture_revision(
-        &self,
-        param_rev_id: String,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetWebcaptureRevisionResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/webcapture/rev/{rev_id}",
-            self.base_path,
-            rev_id = utf8_percent_encode(&param_rev_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::WebcaptureEntity>(body)?;
-                Ok(GetWebcaptureRevisionResponse::FoundEntityRevision(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWebcaptureRevisionResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWebcaptureRevisionResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWebcaptureRevisionResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_work(
-        &self,
-        param_ident: String,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetWorkResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/work/{ident}",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::WorkEntity>(body)?;
-                Ok(GetWorkResponse::FoundEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_work_edit(
-        &self,
-        param_edit_id: String,
-        context: &C,
-    ) -> Result<GetWorkEditResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/work/edit/{edit_id}",
-            self.base_path,
-            edit_id = utf8_percent_encode(&param_edit_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(GetWorkEditResponse::FoundEdit(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkEditResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkEditResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkEditResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_work_history(
-        &self,
-        param_ident: String,
-        param_limit: Option<i64>,
-        context: &C,
-    ) -> Result<GetWorkHistoryResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/work/{ident}/history",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_limit) = param_limit {
-                query_string.append_pair("limit", &param_limit.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<models::EntityHistoryEntry>>(body)?;
-                Ok(GetWorkHistoryResponse::FoundEntityHistory(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkHistoryResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkHistoryResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkHistoryResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_work_redirects(
-        &self,
-        param_ident: String,
-        context: &C,
-    ) -> Result<GetWorkRedirectsResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/work/{ident}/redirects",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<String>>(body)?;
-                Ok(GetWorkRedirectsResponse::FoundEntityRedirects(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkRedirectsResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkRedirectsResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkRedirectsResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_work_releases(
-        &self,
-        param_ident: String,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetWorkReleasesResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/work/{ident}/releases",
-            self.base_path,
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<Vec<models::ReleaseEntity>>(body)?;
-                Ok(GetWorkReleasesResponse::Found(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkReleasesResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkReleasesResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkReleasesResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn get_work_revision(
-        &self,
-        param_rev_id: String,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<GetWorkRevisionResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/work/rev/{rev_id}",
-            self.base_path,
-            rev_id = utf8_percent_encode(&param_rev_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::WorkEntity>(body)?;
-                Ok(GetWorkRevisionResponse::FoundEntityRevision(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkRevisionResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkRevisionResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(GetWorkRevisionResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn lookup_container(
-        &self,
-        param_issnl: Option<String>,
-        param_wikidata_qid: Option<String>,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<LookupContainerResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!("{}/v0/container/lookup", self.base_path);
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_issnl) = param_issnl {
-                query_string.append_pair("issnl", &param_issnl.to_string());
-            }
-            if let Some(param_wikidata_qid) = param_wikidata_qid {
-                query_string.append_pair("wikidata_qid", &param_wikidata_qid.to_string());
-            }
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ContainerEntity>(body)?;
-                Ok(LookupContainerResponse::FoundEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(LookupContainerResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(LookupContainerResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(LookupContainerResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn lookup_creator(
-        &self,
-        param_orcid: Option<String>,
-        param_wikidata_qid: Option<String>,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<LookupCreatorResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!("{}/v0/creator/lookup", self.base_path);
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_orcid) = param_orcid {
-                query_string.append_pair("orcid", &param_orcid.to_string());
-            }
-            if let Some(param_wikidata_qid) = param_wikidata_qid {
-                query_string.append_pair("wikidata_qid", &param_wikidata_qid.to_string());
-            }
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::CreatorEntity>(body)?;
-                Ok(LookupCreatorResponse::FoundEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(LookupCreatorResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(LookupCreatorResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(LookupCreatorResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn lookup_file(
-        &self,
-        param_md5: Option<String>,
-        param_sha1: Option<String>,
-        param_sha256: Option<String>,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<LookupFileResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!("{}/v0/file/lookup", self.base_path);
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_md5) = param_md5 {
-                query_string.append_pair("md5", &param_md5.to_string());
-            }
-            if let Some(param_sha1) = param_sha1 {
-                query_string.append_pair("sha1", &param_sha1.to_string());
-            }
-            if let Some(param_sha256) = param_sha256 {
-                query_string.append_pair("sha256", &param_sha256.to_string());
-            }
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::FileEntity>(body)?;
-                Ok(LookupFileResponse::FoundEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(LookupFileResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(LookupFileResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(LookupFileResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn lookup_release(
-        &self,
-        param_doi: Option<String>,
-        param_wikidata_qid: Option<String>,
-        param_isbn13: Option<String>,
-        param_pmid: Option<String>,
-        param_pmcid: Option<String>,
-        param_core: Option<String>,
-        param_arxiv: Option<String>,
-        param_jstor: Option<String>,
-        param_ark: Option<String>,
-        param_mag: Option<String>,
-        param_doaj: Option<String>,
-        param_dblp: Option<String>,
-        param_oai: Option<String>,
-        param_expand: Option<String>,
-        param_hide: Option<String>,
-        context: &C,
-    ) -> Result<LookupReleaseResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!("{}/v0/release/lookup", self.base_path);
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_doi) = param_doi {
-                query_string.append_pair("doi", &param_doi.to_string());
-            }
-            if let Some(param_wikidata_qid) = param_wikidata_qid {
-                query_string.append_pair("wikidata_qid", &param_wikidata_qid.to_string());
-            }
-            if let Some(param_isbn13) = param_isbn13 {
-                query_string.append_pair("isbn13", &param_isbn13.to_string());
-            }
-            if let Some(param_pmid) = param_pmid {
-                query_string.append_pair("pmid", &param_pmid.to_string());
-            }
-            if let Some(param_pmcid) = param_pmcid {
-                query_string.append_pair("pmcid", &param_pmcid.to_string());
-            }
-            if let Some(param_core) = param_core {
-                query_string.append_pair("core", &param_core.to_string());
-            }
-            if let Some(param_arxiv) = param_arxiv {
-                query_string.append_pair("arxiv", &param_arxiv.to_string());
-            }
-            if let Some(param_jstor) = param_jstor {
-                query_string.append_pair("jstor", &param_jstor.to_string());
-            }
-            if let Some(param_ark) = param_ark {
-                query_string.append_pair("ark", &param_ark.to_string());
-            }
-            if let Some(param_mag) = param_mag {
-                query_string.append_pair("mag", &param_mag.to_string());
-            }
-            if let Some(param_doaj) = param_doaj {
-                query_string.append_pair("doaj", &param_doaj.to_string());
-            }
-            if let Some(param_dblp) = param_dblp {
-                query_string.append_pair("dblp", &param_dblp.to_string());
-            }
-            if let Some(param_oai) = param_oai {
-                query_string.append_pair("oai", &param_oai.to_string());
-            }
-            if let Some(param_expand) = param_expand {
-                query_string.append_pair("expand", &param_expand.to_string());
-            }
-            if let Some(param_hide) = param_hide {
-                query_string.append_pair("hide", &param_hide.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("GET")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ReleaseEntity>(body)?;
-                Ok(LookupReleaseResponse::FoundEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(LookupReleaseResponse::BadRequest(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(LookupReleaseResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(LookupReleaseResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn update_container(
-        &self,
-        param_editgroup_id: String,
-        param_ident: String,
-        param_container_entity: models::ContainerEntity,
-        context: &C,
-    ) -> Result<UpdateContainerResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/container/{ident}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("PUT")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body = serde_json::to_string(&param_container_entity)
-            .expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(UpdateContainerResponse::UpdatedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateContainerResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateContainerResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateContainerResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateContainerResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateContainerResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn update_creator(
-        &self,
-        param_editgroup_id: String,
-        param_ident: String,
-        param_creator_entity: models::CreatorEntity,
-        context: &C,
-    ) -> Result<UpdateCreatorResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/creator/{ident}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("PUT")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body =
-            serde_json::to_string(&param_creator_entity).expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(UpdateCreatorResponse::UpdatedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateCreatorResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateCreatorResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateCreatorResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateCreatorResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateCreatorResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn update_editgroup(
-        &self,
-        param_editgroup_id: String,
-        param_editgroup: models::Editgroup,
-        param_submit: Option<bool>,
-        context: &C,
-    ) -> Result<UpdateEditgroupResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            if let Some(param_submit) = param_submit {
-                query_string.append_pair("submit", &param_submit.to_string());
-            }
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("PUT")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body =
-            serde_json::to_string(&param_editgroup).expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Editgroup>(body)?;
-                Ok(UpdateEditgroupResponse::UpdatedEditgroup(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateEditgroupResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateEditgroupResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateEditgroupResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateEditgroupResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateEditgroupResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn update_editor(
-        &self,
-        param_editor_id: String,
-        param_editor: models::Editor,
-        context: &C,
-    ) -> Result<UpdateEditorResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editor/{editor_id}",
-            self.base_path,
-            editor_id = utf8_percent_encode(&param_editor_id.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("PUT")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body = serde_json::to_string(&param_editor).expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::Editor>(body)?;
-                Ok(UpdateEditorResponse::UpdatedEditor(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateEditorResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateEditorResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateEditorResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateEditorResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateEditorResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn update_file(
-        &self,
-        param_editgroup_id: String,
-        param_ident: String,
-        param_file_entity: models::FileEntity,
-        context: &C,
-    ) -> Result<UpdateFileResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/file/{ident}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("PUT")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body =
-            serde_json::to_string(&param_file_entity).expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(UpdateFileResponse::UpdatedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateFileResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateFileResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateFileResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateFileResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateFileResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn update_fileset(
-        &self,
-        param_editgroup_id: String,
-        param_ident: String,
-        param_fileset_entity: models::FilesetEntity,
-        context: &C,
-    ) -> Result<UpdateFilesetResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/fileset/{ident}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("PUT")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body =
-            serde_json::to_string(&param_fileset_entity).expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(UpdateFilesetResponse::UpdatedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateFilesetResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateFilesetResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateFilesetResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateFilesetResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateFilesetResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn update_release(
-        &self,
-        param_editgroup_id: String,
-        param_ident: String,
-        param_release_entity: models::ReleaseEntity,
-        context: &C,
-    ) -> Result<UpdateReleaseResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/release/{ident}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("PUT")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body =
-            serde_json::to_string(&param_release_entity).expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(UpdateReleaseResponse::UpdatedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateReleaseResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateReleaseResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateReleaseResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateReleaseResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateReleaseResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn update_webcapture(
-        &self,
-        param_editgroup_id: String,
-        param_ident: String,
-        param_webcapture_entity: models::WebcaptureEntity,
-        context: &C,
-    ) -> Result<UpdateWebcaptureResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/webcapture/{ident}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("PUT")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body = serde_json::to_string(&param_webcapture_entity)
-            .expect("impossible to fail to serialize");
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(UpdateWebcaptureResponse::UpdatedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateWebcaptureResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateWebcaptureResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateWebcaptureResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateWebcaptureResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateWebcaptureResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-
-    async fn update_work(
-        &self,
-        param_editgroup_id: String,
-        param_ident: String,
-        param_work_entity: models::WorkEntity,
-        context: &C,
-    ) -> Result<UpdateWorkResponse, ApiError> {
-        let mut client_service = self.client_service.clone();
-        let mut uri = format!(
-            "{}/v0/editgroup/{editgroup_id}/work/{ident}",
-            self.base_path,
-            editgroup_id = utf8_percent_encode(&param_editgroup_id.to_string(), ID_ENCODE_SET),
-            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
-        );
-
-        // Query parameters
-        let query_string = {
-            let mut query_string = form_urlencoded::Serializer::new("".to_owned());
-            query_string.finish()
-        };
-        if !query_string.is_empty() {
-            uri += "?";
-            uri += &query_string;
-        }
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
-        };
-
-        let mut request = match Request::builder()
-            .method("PUT")
-            .uri(uri)
-            .body(Body::empty())
-        {
-            Ok(req) => req,
-            Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))),
-        };
-
-        let body =
-            serde_json::to_string(&param_work_entity).expect("impossible to fail to serialize");
-
-        *request.body_mut() = Body::from(body);
-
-        let header = "application/json";
-        request.headers_mut().insert(
-            CONTENT_TYPE,
-            match HeaderValue::from_str(header) {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create header: {} - {}",
-                        header, e
-                    )))
-                }
-            },
-        );
-
-        let header = HeaderValue::from_str(
-            Has::<XSpanIdString>::get(context)
-                .0
-                .clone()
-                .to_string()
-                .as_str(),
-        );
-        request.headers_mut().insert(
-            HeaderName::from_static("x-span-id"),
-            match header {
-                Ok(h) => h,
-                Err(e) => {
-                    return Err(ApiError(format!(
-                        "Unable to create X-Span ID header value: {}",
-                        e
-                    )))
-                }
-            },
-        );
-
-        if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
-            // Currently only authentication with Basic and Bearer are supported
-            match auth_data {
-                &AuthData::Bearer(ref bearer_header) => {
-                    let auth = swagger::auth::Header(bearer_header.clone());
-                    let header = match HeaderValue::from_str(&format!("{}", auth)) {
-                        Ok(h) => h,
-                        Err(e) => {
-                            return Err(ApiError(format!(
-                                "Unable to create Authorization header: {}",
-                                e
-                            )))
-                        }
-                    };
-                    request
-                        .headers_mut()
-                        .insert(hyper::header::AUTHORIZATION, header);
-                }
-                _ => {}
-            }
-        }
-
-        let mut response = client_service
-            .call((request, context.clone()))
-            .map_err(|e| ApiError(format!("No response received: {}", e)))
-            .await?;
-
-        match response.status().as_u16() {
-            200 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::EntityEdit>(body)?;
-                Ok(UpdateWorkResponse::UpdatedEntity(body))
-            }
-            400 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateWorkResponse::BadRequest(body))
-            }
-            401 => {
-                let response_www_authenticate = match response
-                    .headers()
-                    .get(HeaderName::from_static("www_authenticate"))
-                {
-                    Some(response_www_authenticate) => {
-                        let response_www_authenticate = response_www_authenticate.clone();
-                        let response_www_authenticate = match TryInto::<
-                            header::IntoHeaderValue<String>,
-                        >::try_into(
-                            response_www_authenticate
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)));
-                            }
-                        };
-                        let response_www_authenticate = response_www_authenticate.0;
-                        Some(response_www_authenticate)
-                    }
-                    None => None,
-                };
-
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateWorkResponse::NotAuthorized {
-                    body: body,
-                    www_authenticate: response_www_authenticate,
-                })
-            }
-            403 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateWorkResponse::Forbidden(body))
-            }
-            404 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateWorkResponse::NotFound(body))
-            }
-            500 => {
-                let body = response.into_body();
-                let body = body
-                    .to_raw()
-                    .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                    .await?;
-                let body = str::from_utf8(&body)
-                    .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                let body = serde_json::from_str::<models::ErrorResponse>(body)?;
-                Ok(UpdateWorkResponse::GenericError(body))
-            }
-            code => {
-                let headers = response.headers().clone();
-                let body = response.into_body().take(100).to_raw().await;
-                Err(ApiError(format!(
-                    "Unexpected response code {}:\n{:?}\n\n{}",
-                    code,
-                    headers,
-                    match body {
-                        Ok(body) => match String::from_utf8(body) {
-                            Ok(body) => body,
-                            Err(e) => format!("<Body was not UTF8: {:?}>", e),
-                        },
-                        Err(e) => format!("<Failed to read body: {}>", e),
-                    }
-                )))
-            }
-        }
-    }
-}
diff --git a/rust/fatcat-openapi/src/context.rs b/rust/fatcat-openapi/src/context.rs
deleted file mode 100644
index d782855..0000000
--- a/rust/fatcat-openapi/src/context.rs
+++ /dev/null
@@ -1,120 +0,0 @@
-use crate::Api;
-use futures::future::BoxFuture;
-use hyper::header::HeaderName;
-use hyper::{service::Service, Error, Request, Response, StatusCode};
-use std::default::Default;
-use std::io;
-use std::marker::PhantomData;
-use std::task::{Context, Poll};
-use swagger::auth::{AuthData, Authorization, Bearer, Scopes};
-use swagger::{EmptyContext, Has, Pop, Push, XSpanIdString};
-use url::form_urlencoded;
-
-pub struct MakeAddContext<T, A> {
-    inner: T,
-    marker: PhantomData<A>,
-}
-
-impl<T, A, B, C, D> MakeAddContext<T, A>
-where
-    A: Default + Push<XSpanIdString, Result = B>,
-    B: Push<Option<AuthData>, Result = C>,
-    C: Push<Option<Authorization>, Result = D>,
-{
-    pub fn new(inner: T) -> MakeAddContext<T, A> {
-        MakeAddContext {
-            inner,
-            marker: PhantomData,
-        }
-    }
-}
-
-// Make a service that adds context.
-impl<Target, T, A, B, C, D> Service<Target> for MakeAddContext<T, A>
-where
-    Target: Send,
-    A: Default + Push<XSpanIdString, Result = B> + Send,
-    B: Push<Option<AuthData>, Result = C>,
-    C: Push<Option<Authorization>, Result = D>,
-    D: Send + 'static,
-    T: Service<Target> + Send,
-    T::Future: Send + 'static,
-{
-    type Error = T::Error;
-    type Response = AddContext<T::Response, A, B, C, D>;
-    type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
-
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.inner.poll_ready(cx)
-    }
-
-    fn call(&mut self, target: Target) -> Self::Future {
-        let service = self.inner.call(target);
-
-        Box::pin(async move { Ok(AddContext::new(service.await?)) })
-    }
-}
-
-/// Middleware to add context data from the request
-pub struct AddContext<T, A, B, C, D>
-where
-    A: Default + Push<XSpanIdString, Result = B>,
-    B: Push<Option<AuthData>, Result = C>,
-    C: Push<Option<Authorization>, Result = D>,
-{
-    inner: T,
-    marker: PhantomData<A>,
-}
-
-impl<T, A, B, C, D> AddContext<T, A, B, C, D>
-where
-    A: Default + Push<XSpanIdString, Result = B>,
-    B: Push<Option<AuthData>, Result = C>,
-    C: Push<Option<Authorization>, Result = D>,
-{
-    pub fn new(inner: T) -> Self {
-        AddContext {
-            inner,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<T, A, B, C, D, ReqBody> Service<Request<ReqBody>> for AddContext<T, A, B, C, D>
-where
-    A: Default + Push<XSpanIdString, Result = B>,
-    B: Push<Option<AuthData>, Result = C>,
-    C: Push<Option<Authorization>, Result = D>,
-    D: Send + 'static,
-    T: Service<(Request<ReqBody>, D)>,
-{
-    type Error = T::Error;
-    type Future = T::Future;
-    type Response = T::Response;
-
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.inner.poll_ready(cx)
-    }
-
-    fn call(&mut self, request: Request<ReqBody>) -> Self::Future {
-        let context = A::default().push(XSpanIdString::get_or_generate(&request));
-        let headers = request.headers();
-
-        {
-            use std::ops::Deref;
-            use swagger::auth::Basic;
-            if let Some(basic) = swagger::auth::from_headers::<Basic>(&headers) {
-                let auth_data = AuthData::Basic(basic);
-                let context = context.push(Some(auth_data));
-                let context = context.push(None::<Authorization>);
-
-                return self.inner.call((request, context));
-            }
-        }
-
-        let context = context.push(None::<AuthData>);
-        let context = context.push(None::<Authorization>);
-
-        self.inner.call((request, context))
-    }
-}
diff --git a/rust/fatcat-openapi/src/header.rs b/rust/fatcat-openapi/src/header.rs
deleted file mode 100644
index 7589ab0..0000000
--- a/rust/fatcat-openapi/src/header.rs
+++ /dev/null
@@ -1,197 +0,0 @@
-use chrono::{DateTime, Utc};
-use hyper::header::HeaderValue;
-use std::convert::TryFrom;
-use std::fmt;
-use std::ops::Deref;
-
-/// A struct to allow homogeneous conversion into a HeaderValue. We can't
-/// implement the From/Into trait on HeaderValue because we don't own
-/// either of the types.
-#[derive(Debug, Clone)]
-pub(crate) struct IntoHeaderValue<T>(pub T);
-
-// Generic implementations
-
-impl<T> Deref for IntoHeaderValue<T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        &self.0
-    }
-}
-
-// Derive for each TryFrom<T> in hyper::header::HeaderValue
-
-macro_rules! ihv_generate {
-    ($t:ident) => {
-        impl TryFrom<HeaderValue> for IntoHeaderValue<$t> {
-            type Error = String;
-
-            fn try_from(hdr_value: HeaderValue) -> Result<Self, Self::Error> {
-                match hdr_value.to_str() {
-                    Ok(hdr_value) => match hdr_value.parse::<$t>() {
-                        Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value)),
-                        Err(e) => Err(format!(
-                            "Unable to parse {} as a string: {}",
-                            stringify!($t),
-                            e
-                        )),
-                    },
-                    Err(e) => Err(format!(
-                        "Unable to parse header {:?} as a string - {}",
-                        hdr_value, e
-                    )),
-                }
-            }
-        }
-
-        impl TryFrom<IntoHeaderValue<$t>> for HeaderValue {
-            type Error = String;
-
-            fn try_from(hdr_value: IntoHeaderValue<$t>) -> Result<Self, Self::Error> {
-                Ok(hdr_value.0.into())
-            }
-        }
-    };
-}
-
-ihv_generate!(u64);
-ihv_generate!(i64);
-ihv_generate!(i16);
-ihv_generate!(u16);
-ihv_generate!(u32);
-ihv_generate!(usize);
-ihv_generate!(isize);
-ihv_generate!(i32);
-
-// Custom derivations
-
-// Vec<String>
-
-impl TryFrom<HeaderValue> for IntoHeaderValue<Vec<String>> {
-    type Error = String;
-
-    fn try_from(hdr_value: HeaderValue) -> Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            Ok(hdr_value) => Ok(IntoHeaderValue(
-                hdr_value
-                    .split(',')
-                    .filter_map(|x| match x.trim() {
-                        "" => None,
-                        y => Some(y.to_string()),
-                    })
-                    .collect(),
-            )),
-            Err(e) => Err(format!(
-                "Unable to parse header: {:?} as a string - {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-impl TryFrom<IntoHeaderValue<Vec<String>>> for HeaderValue {
-    type Error = String;
-
-    fn try_from(hdr_value: IntoHeaderValue<Vec<String>>) -> Result<Self, Self::Error> {
-        match HeaderValue::from_str(&hdr_value.0.join(", ")) {
-            Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!(
-                "Unable to convert {:?} into a header - {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-// String
-
-impl TryFrom<HeaderValue> for IntoHeaderValue<String> {
-    type Error = String;
-
-    fn try_from(hdr_value: HeaderValue) -> Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value.to_string())),
-            Err(e) => Err(format!("Unable to convert header {:?} to {}", hdr_value, e)),
-        }
-    }
-}
-
-impl TryFrom<IntoHeaderValue<String>> for HeaderValue {
-    type Error = String;
-
-    fn try_from(hdr_value: IntoHeaderValue<String>) -> Result<Self, Self::Error> {
-        match HeaderValue::from_str(&hdr_value.0) {
-            Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!(
-                "Unable to convert {:?} from a header {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-// bool
-impl TryFrom<HeaderValue> for IntoHeaderValue<bool> {
-    type Error = String;
-
-    fn try_from(hdr_value: HeaderValue) -> Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            Ok(hdr_value) => match hdr_value.parse() {
-                Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value)),
-                Err(e) => Err(format!("Unable to parse bool from {} - {}", hdr_value, e)),
-            },
-            Err(e) => Err(format!(
-                "Unable to convert {:?} from a header {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-impl TryFrom<IntoHeaderValue<bool>> for HeaderValue {
-    type Error = String;
-
-    fn try_from(hdr_value: IntoHeaderValue<bool>) -> Result<Self, Self::Error> {
-        match HeaderValue::from_str(&hdr_value.0.to_string()) {
-            Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!(
-                "Unable to convert: {:?} into a header: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-// DateTime
-
-impl TryFrom<HeaderValue> for IntoHeaderValue<DateTime<Utc>> {
-    type Error = String;
-
-    fn try_from(hdr_value: HeaderValue) -> Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            Ok(hdr_value) => match DateTime::parse_from_rfc3339(hdr_value) {
-                Ok(date) => Ok(IntoHeaderValue(date.with_timezone(&Utc))),
-                Err(e) => Err(format!("Unable to parse: {} as date - {}", hdr_value, e)),
-            },
-            Err(e) => Err(format!(
-                "Unable to convert header {:?} to string {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-impl TryFrom<IntoHeaderValue<DateTime<Utc>>> for HeaderValue {
-    type Error = String;
-
-    fn try_from(hdr_value: IntoHeaderValue<DateTime<Utc>>) -> Result<Self, Self::Error> {
-        match HeaderValue::from_str(hdr_value.0.to_rfc3339().as_str()) {
-            Ok(hdr_value) => Ok(hdr_value),
-            Err(e) => Err(format!(
-                "Unable to convert {:?} to a header: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
diff --git a/rust/fatcat-openapi/src/lib.rs b/rust/fatcat-openapi/src/lib.rs
deleted file mode 100644
index ba49f27..0000000
--- a/rust/fatcat-openapi/src/lib.rs
+++ /dev/null
@@ -1,3844 +0,0 @@
-#![allow(
-    missing_docs,
-    trivial_casts,
-    unused_variables,
-    unused_mut,
-    unused_imports,
-    unused_extern_crates,
-    non_camel_case_types
-)]
-
-use async_trait::async_trait;
-use futures::Stream;
-use std::error::Error;
-use std::task::{Context, Poll};
-use swagger::{ApiError, ContextWrapper};
-
-type ServiceError = Box<dyn Error + Send + Sync + 'static>;
-
-pub const BASE_PATH: &'static str = "/v0";
-pub const API_VERSION: &'static str = "0.3.3";
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum AcceptEditgroupResponse {
-    /// Merged Successfully
-    MergedSuccessfully(models::Success),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Edit Conflict
-    EditConflict(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum AuthCheckResponse {
-    /// Success
-    Success(models::Success),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum AuthOidcResponse {
-    /// Found
-    Found(models::AuthOidcResult),
-    /// Created
-    Created(models::AuthOidcResult),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Conflict
-    Conflict(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum CreateAuthTokenResponse {
-    /// Success
-    Success(models::AuthTokenResult),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum CreateContainerResponse {
-    /// Created Entity
-    CreatedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum CreateContainerAutoBatchResponse {
-    /// Created Editgroup
-    CreatedEditgroup(models::Editgroup),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum CreateCreatorResponse {
-    /// Created Entity
-    CreatedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum CreateCreatorAutoBatchResponse {
-    /// Created Editgroup
-    CreatedEditgroup(models::Editgroup),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum CreateEditgroupResponse {
-    /// Successfully Created
-    SuccessfullyCreated(models::Editgroup),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum CreateEditgroupAnnotationResponse {
-    /// Created
-    Created(models::EditgroupAnnotation),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum CreateFileResponse {
-    /// Created Entity
-    CreatedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum CreateFileAutoBatchResponse {
-    /// Created Editgroup
-    CreatedEditgroup(models::Editgroup),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum CreateFilesetResponse {
-    /// Created Entity
-    CreatedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum CreateFilesetAutoBatchResponse {
-    /// Created Editgroup
-    CreatedEditgroup(models::Editgroup),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum CreateReleaseResponse {
-    /// Created Entity
-    CreatedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum CreateReleaseAutoBatchResponse {
-    /// Created Editgroup
-    CreatedEditgroup(models::Editgroup),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum CreateWebcaptureResponse {
-    /// Created Entity
-    CreatedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum CreateWebcaptureAutoBatchResponse {
-    /// Created Editgroup
-    CreatedEditgroup(models::Editgroup),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum CreateWorkResponse {
-    /// Created Entity
-    CreatedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum CreateWorkAutoBatchResponse {
-    /// Created Editgroup
-    CreatedEditgroup(models::Editgroup),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum DeleteContainerResponse {
-    /// Deleted Entity
-    DeletedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum DeleteContainerEditResponse {
-    /// Deleted Edit
-    DeletedEdit(models::Success),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum DeleteCreatorResponse {
-    /// Deleted Entity
-    DeletedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum DeleteCreatorEditResponse {
-    /// Deleted Edit
-    DeletedEdit(models::Success),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum DeleteFileResponse {
-    /// Deleted Entity
-    DeletedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum DeleteFileEditResponse {
-    /// Deleted Edit
-    DeletedEdit(models::Success),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum DeleteFilesetResponse {
-    /// Deleted Entity
-    DeletedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum DeleteFilesetEditResponse {
-    /// Deleted Edit
-    DeletedEdit(models::Success),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum DeleteReleaseResponse {
-    /// Deleted Entity
-    DeletedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum DeleteReleaseEditResponse {
-    /// Deleted Edit
-    DeletedEdit(models::Success),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum DeleteWebcaptureResponse {
-    /// Deleted Entity
-    DeletedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum DeleteWebcaptureEditResponse {
-    /// Deleted Edit
-    DeletedEdit(models::Success),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum DeleteWorkResponse {
-    /// Deleted Entity
-    DeletedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum DeleteWorkEditResponse {
-    /// Deleted Edit
-    DeletedEdit(models::Success),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetChangelogResponse {
-    /// Success
-    Success(Vec<models::ChangelogEntry>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetChangelogEntryResponse {
-    /// Found Changelog Entry
-    FoundChangelogEntry(models::ChangelogEntry),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetContainerResponse {
-    /// Found Entity
-    FoundEntity(models::ContainerEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetContainerEditResponse {
-    /// Found Edit
-    FoundEdit(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetContainerHistoryResponse {
-    /// Found Entity History
-    FoundEntityHistory(Vec<models::EntityHistoryEntry>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetContainerRedirectsResponse {
-    /// Found Entity Redirects
-    FoundEntityRedirects(Vec<String>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetContainerRevisionResponse {
-    /// Found Entity Revision
-    FoundEntityRevision(models::ContainerEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetCreatorResponse {
-    /// Found Entity
-    FoundEntity(models::CreatorEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetCreatorEditResponse {
-    /// Found Edit
-    FoundEdit(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetCreatorHistoryResponse {
-    /// Found Entity History
-    FoundEntityHistory(Vec<models::EntityHistoryEntry>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetCreatorRedirectsResponse {
-    /// Found Entity Redirects
-    FoundEntityRedirects(Vec<String>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetCreatorReleasesResponse {
-    /// Found
-    Found(Vec<models::ReleaseEntity>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetCreatorRevisionResponse {
-    /// Found Entity Revision
-    FoundEntityRevision(models::CreatorEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetEditgroupResponse {
-    /// Found
-    Found(models::Editgroup),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetEditgroupAnnotationsResponse {
-    /// Success
-    Success(Vec<models::EditgroupAnnotation>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetEditgroupsReviewableResponse {
-    /// Found
-    Found(Vec<models::Editgroup>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetEditorResponse {
-    /// Found
-    Found(models::Editor),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetEditorAnnotationsResponse {
-    /// Success
-    Success(Vec<models::EditgroupAnnotation>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetEditorEditgroupsResponse {
-    /// Found
-    Found(Vec<models::Editgroup>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetFileResponse {
-    /// Found Entity
-    FoundEntity(models::FileEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetFileEditResponse {
-    /// Found Edit
-    FoundEdit(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetFileHistoryResponse {
-    /// Found Entity History
-    FoundEntityHistory(Vec<models::EntityHistoryEntry>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetFileRedirectsResponse {
-    /// Found Entity Redirects
-    FoundEntityRedirects(Vec<String>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetFileRevisionResponse {
-    /// Found Entity Revision
-    FoundEntityRevision(models::FileEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetFilesetResponse {
-    /// Found Entity
-    FoundEntity(models::FilesetEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetFilesetEditResponse {
-    /// Found Edit
-    FoundEdit(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetFilesetHistoryResponse {
-    /// Found Entity History
-    FoundEntityHistory(Vec<models::EntityHistoryEntry>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetFilesetRedirectsResponse {
-    /// Found Entity Redirects
-    FoundEntityRedirects(Vec<String>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetFilesetRevisionResponse {
-    /// Found Entity Revision
-    FoundEntityRevision(models::FilesetEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetReleaseResponse {
-    /// Found Entity
-    FoundEntity(models::ReleaseEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetReleaseEditResponse {
-    /// Found Edit
-    FoundEdit(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetReleaseFilesResponse {
-    /// Found
-    Found(Vec<models::FileEntity>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetReleaseFilesetsResponse {
-    /// Found
-    Found(Vec<models::FilesetEntity>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetReleaseHistoryResponse {
-    /// Found Entity History
-    FoundEntityHistory(Vec<models::EntityHistoryEntry>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetReleaseRedirectsResponse {
-    /// Found Entity Redirects
-    FoundEntityRedirects(Vec<String>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetReleaseRevisionResponse {
-    /// Found Entity Revision
-    FoundEntityRevision(models::ReleaseEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetReleaseWebcapturesResponse {
-    /// Found
-    Found(Vec<models::WebcaptureEntity>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetWebcaptureResponse {
-    /// Found Entity
-    FoundEntity(models::WebcaptureEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetWebcaptureEditResponse {
-    /// Found Edit
-    FoundEdit(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetWebcaptureHistoryResponse {
-    /// Found Entity History
-    FoundEntityHistory(Vec<models::EntityHistoryEntry>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetWebcaptureRedirectsResponse {
-    /// Found Entity Redirects
-    FoundEntityRedirects(Vec<String>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetWebcaptureRevisionResponse {
-    /// Found Entity Revision
-    FoundEntityRevision(models::WebcaptureEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetWorkResponse {
-    /// Found Entity
-    FoundEntity(models::WorkEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetWorkEditResponse {
-    /// Found Edit
-    FoundEdit(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetWorkHistoryResponse {
-    /// Found Entity History
-    FoundEntityHistory(Vec<models::EntityHistoryEntry>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetWorkRedirectsResponse {
-    /// Found Entity Redirects
-    FoundEntityRedirects(Vec<String>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetWorkReleasesResponse {
-    /// Found
-    Found(Vec<models::ReleaseEntity>),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum GetWorkRevisionResponse {
-    /// Found Entity Revision
-    FoundEntityRevision(models::WorkEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum LookupContainerResponse {
-    /// Found Entity
-    FoundEntity(models::ContainerEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum LookupCreatorResponse {
-    /// Found Entity
-    FoundEntity(models::CreatorEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum LookupFileResponse {
-    /// Found Entity
-    FoundEntity(models::FileEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum LookupReleaseResponse {
-    /// Found Entity
-    FoundEntity(models::ReleaseEntity),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum UpdateContainerResponse {
-    /// Updated Entity
-    UpdatedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum UpdateCreatorResponse {
-    /// Updated Entity
-    UpdatedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum UpdateEditgroupResponse {
-    /// Updated Editgroup
-    UpdatedEditgroup(models::Editgroup),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum UpdateEditorResponse {
-    /// Updated Editor
-    UpdatedEditor(models::Editor),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum UpdateFileResponse {
-    /// Updated Entity
-    UpdatedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum UpdateFilesetResponse {
-    /// Updated Entity
-    UpdatedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum UpdateReleaseResponse {
-    /// Updated Entity
-    UpdatedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum UpdateWebcaptureResponse {
-    /// Updated Entity
-    UpdatedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-#[derive(Debug, PartialEq)]
-#[must_use]
-pub enum UpdateWorkResponse {
-    /// Updated Entity
-    UpdatedEntity(models::EntityEdit),
-    /// Bad Request
-    BadRequest(models::ErrorResponse),
-    /// Not Authorized
-    NotAuthorized {
-        body: models::ErrorResponse,
-        www_authenticate: Option<String>,
-    },
-    /// Forbidden
-    Forbidden(models::ErrorResponse),
-    /// Not Found
-    NotFound(models::ErrorResponse),
-    /// Generic Error
-    GenericError(models::ErrorResponse),
-}
-
-/// API
-#[async_trait]
-pub trait Api<C: Send + Sync> {
-    fn poll_ready(
-        &self,
-        _cx: &mut Context,
-    ) -> Poll<Result<(), Box<dyn Error + Send + Sync + 'static>>> {
-        Poll::Ready(Ok(()))
-    }
-
-    async fn accept_editgroup(
-        &self,
-        editgroup_id: String,
-        context: &C,
-    ) -> Result<AcceptEditgroupResponse, ApiError>;
-
-    async fn auth_check(
-        &self,
-        role: Option<String>,
-        context: &C,
-    ) -> Result<AuthCheckResponse, ApiError>;
-
-    async fn auth_oidc(
-        &self,
-        auth_oidc: models::AuthOidc,
-        context: &C,
-    ) -> Result<AuthOidcResponse, ApiError>;
-
-    async fn create_auth_token(
-        &self,
-        editor_id: String,
-        duration_seconds: Option<i32>,
-        context: &C,
-    ) -> Result<CreateAuthTokenResponse, ApiError>;
-
-    async fn create_container(
-        &self,
-        editgroup_id: String,
-        container_entity: models::ContainerEntity,
-        context: &C,
-    ) -> Result<CreateContainerResponse, ApiError>;
-
-    async fn create_container_auto_batch(
-        &self,
-        container_auto_batch: models::ContainerAutoBatch,
-        context: &C,
-    ) -> Result<CreateContainerAutoBatchResponse, ApiError>;
-
-    async fn create_creator(
-        &self,
-        editgroup_id: String,
-        creator_entity: models::CreatorEntity,
-        context: &C,
-    ) -> Result<CreateCreatorResponse, ApiError>;
-
-    async fn create_creator_auto_batch(
-        &self,
-        creator_auto_batch: models::CreatorAutoBatch,
-        context: &C,
-    ) -> Result<CreateCreatorAutoBatchResponse, ApiError>;
-
-    async fn create_editgroup(
-        &self,
-        editgroup: models::Editgroup,
-        context: &C,
-    ) -> Result<CreateEditgroupResponse, ApiError>;
-
-    async fn create_editgroup_annotation(
-        &self,
-        editgroup_id: String,
-        editgroup_annotation: models::EditgroupAnnotation,
-        context: &C,
-    ) -> Result<CreateEditgroupAnnotationResponse, ApiError>;
-
-    async fn create_file(
-        &self,
-        editgroup_id: String,
-        file_entity: models::FileEntity,
-        context: &C,
-    ) -> Result<CreateFileResponse, ApiError>;
-
-    async fn create_file_auto_batch(
-        &self,
-        file_auto_batch: models::FileAutoBatch,
-        context: &C,
-    ) -> Result<CreateFileAutoBatchResponse, ApiError>;
-
-    async fn create_fileset(
-        &self,
-        editgroup_id: String,
-        fileset_entity: models::FilesetEntity,
-        context: &C,
-    ) -> Result<CreateFilesetResponse, ApiError>;
-
-    async fn create_fileset_auto_batch(
-        &self,
-        fileset_auto_batch: models::FilesetAutoBatch,
-        context: &C,
-    ) -> Result<CreateFilesetAutoBatchResponse, ApiError>;
-
-    async fn create_release(
-        &self,
-        editgroup_id: String,
-        release_entity: models::ReleaseEntity,
-        context: &C,
-    ) -> Result<CreateReleaseResponse, ApiError>;
-
-    async fn create_release_auto_batch(
-        &self,
-        release_auto_batch: models::ReleaseAutoBatch,
-        context: &C,
-    ) -> Result<CreateReleaseAutoBatchResponse, ApiError>;
-
-    async fn create_webcapture(
-        &self,
-        editgroup_id: String,
-        webcapture_entity: models::WebcaptureEntity,
-        context: &C,
-    ) -> Result<CreateWebcaptureResponse, ApiError>;
-
-    async fn create_webcapture_auto_batch(
-        &self,
-        webcapture_auto_batch: models::WebcaptureAutoBatch,
-        context: &C,
-    ) -> Result<CreateWebcaptureAutoBatchResponse, ApiError>;
-
-    async fn create_work(
-        &self,
-        editgroup_id: String,
-        work_entity: models::WorkEntity,
-        context: &C,
-    ) -> Result<CreateWorkResponse, ApiError>;
-
-    async fn create_work_auto_batch(
-        &self,
-        work_auto_batch: models::WorkAutoBatch,
-        context: &C,
-    ) -> Result<CreateWorkAutoBatchResponse, ApiError>;
-
-    async fn delete_container(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        context: &C,
-    ) -> Result<DeleteContainerResponse, ApiError>;
-
-    async fn delete_container_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-        context: &C,
-    ) -> Result<DeleteContainerEditResponse, ApiError>;
-
-    async fn delete_creator(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        context: &C,
-    ) -> Result<DeleteCreatorResponse, ApiError>;
-
-    async fn delete_creator_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-        context: &C,
-    ) -> Result<DeleteCreatorEditResponse, ApiError>;
-
-    async fn delete_file(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        context: &C,
-    ) -> Result<DeleteFileResponse, ApiError>;
-
-    async fn delete_file_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-        context: &C,
-    ) -> Result<DeleteFileEditResponse, ApiError>;
-
-    async fn delete_fileset(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        context: &C,
-    ) -> Result<DeleteFilesetResponse, ApiError>;
-
-    async fn delete_fileset_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-        context: &C,
-    ) -> Result<DeleteFilesetEditResponse, ApiError>;
-
-    async fn delete_release(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        context: &C,
-    ) -> Result<DeleteReleaseResponse, ApiError>;
-
-    async fn delete_release_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-        context: &C,
-    ) -> Result<DeleteReleaseEditResponse, ApiError>;
-
-    async fn delete_webcapture(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        context: &C,
-    ) -> Result<DeleteWebcaptureResponse, ApiError>;
-
-    async fn delete_webcapture_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-        context: &C,
-    ) -> Result<DeleteWebcaptureEditResponse, ApiError>;
-
-    async fn delete_work(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        context: &C,
-    ) -> Result<DeleteWorkResponse, ApiError>;
-
-    async fn delete_work_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-        context: &C,
-    ) -> Result<DeleteWorkEditResponse, ApiError>;
-
-    async fn get_changelog(
-        &self,
-        limit: Option<i64>,
-        context: &C,
-    ) -> Result<GetChangelogResponse, ApiError>;
-
-    async fn get_changelog_entry(
-        &self,
-        index: i64,
-        context: &C,
-    ) -> Result<GetChangelogEntryResponse, ApiError>;
-
-    async fn get_container(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetContainerResponse, ApiError>;
-
-    async fn get_container_edit(
-        &self,
-        edit_id: String,
-        context: &C,
-    ) -> Result<GetContainerEditResponse, ApiError>;
-
-    async fn get_container_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-        context: &C,
-    ) -> Result<GetContainerHistoryResponse, ApiError>;
-
-    async fn get_container_redirects(
-        &self,
-        ident: String,
-        context: &C,
-    ) -> Result<GetContainerRedirectsResponse, ApiError>;
-
-    async fn get_container_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetContainerRevisionResponse, ApiError>;
-
-    async fn get_creator(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetCreatorResponse, ApiError>;
-
-    async fn get_creator_edit(
-        &self,
-        edit_id: String,
-        context: &C,
-    ) -> Result<GetCreatorEditResponse, ApiError>;
-
-    async fn get_creator_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-        context: &C,
-    ) -> Result<GetCreatorHistoryResponse, ApiError>;
-
-    async fn get_creator_redirects(
-        &self,
-        ident: String,
-        context: &C,
-    ) -> Result<GetCreatorRedirectsResponse, ApiError>;
-
-    async fn get_creator_releases(
-        &self,
-        ident: String,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetCreatorReleasesResponse, ApiError>;
-
-    async fn get_creator_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetCreatorRevisionResponse, ApiError>;
-
-    async fn get_editgroup(
-        &self,
-        editgroup_id: String,
-        context: &C,
-    ) -> Result<GetEditgroupResponse, ApiError>;
-
-    async fn get_editgroup_annotations(
-        &self,
-        editgroup_id: String,
-        expand: Option<String>,
-        context: &C,
-    ) -> Result<GetEditgroupAnnotationsResponse, ApiError>;
-
-    async fn get_editgroups_reviewable(
-        &self,
-        expand: Option<String>,
-        limit: Option<i64>,
-        before: Option<chrono::DateTime<chrono::Utc>>,
-        since: Option<chrono::DateTime<chrono::Utc>>,
-        context: &C,
-    ) -> Result<GetEditgroupsReviewableResponse, ApiError>;
-
-    async fn get_editor(
-        &self,
-        editor_id: String,
-        context: &C,
-    ) -> Result<GetEditorResponse, ApiError>;
-
-    async fn get_editor_annotations(
-        &self,
-        editor_id: String,
-        limit: Option<i64>,
-        before: Option<chrono::DateTime<chrono::Utc>>,
-        since: Option<chrono::DateTime<chrono::Utc>>,
-        context: &C,
-    ) -> Result<GetEditorAnnotationsResponse, ApiError>;
-
-    async fn get_editor_editgroups(
-        &self,
-        editor_id: String,
-        limit: Option<i64>,
-        before: Option<chrono::DateTime<chrono::Utc>>,
-        since: Option<chrono::DateTime<chrono::Utc>>,
-        context: &C,
-    ) -> Result<GetEditorEditgroupsResponse, ApiError>;
-
-    async fn get_file(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetFileResponse, ApiError>;
-
-    async fn get_file_edit(
-        &self,
-        edit_id: String,
-        context: &C,
-    ) -> Result<GetFileEditResponse, ApiError>;
-
-    async fn get_file_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-        context: &C,
-    ) -> Result<GetFileHistoryResponse, ApiError>;
-
-    async fn get_file_redirects(
-        &self,
-        ident: String,
-        context: &C,
-    ) -> Result<GetFileRedirectsResponse, ApiError>;
-
-    async fn get_file_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetFileRevisionResponse, ApiError>;
-
-    async fn get_fileset(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetFilesetResponse, ApiError>;
-
-    async fn get_fileset_edit(
-        &self,
-        edit_id: String,
-        context: &C,
-    ) -> Result<GetFilesetEditResponse, ApiError>;
-
-    async fn get_fileset_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-        context: &C,
-    ) -> Result<GetFilesetHistoryResponse, ApiError>;
-
-    async fn get_fileset_redirects(
-        &self,
-        ident: String,
-        context: &C,
-    ) -> Result<GetFilesetRedirectsResponse, ApiError>;
-
-    async fn get_fileset_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetFilesetRevisionResponse, ApiError>;
-
-    async fn get_release(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetReleaseResponse, ApiError>;
-
-    async fn get_release_edit(
-        &self,
-        edit_id: String,
-        context: &C,
-    ) -> Result<GetReleaseEditResponse, ApiError>;
-
-    async fn get_release_files(
-        &self,
-        ident: String,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetReleaseFilesResponse, ApiError>;
-
-    async fn get_release_filesets(
-        &self,
-        ident: String,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetReleaseFilesetsResponse, ApiError>;
-
-    async fn get_release_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-        context: &C,
-    ) -> Result<GetReleaseHistoryResponse, ApiError>;
-
-    async fn get_release_redirects(
-        &self,
-        ident: String,
-        context: &C,
-    ) -> Result<GetReleaseRedirectsResponse, ApiError>;
-
-    async fn get_release_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetReleaseRevisionResponse, ApiError>;
-
-    async fn get_release_webcaptures(
-        &self,
-        ident: String,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetReleaseWebcapturesResponse, ApiError>;
-
-    async fn get_webcapture(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetWebcaptureResponse, ApiError>;
-
-    async fn get_webcapture_edit(
-        &self,
-        edit_id: String,
-        context: &C,
-    ) -> Result<GetWebcaptureEditResponse, ApiError>;
-
-    async fn get_webcapture_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-        context: &C,
-    ) -> Result<GetWebcaptureHistoryResponse, ApiError>;
-
-    async fn get_webcapture_redirects(
-        &self,
-        ident: String,
-        context: &C,
-    ) -> Result<GetWebcaptureRedirectsResponse, ApiError>;
-
-    async fn get_webcapture_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetWebcaptureRevisionResponse, ApiError>;
-
-    async fn get_work(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetWorkResponse, ApiError>;
-
-    async fn get_work_edit(
-        &self,
-        edit_id: String,
-        context: &C,
-    ) -> Result<GetWorkEditResponse, ApiError>;
-
-    async fn get_work_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-        context: &C,
-    ) -> Result<GetWorkHistoryResponse, ApiError>;
-
-    async fn get_work_redirects(
-        &self,
-        ident: String,
-        context: &C,
-    ) -> Result<GetWorkRedirectsResponse, ApiError>;
-
-    async fn get_work_releases(
-        &self,
-        ident: String,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetWorkReleasesResponse, ApiError>;
-
-    async fn get_work_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<GetWorkRevisionResponse, ApiError>;
-
-    async fn lookup_container(
-        &self,
-        issnl: Option<String>,
-        wikidata_qid: Option<String>,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<LookupContainerResponse, ApiError>;
-
-    async fn lookup_creator(
-        &self,
-        orcid: Option<String>,
-        wikidata_qid: Option<String>,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<LookupCreatorResponse, ApiError>;
-
-    async fn lookup_file(
-        &self,
-        md5: Option<String>,
-        sha1: Option<String>,
-        sha256: Option<String>,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<LookupFileResponse, ApiError>;
-
-    async fn lookup_release(
-        &self,
-        doi: Option<String>,
-        wikidata_qid: Option<String>,
-        isbn13: Option<String>,
-        pmid: Option<String>,
-        pmcid: Option<String>,
-        core: Option<String>,
-        arxiv: Option<String>,
-        jstor: Option<String>,
-        ark: Option<String>,
-        mag: Option<String>,
-        doaj: Option<String>,
-        dblp: Option<String>,
-        oai: Option<String>,
-        expand: Option<String>,
-        hide: Option<String>,
-        context: &C,
-    ) -> Result<LookupReleaseResponse, ApiError>;
-
-    async fn update_container(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        container_entity: models::ContainerEntity,
-        context: &C,
-    ) -> Result<UpdateContainerResponse, ApiError>;
-
-    async fn update_creator(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        creator_entity: models::CreatorEntity,
-        context: &C,
-    ) -> Result<UpdateCreatorResponse, ApiError>;
-
-    async fn update_editgroup(
-        &self,
-        editgroup_id: String,
-        editgroup: models::Editgroup,
-        submit: Option<bool>,
-        context: &C,
-    ) -> Result<UpdateEditgroupResponse, ApiError>;
-
-    async fn update_editor(
-        &self,
-        editor_id: String,
-        editor: models::Editor,
-        context: &C,
-    ) -> Result<UpdateEditorResponse, ApiError>;
-
-    async fn update_file(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        file_entity: models::FileEntity,
-        context: &C,
-    ) -> Result<UpdateFileResponse, ApiError>;
-
-    async fn update_fileset(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        fileset_entity: models::FilesetEntity,
-        context: &C,
-    ) -> Result<UpdateFilesetResponse, ApiError>;
-
-    async fn update_release(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        release_entity: models::ReleaseEntity,
-        context: &C,
-    ) -> Result<UpdateReleaseResponse, ApiError>;
-
-    async fn update_webcapture(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        webcapture_entity: models::WebcaptureEntity,
-        context: &C,
-    ) -> Result<UpdateWebcaptureResponse, ApiError>;
-
-    async fn update_work(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        work_entity: models::WorkEntity,
-        context: &C,
-    ) -> Result<UpdateWorkResponse, ApiError>;
-}
-
-/// API where `Context` isn't passed on every API call
-#[async_trait]
-pub trait ApiNoContext<C: Send + Sync> {
-    fn poll_ready(
-        &self,
-        _cx: &mut Context,
-    ) -> Poll<Result<(), Box<dyn Error + Send + Sync + 'static>>>;
-
-    fn context(&self) -> &C;
-
-    async fn accept_editgroup(
-        &self,
-        editgroup_id: String,
-    ) -> Result<AcceptEditgroupResponse, ApiError>;
-
-    async fn auth_check(&self, role: Option<String>) -> Result<AuthCheckResponse, ApiError>;
-
-    async fn auth_oidc(&self, auth_oidc: models::AuthOidc) -> Result<AuthOidcResponse, ApiError>;
-
-    async fn create_auth_token(
-        &self,
-        editor_id: String,
-        duration_seconds: Option<i32>,
-    ) -> Result<CreateAuthTokenResponse, ApiError>;
-
-    async fn create_container(
-        &self,
-        editgroup_id: String,
-        container_entity: models::ContainerEntity,
-    ) -> Result<CreateContainerResponse, ApiError>;
-
-    async fn create_container_auto_batch(
-        &self,
-        container_auto_batch: models::ContainerAutoBatch,
-    ) -> Result<CreateContainerAutoBatchResponse, ApiError>;
-
-    async fn create_creator(
-        &self,
-        editgroup_id: String,
-        creator_entity: models::CreatorEntity,
-    ) -> Result<CreateCreatorResponse, ApiError>;
-
-    async fn create_creator_auto_batch(
-        &self,
-        creator_auto_batch: models::CreatorAutoBatch,
-    ) -> Result<CreateCreatorAutoBatchResponse, ApiError>;
-
-    async fn create_editgroup(
-        &self,
-        editgroup: models::Editgroup,
-    ) -> Result<CreateEditgroupResponse, ApiError>;
-
-    async fn create_editgroup_annotation(
-        &self,
-        editgroup_id: String,
-        editgroup_annotation: models::EditgroupAnnotation,
-    ) -> Result<CreateEditgroupAnnotationResponse, ApiError>;
-
-    async fn create_file(
-        &self,
-        editgroup_id: String,
-        file_entity: models::FileEntity,
-    ) -> Result<CreateFileResponse, ApiError>;
-
-    async fn create_file_auto_batch(
-        &self,
-        file_auto_batch: models::FileAutoBatch,
-    ) -> Result<CreateFileAutoBatchResponse, ApiError>;
-
-    async fn create_fileset(
-        &self,
-        editgroup_id: String,
-        fileset_entity: models::FilesetEntity,
-    ) -> Result<CreateFilesetResponse, ApiError>;
-
-    async fn create_fileset_auto_batch(
-        &self,
-        fileset_auto_batch: models::FilesetAutoBatch,
-    ) -> Result<CreateFilesetAutoBatchResponse, ApiError>;
-
-    async fn create_release(
-        &self,
-        editgroup_id: String,
-        release_entity: models::ReleaseEntity,
-    ) -> Result<CreateReleaseResponse, ApiError>;
-
-    async fn create_release_auto_batch(
-        &self,
-        release_auto_batch: models::ReleaseAutoBatch,
-    ) -> Result<CreateReleaseAutoBatchResponse, ApiError>;
-
-    async fn create_webcapture(
-        &self,
-        editgroup_id: String,
-        webcapture_entity: models::WebcaptureEntity,
-    ) -> Result<CreateWebcaptureResponse, ApiError>;
-
-    async fn create_webcapture_auto_batch(
-        &self,
-        webcapture_auto_batch: models::WebcaptureAutoBatch,
-    ) -> Result<CreateWebcaptureAutoBatchResponse, ApiError>;
-
-    async fn create_work(
-        &self,
-        editgroup_id: String,
-        work_entity: models::WorkEntity,
-    ) -> Result<CreateWorkResponse, ApiError>;
-
-    async fn create_work_auto_batch(
-        &self,
-        work_auto_batch: models::WorkAutoBatch,
-    ) -> Result<CreateWorkAutoBatchResponse, ApiError>;
-
-    async fn delete_container(
-        &self,
-        editgroup_id: String,
-        ident: String,
-    ) -> Result<DeleteContainerResponse, ApiError>;
-
-    async fn delete_container_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-    ) -> Result<DeleteContainerEditResponse, ApiError>;
-
-    async fn delete_creator(
-        &self,
-        editgroup_id: String,
-        ident: String,
-    ) -> Result<DeleteCreatorResponse, ApiError>;
-
-    async fn delete_creator_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-    ) -> Result<DeleteCreatorEditResponse, ApiError>;
-
-    async fn delete_file(
-        &self,
-        editgroup_id: String,
-        ident: String,
-    ) -> Result<DeleteFileResponse, ApiError>;
-
-    async fn delete_file_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-    ) -> Result<DeleteFileEditResponse, ApiError>;
-
-    async fn delete_fileset(
-        &self,
-        editgroup_id: String,
-        ident: String,
-    ) -> Result<DeleteFilesetResponse, ApiError>;
-
-    async fn delete_fileset_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-    ) -> Result<DeleteFilesetEditResponse, ApiError>;
-
-    async fn delete_release(
-        &self,
-        editgroup_id: String,
-        ident: String,
-    ) -> Result<DeleteReleaseResponse, ApiError>;
-
-    async fn delete_release_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-    ) -> Result<DeleteReleaseEditResponse, ApiError>;
-
-    async fn delete_webcapture(
-        &self,
-        editgroup_id: String,
-        ident: String,
-    ) -> Result<DeleteWebcaptureResponse, ApiError>;
-
-    async fn delete_webcapture_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-    ) -> Result<DeleteWebcaptureEditResponse, ApiError>;
-
-    async fn delete_work(
-        &self,
-        editgroup_id: String,
-        ident: String,
-    ) -> Result<DeleteWorkResponse, ApiError>;
-
-    async fn delete_work_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-    ) -> Result<DeleteWorkEditResponse, ApiError>;
-
-    async fn get_changelog(&self, limit: Option<i64>) -> Result<GetChangelogResponse, ApiError>;
-
-    async fn get_changelog_entry(&self, index: i64) -> Result<GetChangelogEntryResponse, ApiError>;
-
-    async fn get_container(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetContainerResponse, ApiError>;
-
-    async fn get_container_edit(
-        &self,
-        edit_id: String,
-    ) -> Result<GetContainerEditResponse, ApiError>;
-
-    async fn get_container_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-    ) -> Result<GetContainerHistoryResponse, ApiError>;
-
-    async fn get_container_redirects(
-        &self,
-        ident: String,
-    ) -> Result<GetContainerRedirectsResponse, ApiError>;
-
-    async fn get_container_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetContainerRevisionResponse, ApiError>;
-
-    async fn get_creator(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetCreatorResponse, ApiError>;
-
-    async fn get_creator_edit(&self, edit_id: String) -> Result<GetCreatorEditResponse, ApiError>;
-
-    async fn get_creator_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-    ) -> Result<GetCreatorHistoryResponse, ApiError>;
-
-    async fn get_creator_redirects(
-        &self,
-        ident: String,
-    ) -> Result<GetCreatorRedirectsResponse, ApiError>;
-
-    async fn get_creator_releases(
-        &self,
-        ident: String,
-        hide: Option<String>,
-    ) -> Result<GetCreatorReleasesResponse, ApiError>;
-
-    async fn get_creator_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetCreatorRevisionResponse, ApiError>;
-
-    async fn get_editgroup(&self, editgroup_id: String) -> Result<GetEditgroupResponse, ApiError>;
-
-    async fn get_editgroup_annotations(
-        &self,
-        editgroup_id: String,
-        expand: Option<String>,
-    ) -> Result<GetEditgroupAnnotationsResponse, ApiError>;
-
-    async fn get_editgroups_reviewable(
-        &self,
-        expand: Option<String>,
-        limit: Option<i64>,
-        before: Option<chrono::DateTime<chrono::Utc>>,
-        since: Option<chrono::DateTime<chrono::Utc>>,
-    ) -> Result<GetEditgroupsReviewableResponse, ApiError>;
-
-    async fn get_editor(&self, editor_id: String) -> Result<GetEditorResponse, ApiError>;
-
-    async fn get_editor_annotations(
-        &self,
-        editor_id: String,
-        limit: Option<i64>,
-        before: Option<chrono::DateTime<chrono::Utc>>,
-        since: Option<chrono::DateTime<chrono::Utc>>,
-    ) -> Result<GetEditorAnnotationsResponse, ApiError>;
-
-    async fn get_editor_editgroups(
-        &self,
-        editor_id: String,
-        limit: Option<i64>,
-        before: Option<chrono::DateTime<chrono::Utc>>,
-        since: Option<chrono::DateTime<chrono::Utc>>,
-    ) -> Result<GetEditorEditgroupsResponse, ApiError>;
-
-    async fn get_file(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetFileResponse, ApiError>;
-
-    async fn get_file_edit(&self, edit_id: String) -> Result<GetFileEditResponse, ApiError>;
-
-    async fn get_file_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-    ) -> Result<GetFileHistoryResponse, ApiError>;
-
-    async fn get_file_redirects(&self, ident: String)
-        -> Result<GetFileRedirectsResponse, ApiError>;
-
-    async fn get_file_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetFileRevisionResponse, ApiError>;
-
-    async fn get_fileset(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetFilesetResponse, ApiError>;
-
-    async fn get_fileset_edit(&self, edit_id: String) -> Result<GetFilesetEditResponse, ApiError>;
-
-    async fn get_fileset_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-    ) -> Result<GetFilesetHistoryResponse, ApiError>;
-
-    async fn get_fileset_redirects(
-        &self,
-        ident: String,
-    ) -> Result<GetFilesetRedirectsResponse, ApiError>;
-
-    async fn get_fileset_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetFilesetRevisionResponse, ApiError>;
-
-    async fn get_release(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetReleaseResponse, ApiError>;
-
-    async fn get_release_edit(&self, edit_id: String) -> Result<GetReleaseEditResponse, ApiError>;
-
-    async fn get_release_files(
-        &self,
-        ident: String,
-        hide: Option<String>,
-    ) -> Result<GetReleaseFilesResponse, ApiError>;
-
-    async fn get_release_filesets(
-        &self,
-        ident: String,
-        hide: Option<String>,
-    ) -> Result<GetReleaseFilesetsResponse, ApiError>;
-
-    async fn get_release_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-    ) -> Result<GetReleaseHistoryResponse, ApiError>;
-
-    async fn get_release_redirects(
-        &self,
-        ident: String,
-    ) -> Result<GetReleaseRedirectsResponse, ApiError>;
-
-    async fn get_release_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetReleaseRevisionResponse, ApiError>;
-
-    async fn get_release_webcaptures(
-        &self,
-        ident: String,
-        hide: Option<String>,
-    ) -> Result<GetReleaseWebcapturesResponse, ApiError>;
-
-    async fn get_webcapture(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetWebcaptureResponse, ApiError>;
-
-    async fn get_webcapture_edit(
-        &self,
-        edit_id: String,
-    ) -> Result<GetWebcaptureEditResponse, ApiError>;
-
-    async fn get_webcapture_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-    ) -> Result<GetWebcaptureHistoryResponse, ApiError>;
-
-    async fn get_webcapture_redirects(
-        &self,
-        ident: String,
-    ) -> Result<GetWebcaptureRedirectsResponse, ApiError>;
-
-    async fn get_webcapture_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetWebcaptureRevisionResponse, ApiError>;
-
-    async fn get_work(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetWorkResponse, ApiError>;
-
-    async fn get_work_edit(&self, edit_id: String) -> Result<GetWorkEditResponse, ApiError>;
-
-    async fn get_work_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-    ) -> Result<GetWorkHistoryResponse, ApiError>;
-
-    async fn get_work_redirects(&self, ident: String)
-        -> Result<GetWorkRedirectsResponse, ApiError>;
-
-    async fn get_work_releases(
-        &self,
-        ident: String,
-        hide: Option<String>,
-    ) -> Result<GetWorkReleasesResponse, ApiError>;
-
-    async fn get_work_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetWorkRevisionResponse, ApiError>;
-
-    async fn lookup_container(
-        &self,
-        issnl: Option<String>,
-        wikidata_qid: Option<String>,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<LookupContainerResponse, ApiError>;
-
-    async fn lookup_creator(
-        &self,
-        orcid: Option<String>,
-        wikidata_qid: Option<String>,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<LookupCreatorResponse, ApiError>;
-
-    async fn lookup_file(
-        &self,
-        md5: Option<String>,
-        sha1: Option<String>,
-        sha256: Option<String>,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<LookupFileResponse, ApiError>;
-
-    async fn lookup_release(
-        &self,
-        doi: Option<String>,
-        wikidata_qid: Option<String>,
-        isbn13: Option<String>,
-        pmid: Option<String>,
-        pmcid: Option<String>,
-        core: Option<String>,
-        arxiv: Option<String>,
-        jstor: Option<String>,
-        ark: Option<String>,
-        mag: Option<String>,
-        doaj: Option<String>,
-        dblp: Option<String>,
-        oai: Option<String>,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<LookupReleaseResponse, ApiError>;
-
-    async fn update_container(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        container_entity: models::ContainerEntity,
-    ) -> Result<UpdateContainerResponse, ApiError>;
-
-    async fn update_creator(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        creator_entity: models::CreatorEntity,
-    ) -> Result<UpdateCreatorResponse, ApiError>;
-
-    async fn update_editgroup(
-        &self,
-        editgroup_id: String,
-        editgroup: models::Editgroup,
-        submit: Option<bool>,
-    ) -> Result<UpdateEditgroupResponse, ApiError>;
-
-    async fn update_editor(
-        &self,
-        editor_id: String,
-        editor: models::Editor,
-    ) -> Result<UpdateEditorResponse, ApiError>;
-
-    async fn update_file(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        file_entity: models::FileEntity,
-    ) -> Result<UpdateFileResponse, ApiError>;
-
-    async fn update_fileset(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        fileset_entity: models::FilesetEntity,
-    ) -> Result<UpdateFilesetResponse, ApiError>;
-
-    async fn update_release(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        release_entity: models::ReleaseEntity,
-    ) -> Result<UpdateReleaseResponse, ApiError>;
-
-    async fn update_webcapture(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        webcapture_entity: models::WebcaptureEntity,
-    ) -> Result<UpdateWebcaptureResponse, ApiError>;
-
-    async fn update_work(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        work_entity: models::WorkEntity,
-    ) -> Result<UpdateWorkResponse, ApiError>;
-}
-
-/// Trait to extend an API to make it easy to bind it to a context.
-pub trait ContextWrapperExt<C: Send + Sync>
-where
-    Self: Sized,
-{
-    /// Binds this API to a context.
-    fn with_context(self: Self, context: C) -> ContextWrapper<Self, C>;
-}
-
-impl<T: Api<C> + Send + Sync, C: Clone + Send + Sync> ContextWrapperExt<C> for T {
-    fn with_context(self: T, context: C) -> ContextWrapper<T, C> {
-        ContextWrapper::<T, C>::new(self, context)
-    }
-}
-
-#[async_trait]
-impl<T: Api<C> + Send + Sync, C: Clone + Send + Sync> ApiNoContext<C> for ContextWrapper<T, C> {
-    fn poll_ready(&self, cx: &mut Context) -> Poll<Result<(), ServiceError>> {
-        self.api().poll_ready(cx)
-    }
-
-    fn context(&self) -> &C {
-        ContextWrapper::context(self)
-    }
-
-    async fn accept_editgroup(
-        &self,
-        editgroup_id: String,
-    ) -> Result<AcceptEditgroupResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().accept_editgroup(editgroup_id, &context).await
-    }
-
-    async fn auth_check(&self, role: Option<String>) -> Result<AuthCheckResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().auth_check(role, &context).await
-    }
-
-    async fn auth_oidc(&self, auth_oidc: models::AuthOidc) -> Result<AuthOidcResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().auth_oidc(auth_oidc, &context).await
-    }
-
-    async fn create_auth_token(
-        &self,
-        editor_id: String,
-        duration_seconds: Option<i32>,
-    ) -> Result<CreateAuthTokenResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .create_auth_token(editor_id, duration_seconds, &context)
-            .await
-    }
-
-    async fn create_container(
-        &self,
-        editgroup_id: String,
-        container_entity: models::ContainerEntity,
-    ) -> Result<CreateContainerResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .create_container(editgroup_id, container_entity, &context)
-            .await
-    }
-
-    async fn create_container_auto_batch(
-        &self,
-        container_auto_batch: models::ContainerAutoBatch,
-    ) -> Result<CreateContainerAutoBatchResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .create_container_auto_batch(container_auto_batch, &context)
-            .await
-    }
-
-    async fn create_creator(
-        &self,
-        editgroup_id: String,
-        creator_entity: models::CreatorEntity,
-    ) -> Result<CreateCreatorResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .create_creator(editgroup_id, creator_entity, &context)
-            .await
-    }
-
-    async fn create_creator_auto_batch(
-        &self,
-        creator_auto_batch: models::CreatorAutoBatch,
-    ) -> Result<CreateCreatorAutoBatchResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .create_creator_auto_batch(creator_auto_batch, &context)
-            .await
-    }
-
-    async fn create_editgroup(
-        &self,
-        editgroup: models::Editgroup,
-    ) -> Result<CreateEditgroupResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().create_editgroup(editgroup, &context).await
-    }
-
-    async fn create_editgroup_annotation(
-        &self,
-        editgroup_id: String,
-        editgroup_annotation: models::EditgroupAnnotation,
-    ) -> Result<CreateEditgroupAnnotationResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .create_editgroup_annotation(editgroup_id, editgroup_annotation, &context)
-            .await
-    }
-
-    async fn create_file(
-        &self,
-        editgroup_id: String,
-        file_entity: models::FileEntity,
-    ) -> Result<CreateFileResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .create_file(editgroup_id, file_entity, &context)
-            .await
-    }
-
-    async fn create_file_auto_batch(
-        &self,
-        file_auto_batch: models::FileAutoBatch,
-    ) -> Result<CreateFileAutoBatchResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .create_file_auto_batch(file_auto_batch, &context)
-            .await
-    }
-
-    async fn create_fileset(
-        &self,
-        editgroup_id: String,
-        fileset_entity: models::FilesetEntity,
-    ) -> Result<CreateFilesetResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .create_fileset(editgroup_id, fileset_entity, &context)
-            .await
-    }
-
-    async fn create_fileset_auto_batch(
-        &self,
-        fileset_auto_batch: models::FilesetAutoBatch,
-    ) -> Result<CreateFilesetAutoBatchResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .create_fileset_auto_batch(fileset_auto_batch, &context)
-            .await
-    }
-
-    async fn create_release(
-        &self,
-        editgroup_id: String,
-        release_entity: models::ReleaseEntity,
-    ) -> Result<CreateReleaseResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .create_release(editgroup_id, release_entity, &context)
-            .await
-    }
-
-    async fn create_release_auto_batch(
-        &self,
-        release_auto_batch: models::ReleaseAutoBatch,
-    ) -> Result<CreateReleaseAutoBatchResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .create_release_auto_batch(release_auto_batch, &context)
-            .await
-    }
-
-    async fn create_webcapture(
-        &self,
-        editgroup_id: String,
-        webcapture_entity: models::WebcaptureEntity,
-    ) -> Result<CreateWebcaptureResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .create_webcapture(editgroup_id, webcapture_entity, &context)
-            .await
-    }
-
-    async fn create_webcapture_auto_batch(
-        &self,
-        webcapture_auto_batch: models::WebcaptureAutoBatch,
-    ) -> Result<CreateWebcaptureAutoBatchResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .create_webcapture_auto_batch(webcapture_auto_batch, &context)
-            .await
-    }
-
-    async fn create_work(
-        &self,
-        editgroup_id: String,
-        work_entity: models::WorkEntity,
-    ) -> Result<CreateWorkResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .create_work(editgroup_id, work_entity, &context)
-            .await
-    }
-
-    async fn create_work_auto_batch(
-        &self,
-        work_auto_batch: models::WorkAutoBatch,
-    ) -> Result<CreateWorkAutoBatchResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .create_work_auto_batch(work_auto_batch, &context)
-            .await
-    }
-
-    async fn delete_container(
-        &self,
-        editgroup_id: String,
-        ident: String,
-    ) -> Result<DeleteContainerResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .delete_container(editgroup_id, ident, &context)
-            .await
-    }
-
-    async fn delete_container_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-    ) -> Result<DeleteContainerEditResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .delete_container_edit(editgroup_id, edit_id, &context)
-            .await
-    }
-
-    async fn delete_creator(
-        &self,
-        editgroup_id: String,
-        ident: String,
-    ) -> Result<DeleteCreatorResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .delete_creator(editgroup_id, ident, &context)
-            .await
-    }
-
-    async fn delete_creator_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-    ) -> Result<DeleteCreatorEditResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .delete_creator_edit(editgroup_id, edit_id, &context)
-            .await
-    }
-
-    async fn delete_file(
-        &self,
-        editgroup_id: String,
-        ident: String,
-    ) -> Result<DeleteFileResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().delete_file(editgroup_id, ident, &context).await
-    }
-
-    async fn delete_file_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-    ) -> Result<DeleteFileEditResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .delete_file_edit(editgroup_id, edit_id, &context)
-            .await
-    }
-
-    async fn delete_fileset(
-        &self,
-        editgroup_id: String,
-        ident: String,
-    ) -> Result<DeleteFilesetResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .delete_fileset(editgroup_id, ident, &context)
-            .await
-    }
-
-    async fn delete_fileset_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-    ) -> Result<DeleteFilesetEditResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .delete_fileset_edit(editgroup_id, edit_id, &context)
-            .await
-    }
-
-    async fn delete_release(
-        &self,
-        editgroup_id: String,
-        ident: String,
-    ) -> Result<DeleteReleaseResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .delete_release(editgroup_id, ident, &context)
-            .await
-    }
-
-    async fn delete_release_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-    ) -> Result<DeleteReleaseEditResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .delete_release_edit(editgroup_id, edit_id, &context)
-            .await
-    }
-
-    async fn delete_webcapture(
-        &self,
-        editgroup_id: String,
-        ident: String,
-    ) -> Result<DeleteWebcaptureResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .delete_webcapture(editgroup_id, ident, &context)
-            .await
-    }
-
-    async fn delete_webcapture_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-    ) -> Result<DeleteWebcaptureEditResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .delete_webcapture_edit(editgroup_id, edit_id, &context)
-            .await
-    }
-
-    async fn delete_work(
-        &self,
-        editgroup_id: String,
-        ident: String,
-    ) -> Result<DeleteWorkResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().delete_work(editgroup_id, ident, &context).await
-    }
-
-    async fn delete_work_edit(
-        &self,
-        editgroup_id: String,
-        edit_id: String,
-    ) -> Result<DeleteWorkEditResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .delete_work_edit(editgroup_id, edit_id, &context)
-            .await
-    }
-
-    async fn get_changelog(&self, limit: Option<i64>) -> Result<GetChangelogResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_changelog(limit, &context).await
-    }
-
-    async fn get_changelog_entry(&self, index: i64) -> Result<GetChangelogEntryResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_changelog_entry(index, &context).await
-    }
-
-    async fn get_container(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetContainerResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .get_container(ident, expand, hide, &context)
-            .await
-    }
-
-    async fn get_container_edit(
-        &self,
-        edit_id: String,
-    ) -> Result<GetContainerEditResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_container_edit(edit_id, &context).await
-    }
-
-    async fn get_container_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-    ) -> Result<GetContainerHistoryResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .get_container_history(ident, limit, &context)
-            .await
-    }
-
-    async fn get_container_redirects(
-        &self,
-        ident: String,
-    ) -> Result<GetContainerRedirectsResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_container_redirects(ident, &context).await
-    }
-
-    async fn get_container_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetContainerRevisionResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .get_container_revision(rev_id, expand, hide, &context)
-            .await
-    }
-
-    async fn get_creator(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetCreatorResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_creator(ident, expand, hide, &context).await
-    }
-
-    async fn get_creator_edit(&self, edit_id: String) -> Result<GetCreatorEditResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_creator_edit(edit_id, &context).await
-    }
-
-    async fn get_creator_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-    ) -> Result<GetCreatorHistoryResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_creator_history(ident, limit, &context).await
-    }
-
-    async fn get_creator_redirects(
-        &self,
-        ident: String,
-    ) -> Result<GetCreatorRedirectsResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_creator_redirects(ident, &context).await
-    }
-
-    async fn get_creator_releases(
-        &self,
-        ident: String,
-        hide: Option<String>,
-    ) -> Result<GetCreatorReleasesResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_creator_releases(ident, hide, &context).await
-    }
-
-    async fn get_creator_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetCreatorRevisionResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .get_creator_revision(rev_id, expand, hide, &context)
-            .await
-    }
-
-    async fn get_editgroup(&self, editgroup_id: String) -> Result<GetEditgroupResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_editgroup(editgroup_id, &context).await
-    }
-
-    async fn get_editgroup_annotations(
-        &self,
-        editgroup_id: String,
-        expand: Option<String>,
-    ) -> Result<GetEditgroupAnnotationsResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .get_editgroup_annotations(editgroup_id, expand, &context)
-            .await
-    }
-
-    async fn get_editgroups_reviewable(
-        &self,
-        expand: Option<String>,
-        limit: Option<i64>,
-        before: Option<chrono::DateTime<chrono::Utc>>,
-        since: Option<chrono::DateTime<chrono::Utc>>,
-    ) -> Result<GetEditgroupsReviewableResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .get_editgroups_reviewable(expand, limit, before, since, &context)
-            .await
-    }
-
-    async fn get_editor(&self, editor_id: String) -> Result<GetEditorResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_editor(editor_id, &context).await
-    }
-
-    async fn get_editor_annotations(
-        &self,
-        editor_id: String,
-        limit: Option<i64>,
-        before: Option<chrono::DateTime<chrono::Utc>>,
-        since: Option<chrono::DateTime<chrono::Utc>>,
-    ) -> Result<GetEditorAnnotationsResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .get_editor_annotations(editor_id, limit, before, since, &context)
-            .await
-    }
-
-    async fn get_editor_editgroups(
-        &self,
-        editor_id: String,
-        limit: Option<i64>,
-        before: Option<chrono::DateTime<chrono::Utc>>,
-        since: Option<chrono::DateTime<chrono::Utc>>,
-    ) -> Result<GetEditorEditgroupsResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .get_editor_editgroups(editor_id, limit, before, since, &context)
-            .await
-    }
-
-    async fn get_file(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetFileResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_file(ident, expand, hide, &context).await
-    }
-
-    async fn get_file_edit(&self, edit_id: String) -> Result<GetFileEditResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_file_edit(edit_id, &context).await
-    }
-
-    async fn get_file_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-    ) -> Result<GetFileHistoryResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_file_history(ident, limit, &context).await
-    }
-
-    async fn get_file_redirects(
-        &self,
-        ident: String,
-    ) -> Result<GetFileRedirectsResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_file_redirects(ident, &context).await
-    }
-
-    async fn get_file_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetFileRevisionResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .get_file_revision(rev_id, expand, hide, &context)
-            .await
-    }
-
-    async fn get_fileset(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetFilesetResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_fileset(ident, expand, hide, &context).await
-    }
-
-    async fn get_fileset_edit(&self, edit_id: String) -> Result<GetFilesetEditResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_fileset_edit(edit_id, &context).await
-    }
-
-    async fn get_fileset_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-    ) -> Result<GetFilesetHistoryResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_fileset_history(ident, limit, &context).await
-    }
-
-    async fn get_fileset_redirects(
-        &self,
-        ident: String,
-    ) -> Result<GetFilesetRedirectsResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_fileset_redirects(ident, &context).await
-    }
-
-    async fn get_fileset_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetFilesetRevisionResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .get_fileset_revision(rev_id, expand, hide, &context)
-            .await
-    }
-
-    async fn get_release(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetReleaseResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_release(ident, expand, hide, &context).await
-    }
-
-    async fn get_release_edit(&self, edit_id: String) -> Result<GetReleaseEditResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_release_edit(edit_id, &context).await
-    }
-
-    async fn get_release_files(
-        &self,
-        ident: String,
-        hide: Option<String>,
-    ) -> Result<GetReleaseFilesResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_release_files(ident, hide, &context).await
-    }
-
-    async fn get_release_filesets(
-        &self,
-        ident: String,
-        hide: Option<String>,
-    ) -> Result<GetReleaseFilesetsResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_release_filesets(ident, hide, &context).await
-    }
-
-    async fn get_release_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-    ) -> Result<GetReleaseHistoryResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_release_history(ident, limit, &context).await
-    }
-
-    async fn get_release_redirects(
-        &self,
-        ident: String,
-    ) -> Result<GetReleaseRedirectsResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_release_redirects(ident, &context).await
-    }
-
-    async fn get_release_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetReleaseRevisionResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .get_release_revision(rev_id, expand, hide, &context)
-            .await
-    }
-
-    async fn get_release_webcaptures(
-        &self,
-        ident: String,
-        hide: Option<String>,
-    ) -> Result<GetReleaseWebcapturesResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .get_release_webcaptures(ident, hide, &context)
-            .await
-    }
-
-    async fn get_webcapture(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetWebcaptureResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .get_webcapture(ident, expand, hide, &context)
-            .await
-    }
-
-    async fn get_webcapture_edit(
-        &self,
-        edit_id: String,
-    ) -> Result<GetWebcaptureEditResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_webcapture_edit(edit_id, &context).await
-    }
-
-    async fn get_webcapture_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-    ) -> Result<GetWebcaptureHistoryResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .get_webcapture_history(ident, limit, &context)
-            .await
-    }
-
-    async fn get_webcapture_redirects(
-        &self,
-        ident: String,
-    ) -> Result<GetWebcaptureRedirectsResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_webcapture_redirects(ident, &context).await
-    }
-
-    async fn get_webcapture_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetWebcaptureRevisionResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .get_webcapture_revision(rev_id, expand, hide, &context)
-            .await
-    }
-
-    async fn get_work(
-        &self,
-        ident: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetWorkResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_work(ident, expand, hide, &context).await
-    }
-
-    async fn get_work_edit(&self, edit_id: String) -> Result<GetWorkEditResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_work_edit(edit_id, &context).await
-    }
-
-    async fn get_work_history(
-        &self,
-        ident: String,
-        limit: Option<i64>,
-    ) -> Result<GetWorkHistoryResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_work_history(ident, limit, &context).await
-    }
-
-    async fn get_work_redirects(
-        &self,
-        ident: String,
-    ) -> Result<GetWorkRedirectsResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_work_redirects(ident, &context).await
-    }
-
-    async fn get_work_releases(
-        &self,
-        ident: String,
-        hide: Option<String>,
-    ) -> Result<GetWorkReleasesResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().get_work_releases(ident, hide, &context).await
-    }
-
-    async fn get_work_revision(
-        &self,
-        rev_id: String,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<GetWorkRevisionResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .get_work_revision(rev_id, expand, hide, &context)
-            .await
-    }
-
-    async fn lookup_container(
-        &self,
-        issnl: Option<String>,
-        wikidata_qid: Option<String>,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<LookupContainerResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .lookup_container(issnl, wikidata_qid, expand, hide, &context)
-            .await
-    }
-
-    async fn lookup_creator(
-        &self,
-        orcid: Option<String>,
-        wikidata_qid: Option<String>,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<LookupCreatorResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .lookup_creator(orcid, wikidata_qid, expand, hide, &context)
-            .await
-    }
-
-    async fn lookup_file(
-        &self,
-        md5: Option<String>,
-        sha1: Option<String>,
-        sha256: Option<String>,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<LookupFileResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .lookup_file(md5, sha1, sha256, expand, hide, &context)
-            .await
-    }
-
-    async fn lookup_release(
-        &self,
-        doi: Option<String>,
-        wikidata_qid: Option<String>,
-        isbn13: Option<String>,
-        pmid: Option<String>,
-        pmcid: Option<String>,
-        core: Option<String>,
-        arxiv: Option<String>,
-        jstor: Option<String>,
-        ark: Option<String>,
-        mag: Option<String>,
-        doaj: Option<String>,
-        dblp: Option<String>,
-        oai: Option<String>,
-        expand: Option<String>,
-        hide: Option<String>,
-    ) -> Result<LookupReleaseResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .lookup_release(
-                doi,
-                wikidata_qid,
-                isbn13,
-                pmid,
-                pmcid,
-                core,
-                arxiv,
-                jstor,
-                ark,
-                mag,
-                doaj,
-                dblp,
-                oai,
-                expand,
-                hide,
-                &context,
-            )
-            .await
-    }
-
-    async fn update_container(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        container_entity: models::ContainerEntity,
-    ) -> Result<UpdateContainerResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .update_container(editgroup_id, ident, container_entity, &context)
-            .await
-    }
-
-    async fn update_creator(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        creator_entity: models::CreatorEntity,
-    ) -> Result<UpdateCreatorResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .update_creator(editgroup_id, ident, creator_entity, &context)
-            .await
-    }
-
-    async fn update_editgroup(
-        &self,
-        editgroup_id: String,
-        editgroup: models::Editgroup,
-        submit: Option<bool>,
-    ) -> Result<UpdateEditgroupResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .update_editgroup(editgroup_id, editgroup, submit, &context)
-            .await
-    }
-
-    async fn update_editor(
-        &self,
-        editor_id: String,
-        editor: models::Editor,
-    ) -> Result<UpdateEditorResponse, ApiError> {
-        let context = self.context().clone();
-        self.api().update_editor(editor_id, editor, &context).await
-    }
-
-    async fn update_file(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        file_entity: models::FileEntity,
-    ) -> Result<UpdateFileResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .update_file(editgroup_id, ident, file_entity, &context)
-            .await
-    }
-
-    async fn update_fileset(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        fileset_entity: models::FilesetEntity,
-    ) -> Result<UpdateFilesetResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .update_fileset(editgroup_id, ident, fileset_entity, &context)
-            .await
-    }
-
-    async fn update_release(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        release_entity: models::ReleaseEntity,
-    ) -> Result<UpdateReleaseResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .update_release(editgroup_id, ident, release_entity, &context)
-            .await
-    }
-
-    async fn update_webcapture(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        webcapture_entity: models::WebcaptureEntity,
-    ) -> Result<UpdateWebcaptureResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .update_webcapture(editgroup_id, ident, webcapture_entity, &context)
-            .await
-    }
-
-    async fn update_work(
-        &self,
-        editgroup_id: String,
-        ident: String,
-        work_entity: models::WorkEntity,
-    ) -> Result<UpdateWorkResponse, ApiError> {
-        let context = self.context().clone();
-        self.api()
-            .update_work(editgroup_id, ident, work_entity, &context)
-            .await
-    }
-}
-
-#[cfg(feature = "client")]
-pub mod client;
-
-// Re-export Client as a top-level name
-#[cfg(feature = "client")]
-pub use client::Client;
-
-#[cfg(feature = "server")]
-pub mod server;
-
-// Re-export router() as a top-level name
-#[cfg(feature = "server")]
-pub use self::server::Service;
-
-#[cfg(feature = "server")]
-pub mod context;
-
-pub mod models;
-
-#[cfg(any(feature = "client", feature = "server"))]
-pub(crate) mod header;
diff --git a/rust/fatcat-openapi/src/models.rs b/rust/fatcat-openapi/src/models.rs
deleted file mode 100644
index d642c62..0000000
--- a/rust/fatcat-openapi/src/models.rs
+++ /dev/null
@@ -1,7621 +0,0 @@
-#![allow(unused_qualifications)]
-
-#[cfg(any(feature = "client", feature = "server"))]
-use crate::header;
-use crate::models;
-
-// Methods for converting between header::IntoHeaderValue<AuthOidc> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<AuthOidc>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<AuthOidc>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for AuthOidc - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<AuthOidc> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <AuthOidc as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into AuthOidc - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct AuthOidc {
-    /// Fatcat-specific short name (slug) for remote service being used for authentication.
-    #[serde(rename = "provider")]
-    pub provider: String,
-
-    /// `SUB` from OIDC protocol. Usually a URL.
-    #[serde(rename = "sub")]
-    pub sub: String,
-
-    /// `ISS` from OIDC protocol. Usually a stable account username, number, or identifier.
-    #[serde(rename = "iss")]
-    pub iss: String,
-
-    /// What it sounds like; returned by OIDC, and used as a hint when creating new editor accounts. Fatcat usernames are usually this string with the `provider` slug as a suffix, though some munging may occur.
-    #[serde(rename = "preferred_username")]
-    pub preferred_username: String,
-}
-
-impl AuthOidc {
-    pub fn new(provider: String, sub: String, iss: String, preferred_username: String) -> AuthOidc {
-        AuthOidc {
-            provider: provider,
-            sub: sub,
-            iss: iss,
-            preferred_username: preferred_username,
-        }
-    }
-}
-
-/// Converts the AuthOidc value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for AuthOidc {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        params.push("provider".to_string());
-        params.push(self.provider.to_string());
-
-        params.push("sub".to_string());
-        params.push(self.sub.to_string());
-
-        params.push("iss".to_string());
-        params.push(self.iss.to_string());
-
-        params.push("preferred_username".to_string());
-        params.push(self.preferred_username.to_string());
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a AuthOidc value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for AuthOidc {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub provider: Vec<String>,
-            pub sub: Vec<String>,
-            pub iss: Vec<String>,
-            pub preferred_username: Vec<String>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing AuthOidc".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "provider" => intermediate_rep
-                        .provider
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "sub" => intermediate_rep
-                        .sub
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "iss" => intermediate_rep
-                        .iss
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "preferred_username" => intermediate_rep
-                        .preferred_username
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing AuthOidc".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(AuthOidc {
-            provider: intermediate_rep
-                .provider
-                .into_iter()
-                .next()
-                .ok_or("provider missing in AuthOidc".to_string())?,
-            sub: intermediate_rep
-                .sub
-                .into_iter()
-                .next()
-                .ok_or("sub missing in AuthOidc".to_string())?,
-            iss: intermediate_rep
-                .iss
-                .into_iter()
-                .next()
-                .ok_or("iss missing in AuthOidc".to_string())?,
-            preferred_username: intermediate_rep
-                .preferred_username
-                .into_iter()
-                .next()
-                .ok_or("preferred_username missing in AuthOidc".to_string())?,
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<AuthOidcResult> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<AuthOidcResult>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<AuthOidcResult>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for AuthOidcResult - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<AuthOidcResult> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <AuthOidcResult as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into AuthOidcResult - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct AuthOidcResult {
-    #[serde(rename = "editor")]
-    pub editor: models::Editor,
-
-    #[serde(rename = "token")]
-    pub token: String,
-}
-
-impl AuthOidcResult {
-    pub fn new(editor: models::Editor, token: String) -> AuthOidcResult {
-        AuthOidcResult {
-            editor: editor,
-            token: token,
-        }
-    }
-}
-
-/// Converts the AuthOidcResult value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for AuthOidcResult {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-        // Skipping editor in query parameter serialization
-
-        params.push("token".to_string());
-        params.push(self.token.to_string());
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a AuthOidcResult value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for AuthOidcResult {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub editor: Vec<models::Editor>,
-            pub token: Vec<String>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing AuthOidcResult".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "editor" => intermediate_rep
-                        .editor
-                        .push(models::Editor::from_str(val).map_err(|x| format!("{}", x))?),
-                    "token" => intermediate_rep
-                        .token
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing AuthOidcResult".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(AuthOidcResult {
-            editor: intermediate_rep
-                .editor
-                .into_iter()
-                .next()
-                .ok_or("editor missing in AuthOidcResult".to_string())?,
-            token: intermediate_rep
-                .token
-                .into_iter()
-                .next()
-                .ok_or("token missing in AuthOidcResult".to_string())?,
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<AuthTokenResult> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<AuthTokenResult>>
-    for hyper::header::HeaderValue
-{
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<AuthTokenResult>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for AuthTokenResult - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue>
-    for header::IntoHeaderValue<AuthTokenResult>
-{
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <AuthTokenResult as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into AuthTokenResult - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct AuthTokenResult {
-    #[serde(rename = "token")]
-    pub token: String,
-}
-
-impl AuthTokenResult {
-    pub fn new(token: String) -> AuthTokenResult {
-        AuthTokenResult { token: token }
-    }
-}
-
-/// Converts the AuthTokenResult value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for AuthTokenResult {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        params.push("token".to_string());
-        params.push(self.token.to_string());
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a AuthTokenResult value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for AuthTokenResult {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub token: Vec<String>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing AuthTokenResult".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "token" => intermediate_rep
-                        .token
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing AuthTokenResult".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(AuthTokenResult {
-            token: intermediate_rep
-                .token
-                .into_iter()
-                .next()
-                .ok_or("token missing in AuthTokenResult".to_string())?,
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<ChangelogEntry> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<ChangelogEntry>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<ChangelogEntry>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for ChangelogEntry - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ChangelogEntry> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <ChangelogEntry as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into ChangelogEntry - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct ChangelogEntry {
-    /// Monotonically increasing sequence number of this changelog entry.
-    #[serde(rename = "index")]
-    pub index: i64,
-
-    /// Identifier of editgroup accepted/merged in this changelog entry.
-    #[serde(rename = "editgroup_id")]
-    pub editgroup_id: String,
-
-    /// Date and time when the editgroup was accpeted.
-    #[serde(rename = "timestamp")]
-    pub timestamp: chrono::DateTime<chrono::Utc>,
-
-    #[serde(rename = "editgroup")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub editgroup: Option<models::Editgroup>,
-}
-
-impl ChangelogEntry {
-    pub fn new(
-        index: i64,
-        editgroup_id: String,
-        timestamp: chrono::DateTime<chrono::Utc>,
-    ) -> ChangelogEntry {
-        ChangelogEntry {
-            index: index,
-            editgroup_id: editgroup_id,
-            timestamp: timestamp,
-            editgroup: None,
-        }
-    }
-}
-
-/// Converts the ChangelogEntry value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for ChangelogEntry {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        params.push("index".to_string());
-        params.push(self.index.to_string());
-
-        params.push("editgroup_id".to_string());
-        params.push(self.editgroup_id.to_string());
-
-        // Skipping timestamp in query parameter serialization
-
-        // Skipping editgroup in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a ChangelogEntry value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for ChangelogEntry {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub index: Vec<i64>,
-            pub editgroup_id: Vec<String>,
-            pub timestamp: Vec<chrono::DateTime<chrono::Utc>>,
-            pub editgroup: Vec<models::Editgroup>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing ChangelogEntry".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "index" => intermediate_rep
-                        .index
-                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
-                    "editgroup_id" => intermediate_rep
-                        .editgroup_id
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "timestamp" => intermediate_rep.timestamp.push(
-                        chrono::DateTime::<chrono::Utc>::from_str(val)
-                            .map_err(|x| format!("{}", x))?,
-                    ),
-                    "editgroup" => intermediate_rep
-                        .editgroup
-                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing ChangelogEntry".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(ChangelogEntry {
-            index: intermediate_rep
-                .index
-                .into_iter()
-                .next()
-                .ok_or("index missing in ChangelogEntry".to_string())?,
-            editgroup_id: intermediate_rep
-                .editgroup_id
-                .into_iter()
-                .next()
-                .ok_or("editgroup_id missing in ChangelogEntry".to_string())?,
-            timestamp: intermediate_rep
-                .timestamp
-                .into_iter()
-                .next()
-                .ok_or("timestamp missing in ChangelogEntry".to_string())?,
-            editgroup: intermediate_rep.editgroup.into_iter().next(),
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<ContainerAutoBatch> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<ContainerAutoBatch>>
-    for hyper::header::HeaderValue
-{
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<ContainerAutoBatch>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for ContainerAutoBatch - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue>
-    for header::IntoHeaderValue<ContainerAutoBatch>
-{
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <ContainerAutoBatch as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into ContainerAutoBatch - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct ContainerAutoBatch {
-    #[serde(rename = "editgroup")]
-    pub editgroup: models::Editgroup,
-
-    #[serde(rename = "entity_list")]
-    pub entity_list: Vec<models::ContainerEntity>,
-}
-
-impl ContainerAutoBatch {
-    pub fn new(
-        editgroup: models::Editgroup,
-        entity_list: Vec<models::ContainerEntity>,
-    ) -> ContainerAutoBatch {
-        ContainerAutoBatch {
-            editgroup: editgroup,
-            entity_list: entity_list,
-        }
-    }
-}
-
-/// Converts the ContainerAutoBatch value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for ContainerAutoBatch {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-        // Skipping editgroup in query parameter serialization
-
-        // Skipping entity_list in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a ContainerAutoBatch value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for ContainerAutoBatch {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub editgroup: Vec<models::Editgroup>,
-            pub entity_list: Vec<Vec<models::ContainerEntity>>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing ContainerAutoBatch".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "editgroup" => intermediate_rep
-                        .editgroup
-                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
-                    "entity_list" => return std::result::Result::Err(
-                        "Parsing a container in this style is not supported in ContainerAutoBatch"
-                            .to_string(),
-                    ),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing ContainerAutoBatch".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(ContainerAutoBatch {
-            editgroup: intermediate_rep
-                .editgroup
-                .into_iter()
-                .next()
-                .ok_or("editgroup missing in ContainerAutoBatch".to_string())?,
-            entity_list: intermediate_rep
-                .entity_list
-                .into_iter()
-                .next()
-                .ok_or("entity_list missing in ContainerAutoBatch".to_string())?,
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<ContainerEntity> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<ContainerEntity>>
-    for hyper::header::HeaderValue
-{
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<ContainerEntity>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for ContainerEntity - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue>
-    for header::IntoHeaderValue<ContainerEntity>
-{
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <ContainerEntity as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into ContainerEntity - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct ContainerEntity {
-    // Note: inline enums are not fully supported by openapi-generator
-    #[serde(rename = "state")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub state: Option<String>,
-
-    /// base32-encoded unique identifier
-    #[serde(rename = "ident")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ident: Option<String>,
-
-    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
-    #[serde(rename = "revision")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub revision: Option<String>,
-
-    /// base32-encoded unique identifier
-    #[serde(rename = "redirect")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub redirect: Option<String>,
-
-    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
-    #[serde(rename = "extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-
-    /// Free-form JSON metadata that will be stored with specific entity edits  (eg, creation/update/delete).
-    #[serde(rename = "edit_extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-
-    /// Name of the container (eg, Journal title). Required for entity creation.
-    #[serde(rename = "name")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub name: Option<String>,
-
-    /// Type of container, eg 'journal' or 'proceedings'. See Guide for list of valid types.
-    #[serde(rename = "container_type")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub container_type: Option<String>,
-
-    /// Name of the organization or entity responsible for publication. Not the complete imprint/brand.
-    #[serde(rename = "publisher")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub publisher: Option<String>,
-
-    /// Linking ISSN number (ISSN-L). Should be valid and registered with issn.org
-    #[serde(rename = "issnl")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub issnl: Option<String>,
-
-    #[serde(rename = "wikidata_qid")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub wikidata_qid: Option<String>,
-}
-
-impl ContainerEntity {
-    pub fn new() -> ContainerEntity {
-        ContainerEntity {
-            state: None,
-            ident: None,
-            revision: None,
-            redirect: None,
-            extra: None,
-            edit_extra: None,
-            name: None,
-            container_type: None,
-            publisher: None,
-            issnl: None,
-            wikidata_qid: None,
-        }
-    }
-}
-
-/// Converts the ContainerEntity value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for ContainerEntity {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        if let Some(ref state) = self.state {
-            params.push("state".to_string());
-            params.push(state.to_string());
-        }
-
-        if let Some(ref ident) = self.ident {
-            params.push("ident".to_string());
-            params.push(ident.to_string());
-        }
-
-        if let Some(ref revision) = self.revision {
-            params.push("revision".to_string());
-            params.push(revision.to_string());
-        }
-
-        if let Some(ref redirect) = self.redirect {
-            params.push("redirect".to_string());
-            params.push(redirect.to_string());
-        }
-
-        // Skipping extra in query parameter serialization
-        // Skipping extra in query parameter serialization
-
-        // Skipping edit_extra in query parameter serialization
-        // Skipping edit_extra in query parameter serialization
-
-        if let Some(ref name) = self.name {
-            params.push("name".to_string());
-            params.push(name.to_string());
-        }
-
-        if let Some(ref container_type) = self.container_type {
-            params.push("container_type".to_string());
-            params.push(container_type.to_string());
-        }
-
-        if let Some(ref publisher) = self.publisher {
-            params.push("publisher".to_string());
-            params.push(publisher.to_string());
-        }
-
-        if let Some(ref issnl) = self.issnl {
-            params.push("issnl".to_string());
-            params.push(issnl.to_string());
-        }
-
-        if let Some(ref wikidata_qid) = self.wikidata_qid {
-            params.push("wikidata_qid".to_string());
-            params.push(wikidata_qid.to_string());
-        }
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a ContainerEntity value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for ContainerEntity {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub state: Vec<String>,
-            pub ident: Vec<String>,
-            pub revision: Vec<String>,
-            pub redirect: Vec<String>,
-            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-            pub name: Vec<String>,
-            pub container_type: Vec<String>,
-            pub publisher: Vec<String>,
-            pub issnl: Vec<String>,
-            pub wikidata_qid: Vec<String>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing ContainerEntity".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "state" => intermediate_rep
-                        .state
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "ident" => intermediate_rep
-                        .ident
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "revision" => intermediate_rep
-                        .revision
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "redirect" => intermediate_rep
-                        .redirect
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "extra" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in ContainerEntity"
-                                .to_string(),
-                        )
-                    }
-                    "edit_extra" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in ContainerEntity"
-                                .to_string(),
-                        )
-                    }
-                    "name" => intermediate_rep
-                        .name
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "container_type" => intermediate_rep
-                        .container_type
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "publisher" => intermediate_rep
-                        .publisher
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "issnl" => intermediate_rep
-                        .issnl
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "wikidata_qid" => intermediate_rep
-                        .wikidata_qid
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing ContainerEntity".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(ContainerEntity {
-            state: intermediate_rep.state.into_iter().next(),
-            ident: intermediate_rep.ident.into_iter().next(),
-            revision: intermediate_rep.revision.into_iter().next(),
-            redirect: intermediate_rep.redirect.into_iter().next(),
-            extra: intermediate_rep.extra.into_iter().next(),
-            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
-            name: intermediate_rep.name.into_iter().next(),
-            container_type: intermediate_rep.container_type.into_iter().next(),
-            publisher: intermediate_rep.publisher.into_iter().next(),
-            issnl: intermediate_rep.issnl.into_iter().next(),
-            wikidata_qid: intermediate_rep.wikidata_qid.into_iter().next(),
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<CreatorAutoBatch> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<CreatorAutoBatch>>
-    for hyper::header::HeaderValue
-{
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<CreatorAutoBatch>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for CreatorAutoBatch - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue>
-    for header::IntoHeaderValue<CreatorAutoBatch>
-{
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <CreatorAutoBatch as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into CreatorAutoBatch - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct CreatorAutoBatch {
-    #[serde(rename = "editgroup")]
-    pub editgroup: models::Editgroup,
-
-    #[serde(rename = "entity_list")]
-    pub entity_list: Vec<models::CreatorEntity>,
-}
-
-impl CreatorAutoBatch {
-    pub fn new(
-        editgroup: models::Editgroup,
-        entity_list: Vec<models::CreatorEntity>,
-    ) -> CreatorAutoBatch {
-        CreatorAutoBatch {
-            editgroup: editgroup,
-            entity_list: entity_list,
-        }
-    }
-}
-
-/// Converts the CreatorAutoBatch value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for CreatorAutoBatch {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-        // Skipping editgroup in query parameter serialization
-
-        // Skipping entity_list in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a CreatorAutoBatch value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for CreatorAutoBatch {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub editgroup: Vec<models::Editgroup>,
-            pub entity_list: Vec<Vec<models::CreatorEntity>>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing CreatorAutoBatch".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "editgroup" => intermediate_rep
-                        .editgroup
-                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
-                    "entity_list" => return std::result::Result::Err(
-                        "Parsing a container in this style is not supported in CreatorAutoBatch"
-                            .to_string(),
-                    ),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing CreatorAutoBatch".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(CreatorAutoBatch {
-            editgroup: intermediate_rep
-                .editgroup
-                .into_iter()
-                .next()
-                .ok_or("editgroup missing in CreatorAutoBatch".to_string())?,
-            entity_list: intermediate_rep
-                .entity_list
-                .into_iter()
-                .next()
-                .ok_or("entity_list missing in CreatorAutoBatch".to_string())?,
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<CreatorEntity> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<CreatorEntity>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<CreatorEntity>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for CreatorEntity - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<CreatorEntity> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <CreatorEntity as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into CreatorEntity - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct CreatorEntity {
-    // Note: inline enums are not fully supported by openapi-generator
-    #[serde(rename = "state")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub state: Option<String>,
-
-    /// base32-encoded unique identifier
-    #[serde(rename = "ident")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ident: Option<String>,
-
-    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
-    #[serde(rename = "revision")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub revision: Option<String>,
-
-    /// base32-encoded unique identifier
-    #[serde(rename = "redirect")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub redirect: Option<String>,
-
-    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
-    #[serde(rename = "extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-
-    /// Free-form JSON metadata that will be stored with specific entity edits  (eg, creation/update/delete).
-    #[serde(rename = "edit_extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-
-    /// Name as should be displayed in web interface or in author lists (not index/sorted). Required for valid entities.
-    #[serde(rename = "display_name")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub display_name: Option<String>,
-
-    /// In English commonly the first name, but ordering is context and culture specific.
-    #[serde(rename = "given_name")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub given_name: Option<String>,
-
-    /// In English commonly the last, or family name, but ordering is context  and culture specific.
-    #[serde(rename = "surname")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub surname: Option<String>,
-
-    /// ORCiD (https://orcid.org) identifier
-    #[serde(rename = "orcid")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub orcid: Option<String>,
-
-    /// Wikidata entity QID
-    #[serde(rename = "wikidata_qid")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub wikidata_qid: Option<String>,
-}
-
-impl CreatorEntity {
-    pub fn new() -> CreatorEntity {
-        CreatorEntity {
-            state: None,
-            ident: None,
-            revision: None,
-            redirect: None,
-            extra: None,
-            edit_extra: None,
-            display_name: None,
-            given_name: None,
-            surname: None,
-            orcid: None,
-            wikidata_qid: None,
-        }
-    }
-}
-
-/// Converts the CreatorEntity value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for CreatorEntity {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        if let Some(ref state) = self.state {
-            params.push("state".to_string());
-            params.push(state.to_string());
-        }
-
-        if let Some(ref ident) = self.ident {
-            params.push("ident".to_string());
-            params.push(ident.to_string());
-        }
-
-        if let Some(ref revision) = self.revision {
-            params.push("revision".to_string());
-            params.push(revision.to_string());
-        }
-
-        if let Some(ref redirect) = self.redirect {
-            params.push("redirect".to_string());
-            params.push(redirect.to_string());
-        }
-
-        // Skipping extra in query parameter serialization
-        // Skipping extra in query parameter serialization
-
-        // Skipping edit_extra in query parameter serialization
-        // Skipping edit_extra in query parameter serialization
-
-        if let Some(ref display_name) = self.display_name {
-            params.push("display_name".to_string());
-            params.push(display_name.to_string());
-        }
-
-        if let Some(ref given_name) = self.given_name {
-            params.push("given_name".to_string());
-            params.push(given_name.to_string());
-        }
-
-        if let Some(ref surname) = self.surname {
-            params.push("surname".to_string());
-            params.push(surname.to_string());
-        }
-
-        if let Some(ref orcid) = self.orcid {
-            params.push("orcid".to_string());
-            params.push(orcid.to_string());
-        }
-
-        if let Some(ref wikidata_qid) = self.wikidata_qid {
-            params.push("wikidata_qid".to_string());
-            params.push(wikidata_qid.to_string());
-        }
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a CreatorEntity value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for CreatorEntity {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub state: Vec<String>,
-            pub ident: Vec<String>,
-            pub revision: Vec<String>,
-            pub redirect: Vec<String>,
-            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-            pub display_name: Vec<String>,
-            pub given_name: Vec<String>,
-            pub surname: Vec<String>,
-            pub orcid: Vec<String>,
-            pub wikidata_qid: Vec<String>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing CreatorEntity".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "state" => intermediate_rep
-                        .state
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "ident" => intermediate_rep
-                        .ident
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "revision" => intermediate_rep
-                        .revision
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "redirect" => intermediate_rep
-                        .redirect
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "extra" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in CreatorEntity"
-                                .to_string(),
-                        )
-                    }
-                    "edit_extra" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in CreatorEntity"
-                                .to_string(),
-                        )
-                    }
-                    "display_name" => intermediate_rep
-                        .display_name
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "given_name" => intermediate_rep
-                        .given_name
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "surname" => intermediate_rep
-                        .surname
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "orcid" => intermediate_rep
-                        .orcid
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "wikidata_qid" => intermediate_rep
-                        .wikidata_qid
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing CreatorEntity".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(CreatorEntity {
-            state: intermediate_rep.state.into_iter().next(),
-            ident: intermediate_rep.ident.into_iter().next(),
-            revision: intermediate_rep.revision.into_iter().next(),
-            redirect: intermediate_rep.redirect.into_iter().next(),
-            extra: intermediate_rep.extra.into_iter().next(),
-            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
-            display_name: intermediate_rep.display_name.into_iter().next(),
-            given_name: intermediate_rep.given_name.into_iter().next(),
-            surname: intermediate_rep.surname.into_iter().next(),
-            orcid: intermediate_rep.orcid.into_iter().next(),
-            wikidata_qid: intermediate_rep.wikidata_qid.into_iter().next(),
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<Editgroup> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<Editgroup>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<Editgroup>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for Editgroup - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Editgroup> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <Editgroup as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into Editgroup - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct Editgroup {
-    /// Fatcat identifier for this editgroup. Assigned on creation.
-    #[serde(rename = "editgroup_id")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub editgroup_id: Option<String>,
-
-    /// Fatcat identifer of editor that created this editgroup.
-    #[serde(rename = "editor_id")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub editor_id: Option<String>,
-
-    #[serde(rename = "editor")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub editor: Option<models::Editor>,
-
-    /// For accepted/merged editgroups, the changelog index that the accept occured at. WARNING: not populated in all contexts that an editgroup could be included in a response.
-    #[serde(rename = "changelog_index")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub changelog_index: Option<i64>,
-
-    /// Timestamp when this editgroup was first created.
-    #[serde(rename = "created")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub created: Option<chrono::DateTime<chrono::Utc>>,
-
-    /// Timestamp when this editgroup was most recently submitted for review. If withdrawn, or never submitted, will be `null`.
-    #[serde(rename = "submitted")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub submitted: Option<chrono::DateTime<chrono::Utc>>,
-
-    /// Comment describing the changes in this editgroup. Can be updated with PUT request.
-    #[serde(rename = "description")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub description: Option<String>,
-
-    /// Free-form JSON metadata attached to this editgroup. Eg, metadata provenance, or script user-agent details. See guide for (unenforced) schema norms.
-    #[serde(rename = "extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-
-    /// Only included in GET responses, and not in all contexts. Do not include this field in PUT or POST requests.
-    #[serde(rename = "annotations")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub annotations: Option<Vec<models::EditgroupAnnotation>>,
-
-    #[serde(rename = "edits")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub edits: Option<models::EditgroupEdits>,
-}
-
-impl Editgroup {
-    pub fn new() -> Editgroup {
-        Editgroup {
-            editgroup_id: None,
-            editor_id: None,
-            editor: None,
-            changelog_index: None,
-            created: None,
-            submitted: None,
-            description: None,
-            extra: None,
-            annotations: None,
-            edits: None,
-        }
-    }
-}
-
-/// Converts the Editgroup value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for Editgroup {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        if let Some(ref editgroup_id) = self.editgroup_id {
-            params.push("editgroup_id".to_string());
-            params.push(editgroup_id.to_string());
-        }
-
-        if let Some(ref editor_id) = self.editor_id {
-            params.push("editor_id".to_string());
-            params.push(editor_id.to_string());
-        }
-
-        // Skipping editor in query parameter serialization
-
-        if let Some(ref changelog_index) = self.changelog_index {
-            params.push("changelog_index".to_string());
-            params.push(changelog_index.to_string());
-        }
-
-        // Skipping created in query parameter serialization
-
-        // Skipping submitted in query parameter serialization
-
-        if let Some(ref description) = self.description {
-            params.push("description".to_string());
-            params.push(description.to_string());
-        }
-
-        // Skipping extra in query parameter serialization
-        // Skipping extra in query parameter serialization
-
-        // Skipping annotations in query parameter serialization
-
-        // Skipping edits in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a Editgroup value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for Editgroup {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub editgroup_id: Vec<String>,
-            pub editor_id: Vec<String>,
-            pub editor: Vec<models::Editor>,
-            pub changelog_index: Vec<i64>,
-            pub created: Vec<chrono::DateTime<chrono::Utc>>,
-            pub submitted: Vec<chrono::DateTime<chrono::Utc>>,
-            pub description: Vec<String>,
-            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-            pub annotations: Vec<Vec<models::EditgroupAnnotation>>,
-            pub edits: Vec<models::EditgroupEdits>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing Editgroup".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "editgroup_id" => intermediate_rep
-                        .editgroup_id
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "editor_id" => intermediate_rep
-                        .editor_id
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "editor" => intermediate_rep
-                        .editor
-                        .push(models::Editor::from_str(val).map_err(|x| format!("{}", x))?),
-                    "changelog_index" => intermediate_rep
-                        .changelog_index
-                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
-                    "created" => intermediate_rep.created.push(
-                        chrono::DateTime::<chrono::Utc>::from_str(val)
-                            .map_err(|x| format!("{}", x))?,
-                    ),
-                    "submitted" => intermediate_rep.submitted.push(
-                        chrono::DateTime::<chrono::Utc>::from_str(val)
-                            .map_err(|x| format!("{}", x))?,
-                    ),
-                    "description" => intermediate_rep
-                        .description
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "extra" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in Editgroup"
-                                .to_string(),
-                        )
-                    }
-                    "annotations" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in Editgroup"
-                                .to_string(),
-                        )
-                    }
-                    "edits" => intermediate_rep
-                        .edits
-                        .push(models::EditgroupEdits::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing Editgroup".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(Editgroup {
-            editgroup_id: intermediate_rep.editgroup_id.into_iter().next(),
-            editor_id: intermediate_rep.editor_id.into_iter().next(),
-            editor: intermediate_rep.editor.into_iter().next(),
-            changelog_index: intermediate_rep.changelog_index.into_iter().next(),
-            created: intermediate_rep.created.into_iter().next(),
-            submitted: intermediate_rep.submitted.into_iter().next(),
-            description: intermediate_rep.description.into_iter().next(),
-            extra: intermediate_rep.extra.into_iter().next(),
-            annotations: intermediate_rep.annotations.into_iter().next(),
-            edits: intermediate_rep.edits.into_iter().next(),
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<EditgroupAnnotation> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<EditgroupAnnotation>>
-    for hyper::header::HeaderValue
-{
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<EditgroupAnnotation>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for EditgroupAnnotation - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue>
-    for header::IntoHeaderValue<EditgroupAnnotation>
-{
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <EditgroupAnnotation as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into EditgroupAnnotation - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct EditgroupAnnotation {
-    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
-    #[serde(rename = "annotation_id")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub annotation_id: Option<String>,
-
-    /// Editgroup that this annotation applies to. Set automatically in creations based on URL parameter.
-    #[serde(rename = "editgroup_id")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub editgroup_id: Option<String>,
-
-    /// Defaults to editor created the annotation via POST request.
-    #[serde(rename = "editor_id")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub editor_id: Option<String>,
-
-    #[serde(rename = "editor")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub editor: Option<models::Editor>,
-
-    /// Timestamp when annotation was first created.
-    #[serde(rename = "created")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub created: Option<chrono::DateTime<chrono::Utc>>,
-
-    #[serde(rename = "comment_markdown")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub comment_markdown: Option<String>,
-
-    /// Additional free-form JSON metadata that can be included as part of the annotation (or even as the primary annotation itself). See guide for details.
-    #[serde(rename = "extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-}
-
-impl EditgroupAnnotation {
-    pub fn new() -> EditgroupAnnotation {
-        EditgroupAnnotation {
-            annotation_id: None,
-            editgroup_id: None,
-            editor_id: None,
-            editor: None,
-            created: None,
-            comment_markdown: None,
-            extra: None,
-        }
-    }
-}
-
-/// Converts the EditgroupAnnotation value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for EditgroupAnnotation {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        if let Some(ref annotation_id) = self.annotation_id {
-            params.push("annotation_id".to_string());
-            params.push(annotation_id.to_string());
-        }
-
-        if let Some(ref editgroup_id) = self.editgroup_id {
-            params.push("editgroup_id".to_string());
-            params.push(editgroup_id.to_string());
-        }
-
-        if let Some(ref editor_id) = self.editor_id {
-            params.push("editor_id".to_string());
-            params.push(editor_id.to_string());
-        }
-
-        // Skipping editor in query parameter serialization
-
-        // Skipping created in query parameter serialization
-
-        if let Some(ref comment_markdown) = self.comment_markdown {
-            params.push("comment_markdown".to_string());
-            params.push(comment_markdown.to_string());
-        }
-
-        // Skipping extra in query parameter serialization
-        // Skipping extra in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a EditgroupAnnotation value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for EditgroupAnnotation {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub annotation_id: Vec<String>,
-            pub editgroup_id: Vec<String>,
-            pub editor_id: Vec<String>,
-            pub editor: Vec<models::Editor>,
-            pub created: Vec<chrono::DateTime<chrono::Utc>>,
-            pub comment_markdown: Vec<String>,
-            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing EditgroupAnnotation".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "annotation_id" => intermediate_rep
-                        .annotation_id
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "editgroup_id" => intermediate_rep
-                        .editgroup_id
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "editor_id" => intermediate_rep
-                        .editor_id
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "editor" => intermediate_rep
-                        .editor
-                        .push(models::Editor::from_str(val).map_err(|x| format!("{}", x))?),
-                    "created" => intermediate_rep.created.push(
-                        chrono::DateTime::<chrono::Utc>::from_str(val)
-                            .map_err(|x| format!("{}", x))?,
-                    ),
-                    "comment_markdown" => intermediate_rep
-                        .comment_markdown
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "extra" => return std::result::Result::Err(
-                        "Parsing a container in this style is not supported in EditgroupAnnotation"
-                            .to_string(),
-                    ),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing EditgroupAnnotation".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(EditgroupAnnotation {
-            annotation_id: intermediate_rep.annotation_id.into_iter().next(),
-            editgroup_id: intermediate_rep.editgroup_id.into_iter().next(),
-            editor_id: intermediate_rep.editor_id.into_iter().next(),
-            editor: intermediate_rep.editor.into_iter().next(),
-            created: intermediate_rep.created.into_iter().next(),
-            comment_markdown: intermediate_rep.comment_markdown.into_iter().next(),
-            extra: intermediate_rep.extra.into_iter().next(),
-        })
-    }
-}
-
-/// Only included in GET responses, and not in all contexts. Do not include this field in PUT or POST requests.
-// Methods for converting between header::IntoHeaderValue<EditgroupEdits> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<EditgroupEdits>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<EditgroupEdits>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for EditgroupEdits - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<EditgroupEdits> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <EditgroupEdits as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into EditgroupEdits - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct EditgroupEdits {
-    #[serde(rename = "containers")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub containers: Option<Vec<models::EntityEdit>>,
-
-    #[serde(rename = "creators")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub creators: Option<Vec<models::EntityEdit>>,
-
-    #[serde(rename = "files")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub files: Option<Vec<models::EntityEdit>>,
-
-    #[serde(rename = "filesets")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub filesets: Option<Vec<models::EntityEdit>>,
-
-    #[serde(rename = "webcaptures")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub webcaptures: Option<Vec<models::EntityEdit>>,
-
-    #[serde(rename = "releases")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub releases: Option<Vec<models::EntityEdit>>,
-
-    #[serde(rename = "works")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub works: Option<Vec<models::EntityEdit>>,
-}
-
-impl EditgroupEdits {
-    pub fn new() -> EditgroupEdits {
-        EditgroupEdits {
-            containers: None,
-            creators: None,
-            files: None,
-            filesets: None,
-            webcaptures: None,
-            releases: None,
-            works: None,
-        }
-    }
-}
-
-/// Converts the EditgroupEdits value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for EditgroupEdits {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-        // Skipping containers in query parameter serialization
-
-        // Skipping creators in query parameter serialization
-
-        // Skipping files in query parameter serialization
-
-        // Skipping filesets in query parameter serialization
-
-        // Skipping webcaptures in query parameter serialization
-
-        // Skipping releases in query parameter serialization
-
-        // Skipping works in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a EditgroupEdits value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for EditgroupEdits {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub containers: Vec<Vec<models::EntityEdit>>,
-            pub creators: Vec<Vec<models::EntityEdit>>,
-            pub files: Vec<Vec<models::EntityEdit>>,
-            pub filesets: Vec<Vec<models::EntityEdit>>,
-            pub webcaptures: Vec<Vec<models::EntityEdit>>,
-            pub releases: Vec<Vec<models::EntityEdit>>,
-            pub works: Vec<Vec<models::EntityEdit>>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing EditgroupEdits".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "containers" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in EditgroupEdits"
-                                .to_string(),
-                        )
-                    }
-                    "creators" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in EditgroupEdits"
-                                .to_string(),
-                        )
-                    }
-                    "files" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in EditgroupEdits"
-                                .to_string(),
-                        )
-                    }
-                    "filesets" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in EditgroupEdits"
-                                .to_string(),
-                        )
-                    }
-                    "webcaptures" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in EditgroupEdits"
-                                .to_string(),
-                        )
-                    }
-                    "releases" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in EditgroupEdits"
-                                .to_string(),
-                        )
-                    }
-                    "works" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in EditgroupEdits"
-                                .to_string(),
-                        )
-                    }
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing EditgroupEdits".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(EditgroupEdits {
-            containers: intermediate_rep.containers.into_iter().next(),
-            creators: intermediate_rep.creators.into_iter().next(),
-            files: intermediate_rep.files.into_iter().next(),
-            filesets: intermediate_rep.filesets.into_iter().next(),
-            webcaptures: intermediate_rep.webcaptures.into_iter().next(),
-            releases: intermediate_rep.releases.into_iter().next(),
-            works: intermediate_rep.works.into_iter().next(),
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<Editor> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<Editor>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<Editor>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for Editor - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Editor> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <Editor as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into Editor - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct Editor {
-    /// Fatcat identifier for the editor. Can not be changed.
-    #[serde(rename = "editor_id")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub editor_id: Option<String>,
-
-    /// Username/handle (short slug-like string) to identify this editor. May be changed at any time by the editor; use the `editor_id` as a persistend identifer.
-    #[serde(rename = "username")]
-    pub username: String,
-
-    /// Whether this editor has the `admin` role.
-    #[serde(rename = "is_admin")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub is_admin: Option<bool>,
-
-    /// Whether this editor is a bot (as opposed to a human making manual edits)
-    #[serde(rename = "is_bot")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub is_bot: Option<bool>,
-
-    /// Whether this editor's account is enabled (if not API tokens and web logins will not work).
-    #[serde(rename = "is_active")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub is_active: Option<bool>,
-}
-
-impl Editor {
-    pub fn new(username: String) -> Editor {
-        Editor {
-            editor_id: None,
-            username: username,
-            is_admin: None,
-            is_bot: None,
-            is_active: None,
-        }
-    }
-}
-
-/// Converts the Editor value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for Editor {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        if let Some(ref editor_id) = self.editor_id {
-            params.push("editor_id".to_string());
-            params.push(editor_id.to_string());
-        }
-
-        params.push("username".to_string());
-        params.push(self.username.to_string());
-
-        if let Some(ref is_admin) = self.is_admin {
-            params.push("is_admin".to_string());
-            params.push(is_admin.to_string());
-        }
-
-        if let Some(ref is_bot) = self.is_bot {
-            params.push("is_bot".to_string());
-            params.push(is_bot.to_string());
-        }
-
-        if let Some(ref is_active) = self.is_active {
-            params.push("is_active".to_string());
-            params.push(is_active.to_string());
-        }
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a Editor value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for Editor {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub editor_id: Vec<String>,
-            pub username: Vec<String>,
-            pub is_admin: Vec<bool>,
-            pub is_bot: Vec<bool>,
-            pub is_active: Vec<bool>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing Editor".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "editor_id" => intermediate_rep
-                        .editor_id
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "username" => intermediate_rep
-                        .username
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "is_admin" => intermediate_rep
-                        .is_admin
-                        .push(bool::from_str(val).map_err(|x| format!("{}", x))?),
-                    "is_bot" => intermediate_rep
-                        .is_bot
-                        .push(bool::from_str(val).map_err(|x| format!("{}", x))?),
-                    "is_active" => intermediate_rep
-                        .is_active
-                        .push(bool::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing Editor".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(Editor {
-            editor_id: intermediate_rep.editor_id.into_iter().next(),
-            username: intermediate_rep
-                .username
-                .into_iter()
-                .next()
-                .ok_or("username missing in Editor".to_string())?,
-            is_admin: intermediate_rep.is_admin.into_iter().next(),
-            is_bot: intermediate_rep.is_bot.into_iter().next(),
-            is_active: intermediate_rep.is_active.into_iter().next(),
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<EntityEdit> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<EntityEdit>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<EntityEdit>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for EntityEdit - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<EntityEdit> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <EntityEdit as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into EntityEdit - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct EntityEdit {
-    /// Unique UUID for this specific edit object.
-    #[serde(rename = "edit_id")]
-    pub edit_id: String,
-
-    /// Fatcat identifier of the entity this edit is mutating.
-    #[serde(rename = "ident")]
-    pub ident: String,
-
-    /// Entity revision that this edit will set the entity to. May be `null` in the case of deletions.
-    #[serde(rename = "revision")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub revision: Option<String>,
-
-    /// Revision of entity just before this edit. May be used in the future to prevent edit race conditions.
-    #[serde(rename = "prev_revision")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub prev_revision: Option<String>,
-
-    /// When an edit is to merge entities (redirect one to another), this is the entity fatcat identifier for the target entity.
-    #[serde(rename = "redirect_ident")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub redirect_ident: Option<String>,
-
-    /// Editgroup identifier that this edit is part of.
-    #[serde(rename = "editgroup_id")]
-    pub editgroup_id: String,
-
-    #[serde(rename = "extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-}
-
-impl EntityEdit {
-    pub fn new(edit_id: String, ident: String, editgroup_id: String) -> EntityEdit {
-        EntityEdit {
-            edit_id: edit_id,
-            ident: ident,
-            revision: None,
-            prev_revision: None,
-            redirect_ident: None,
-            editgroup_id: editgroup_id,
-            extra: None,
-        }
-    }
-}
-
-/// Converts the EntityEdit value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for EntityEdit {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        params.push("edit_id".to_string());
-        params.push(self.edit_id.to_string());
-
-        params.push("ident".to_string());
-        params.push(self.ident.to_string());
-
-        if let Some(ref revision) = self.revision {
-            params.push("revision".to_string());
-            params.push(revision.to_string());
-        }
-
-        if let Some(ref prev_revision) = self.prev_revision {
-            params.push("prev_revision".to_string());
-            params.push(prev_revision.to_string());
-        }
-
-        if let Some(ref redirect_ident) = self.redirect_ident {
-            params.push("redirect_ident".to_string());
-            params.push(redirect_ident.to_string());
-        }
-
-        params.push("editgroup_id".to_string());
-        params.push(self.editgroup_id.to_string());
-
-        // Skipping extra in query parameter serialization
-        // Skipping extra in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a EntityEdit value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for EntityEdit {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub edit_id: Vec<String>,
-            pub ident: Vec<String>,
-            pub revision: Vec<String>,
-            pub prev_revision: Vec<String>,
-            pub redirect_ident: Vec<String>,
-            pub editgroup_id: Vec<String>,
-            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing EntityEdit".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "edit_id" => intermediate_rep
-                        .edit_id
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "ident" => intermediate_rep
-                        .ident
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "revision" => intermediate_rep
-                        .revision
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "prev_revision" => intermediate_rep
-                        .prev_revision
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "redirect_ident" => intermediate_rep
-                        .redirect_ident
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "editgroup_id" => intermediate_rep
-                        .editgroup_id
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "extra" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in EntityEdit"
-                                .to_string(),
-                        )
-                    }
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing EntityEdit".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(EntityEdit {
-            edit_id: intermediate_rep
-                .edit_id
-                .into_iter()
-                .next()
-                .ok_or("edit_id missing in EntityEdit".to_string())?,
-            ident: intermediate_rep
-                .ident
-                .into_iter()
-                .next()
-                .ok_or("ident missing in EntityEdit".to_string())?,
-            revision: intermediate_rep.revision.into_iter().next(),
-            prev_revision: intermediate_rep.prev_revision.into_iter().next(),
-            redirect_ident: intermediate_rep.redirect_ident.into_iter().next(),
-            editgroup_id: intermediate_rep
-                .editgroup_id
-                .into_iter()
-                .next()
-                .ok_or("editgroup_id missing in EntityEdit".to_string())?,
-            extra: intermediate_rep.extra.into_iter().next(),
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<EntityHistoryEntry> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<EntityHistoryEntry>>
-    for hyper::header::HeaderValue
-{
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<EntityHistoryEntry>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for EntityHistoryEntry - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue>
-    for header::IntoHeaderValue<EntityHistoryEntry>
-{
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <EntityHistoryEntry as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into EntityHistoryEntry - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct EntityHistoryEntry {
-    #[serde(rename = "edit")]
-    pub edit: models::EntityEdit,
-
-    #[serde(rename = "editgroup")]
-    pub editgroup: models::Editgroup,
-
-    #[serde(rename = "changelog_entry")]
-    pub changelog_entry: models::ChangelogEntry,
-}
-
-impl EntityHistoryEntry {
-    pub fn new(
-        edit: models::EntityEdit,
-        editgroup: models::Editgroup,
-        changelog_entry: models::ChangelogEntry,
-    ) -> EntityHistoryEntry {
-        EntityHistoryEntry {
-            edit: edit,
-            editgroup: editgroup,
-            changelog_entry: changelog_entry,
-        }
-    }
-}
-
-/// Converts the EntityHistoryEntry value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for EntityHistoryEntry {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-        // Skipping edit in query parameter serialization
-
-        // Skipping editgroup in query parameter serialization
-
-        // Skipping changelog_entry in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a EntityHistoryEntry value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for EntityHistoryEntry {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub edit: Vec<models::EntityEdit>,
-            pub editgroup: Vec<models::Editgroup>,
-            pub changelog_entry: Vec<models::ChangelogEntry>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing EntityHistoryEntry".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "edit" => intermediate_rep
-                        .edit
-                        .push(models::EntityEdit::from_str(val).map_err(|x| format!("{}", x))?),
-                    "editgroup" => intermediate_rep
-                        .editgroup
-                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
-                    "changelog_entry" => intermediate_rep
-                        .changelog_entry
-                        .push(models::ChangelogEntry::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing EntityHistoryEntry".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(EntityHistoryEntry {
-            edit: intermediate_rep
-                .edit
-                .into_iter()
-                .next()
-                .ok_or("edit missing in EntityHistoryEntry".to_string())?,
-            editgroup: intermediate_rep
-                .editgroup
-                .into_iter()
-                .next()
-                .ok_or("editgroup missing in EntityHistoryEntry".to_string())?,
-            changelog_entry: intermediate_rep
-                .changelog_entry
-                .into_iter()
-                .next()
-                .ok_or("changelog_entry missing in EntityHistoryEntry".to_string())?,
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<ErrorResponse> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<ErrorResponse>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<ErrorResponse>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for ErrorResponse - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ErrorResponse> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <ErrorResponse as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into ErrorResponse - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct ErrorResponse {
-    #[serde(rename = "success")]
-    pub success: bool,
-
-    #[serde(rename = "error")]
-    pub error: String,
-
-    #[serde(rename = "message")]
-    pub message: String,
-}
-
-impl ErrorResponse {
-    pub fn new(success: bool, error: String, message: String) -> ErrorResponse {
-        ErrorResponse {
-            success: success,
-            error: error,
-            message: message,
-        }
-    }
-}
-
-/// Converts the ErrorResponse value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for ErrorResponse {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        params.push("success".to_string());
-        params.push(self.success.to_string());
-
-        params.push("error".to_string());
-        params.push(self.error.to_string());
-
-        params.push("message".to_string());
-        params.push(self.message.to_string());
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a ErrorResponse value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for ErrorResponse {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub success: Vec<bool>,
-            pub error: Vec<String>,
-            pub message: Vec<String>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing ErrorResponse".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "success" => intermediate_rep
-                        .success
-                        .push(bool::from_str(val).map_err(|x| format!("{}", x))?),
-                    "error" => intermediate_rep
-                        .error
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "message" => intermediate_rep
-                        .message
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing ErrorResponse".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(ErrorResponse {
-            success: intermediate_rep
-                .success
-                .into_iter()
-                .next()
-                .ok_or("success missing in ErrorResponse".to_string())?,
-            error: intermediate_rep
-                .error
-                .into_iter()
-                .next()
-                .ok_or("error missing in ErrorResponse".to_string())?,
-            message: intermediate_rep
-                .message
-                .into_iter()
-                .next()
-                .ok_or("message missing in ErrorResponse".to_string())?,
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<FileAutoBatch> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<FileAutoBatch>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<FileAutoBatch>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for FileAutoBatch - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FileAutoBatch> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <FileAutoBatch as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into FileAutoBatch - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct FileAutoBatch {
-    #[serde(rename = "editgroup")]
-    pub editgroup: models::Editgroup,
-
-    #[serde(rename = "entity_list")]
-    pub entity_list: Vec<models::FileEntity>,
-}
-
-impl FileAutoBatch {
-    pub fn new(
-        editgroup: models::Editgroup,
-        entity_list: Vec<models::FileEntity>,
-    ) -> FileAutoBatch {
-        FileAutoBatch {
-            editgroup: editgroup,
-            entity_list: entity_list,
-        }
-    }
-}
-
-/// Converts the FileAutoBatch value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for FileAutoBatch {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-        // Skipping editgroup in query parameter serialization
-
-        // Skipping entity_list in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a FileAutoBatch value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for FileAutoBatch {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub editgroup: Vec<models::Editgroup>,
-            pub entity_list: Vec<Vec<models::FileEntity>>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing FileAutoBatch".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "editgroup" => intermediate_rep
-                        .editgroup
-                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
-                    "entity_list" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in FileAutoBatch"
-                                .to_string(),
-                        )
-                    }
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing FileAutoBatch".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(FileAutoBatch {
-            editgroup: intermediate_rep
-                .editgroup
-                .into_iter()
-                .next()
-                .ok_or("editgroup missing in FileAutoBatch".to_string())?,
-            entity_list: intermediate_rep
-                .entity_list
-                .into_iter()
-                .next()
-                .ok_or("entity_list missing in FileAutoBatch".to_string())?,
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<FileEntity> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<FileEntity>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<FileEntity>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for FileEntity - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FileEntity> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <FileEntity as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into FileEntity - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct FileEntity {
-    // Note: inline enums are not fully supported by openapi-generator
-    #[serde(rename = "state")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub state: Option<String>,
-
-    /// base32-encoded unique identifier
-    #[serde(rename = "ident")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ident: Option<String>,
-
-    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
-    #[serde(rename = "revision")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub revision: Option<String>,
-
-    /// base32-encoded unique identifier
-    #[serde(rename = "redirect")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub redirect: Option<String>,
-
-    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
-    #[serde(rename = "extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-
-    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
-    #[serde(rename = "edit_extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-
-    /// Size of file in bytes. Non-zero.
-    #[serde(rename = "size")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub size: Option<i64>,
-
-    /// MD5 hash of data, in hex encoding
-    #[serde(rename = "md5")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub md5: Option<String>,
-
-    /// SHA-1 hash of data, in hex encoding
-    #[serde(rename = "sha1")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub sha1: Option<String>,
-
-    /// SHA-256 hash of data, in hex encoding
-    #[serde(rename = "sha256")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub sha256: Option<String>,
-
-    #[serde(rename = "urls")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub urls: Option<Vec<models::FileUrl>>,
-
-    #[serde(rename = "mimetype")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub mimetype: Option<String>,
-
-    /// Set of identifier of release entities this file represents a full manifestation of. Usually a single release, but some files contain content of multiple full releases (eg, an issue of a journal).
-    #[serde(rename = "release_ids")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub release_ids: Option<Vec<String>>,
-
-    /// Full release entities, included in GET responses when `releases` included in `expand` parameter. Ignored if included in PUT or POST requests.
-    #[serde(rename = "releases")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub releases: Option<Vec<models::ReleaseEntity>>,
-}
-
-impl FileEntity {
-    pub fn new() -> FileEntity {
-        FileEntity {
-            state: None,
-            ident: None,
-            revision: None,
-            redirect: None,
-            extra: None,
-            edit_extra: None,
-            size: None,
-            md5: None,
-            sha1: None,
-            sha256: None,
-            urls: None,
-            mimetype: None,
-            release_ids: None,
-            releases: None,
-        }
-    }
-}
-
-/// Converts the FileEntity value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for FileEntity {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        if let Some(ref state) = self.state {
-            params.push("state".to_string());
-            params.push(state.to_string());
-        }
-
-        if let Some(ref ident) = self.ident {
-            params.push("ident".to_string());
-            params.push(ident.to_string());
-        }
-
-        if let Some(ref revision) = self.revision {
-            params.push("revision".to_string());
-            params.push(revision.to_string());
-        }
-
-        if let Some(ref redirect) = self.redirect {
-            params.push("redirect".to_string());
-            params.push(redirect.to_string());
-        }
-
-        // Skipping extra in query parameter serialization
-        // Skipping extra in query parameter serialization
-
-        // Skipping edit_extra in query parameter serialization
-        // Skipping edit_extra in query parameter serialization
-
-        if let Some(ref size) = self.size {
-            params.push("size".to_string());
-            params.push(size.to_string());
-        }
-
-        if let Some(ref md5) = self.md5 {
-            params.push("md5".to_string());
-            params.push(md5.to_string());
-        }
-
-        if let Some(ref sha1) = self.sha1 {
-            params.push("sha1".to_string());
-            params.push(sha1.to_string());
-        }
-
-        if let Some(ref sha256) = self.sha256 {
-            params.push("sha256".to_string());
-            params.push(sha256.to_string());
-        }
-
-        // Skipping urls in query parameter serialization
-
-        if let Some(ref mimetype) = self.mimetype {
-            params.push("mimetype".to_string());
-            params.push(mimetype.to_string());
-        }
-
-        if let Some(ref release_ids) = self.release_ids {
-            params.push("release_ids".to_string());
-            params.push(
-                release_ids
-                    .iter()
-                    .map(|x| x.to_string())
-                    .collect::<Vec<_>>()
-                    .join(",")
-                    .to_string(),
-            );
-        }
-
-        // Skipping releases in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a FileEntity value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for FileEntity {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub state: Vec<String>,
-            pub ident: Vec<String>,
-            pub revision: Vec<String>,
-            pub redirect: Vec<String>,
-            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-            pub size: Vec<i64>,
-            pub md5: Vec<String>,
-            pub sha1: Vec<String>,
-            pub sha256: Vec<String>,
-            pub urls: Vec<Vec<models::FileUrl>>,
-            pub mimetype: Vec<String>,
-            pub release_ids: Vec<Vec<String>>,
-            pub releases: Vec<Vec<models::ReleaseEntity>>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing FileEntity".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "state" => intermediate_rep
-                        .state
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "ident" => intermediate_rep
-                        .ident
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "revision" => intermediate_rep
-                        .revision
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "redirect" => intermediate_rep
-                        .redirect
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "extra" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in FileEntity"
-                                .to_string(),
-                        )
-                    }
-                    "edit_extra" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in FileEntity"
-                                .to_string(),
-                        )
-                    }
-                    "size" => intermediate_rep
-                        .size
-                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
-                    "md5" => intermediate_rep
-                        .md5
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "sha1" => intermediate_rep
-                        .sha1
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "sha256" => intermediate_rep
-                        .sha256
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "urls" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in FileEntity"
-                                .to_string(),
-                        )
-                    }
-                    "mimetype" => intermediate_rep
-                        .mimetype
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "release_ids" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in FileEntity"
-                                .to_string(),
-                        )
-                    }
-                    "releases" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in FileEntity"
-                                .to_string(),
-                        )
-                    }
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing FileEntity".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(FileEntity {
-            state: intermediate_rep.state.into_iter().next(),
-            ident: intermediate_rep.ident.into_iter().next(),
-            revision: intermediate_rep.revision.into_iter().next(),
-            redirect: intermediate_rep.redirect.into_iter().next(),
-            extra: intermediate_rep.extra.into_iter().next(),
-            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
-            size: intermediate_rep.size.into_iter().next(),
-            md5: intermediate_rep.md5.into_iter().next(),
-            sha1: intermediate_rep.sha1.into_iter().next(),
-            sha256: intermediate_rep.sha256.into_iter().next(),
-            urls: intermediate_rep.urls.into_iter().next(),
-            mimetype: intermediate_rep.mimetype.into_iter().next(),
-            release_ids: intermediate_rep.release_ids.into_iter().next(),
-            releases: intermediate_rep.releases.into_iter().next(),
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<FileUrl> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<FileUrl>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<FileUrl>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for FileUrl - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FileUrl> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <FileUrl as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into FileUrl - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct FileUrl {
-    /// URL/URI pointing directly to a machine retrievable copy of this exact file.
-    #[serde(rename = "url")]
-    pub url: String,
-
-    /// Indicates type of host this URL points to. Eg, \"publisher\", \"repository\", \"webarchive\". See guide for list of acceptable values.
-    #[serde(rename = "rel")]
-    pub rel: String,
-}
-
-impl FileUrl {
-    pub fn new(url: String, rel: String) -> FileUrl {
-        FileUrl { url: url, rel: rel }
-    }
-}
-
-/// Converts the FileUrl value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for FileUrl {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        params.push("url".to_string());
-        params.push(self.url.to_string());
-
-        params.push("rel".to_string());
-        params.push(self.rel.to_string());
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a FileUrl value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for FileUrl {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub url: Vec<String>,
-            pub rel: Vec<String>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing FileUrl".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "url" => intermediate_rep
-                        .url
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "rel" => intermediate_rep
-                        .rel
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing FileUrl".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(FileUrl {
-            url: intermediate_rep
-                .url
-                .into_iter()
-                .next()
-                .ok_or("url missing in FileUrl".to_string())?,
-            rel: intermediate_rep
-                .rel
-                .into_iter()
-                .next()
-                .ok_or("rel missing in FileUrl".to_string())?,
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<FilesetAutoBatch> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<FilesetAutoBatch>>
-    for hyper::header::HeaderValue
-{
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<FilesetAutoBatch>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for FilesetAutoBatch - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue>
-    for header::IntoHeaderValue<FilesetAutoBatch>
-{
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <FilesetAutoBatch as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into FilesetAutoBatch - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct FilesetAutoBatch {
-    #[serde(rename = "editgroup")]
-    pub editgroup: models::Editgroup,
-
-    #[serde(rename = "entity_list")]
-    pub entity_list: Vec<models::FilesetEntity>,
-}
-
-impl FilesetAutoBatch {
-    pub fn new(
-        editgroup: models::Editgroup,
-        entity_list: Vec<models::FilesetEntity>,
-    ) -> FilesetAutoBatch {
-        FilesetAutoBatch {
-            editgroup: editgroup,
-            entity_list: entity_list,
-        }
-    }
-}
-
-/// Converts the FilesetAutoBatch value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for FilesetAutoBatch {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-        // Skipping editgroup in query parameter serialization
-
-        // Skipping entity_list in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a FilesetAutoBatch value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for FilesetAutoBatch {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub editgroup: Vec<models::Editgroup>,
-            pub entity_list: Vec<Vec<models::FilesetEntity>>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing FilesetAutoBatch".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "editgroup" => intermediate_rep
-                        .editgroup
-                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
-                    "entity_list" => return std::result::Result::Err(
-                        "Parsing a container in this style is not supported in FilesetAutoBatch"
-                            .to_string(),
-                    ),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing FilesetAutoBatch".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(FilesetAutoBatch {
-            editgroup: intermediate_rep
-                .editgroup
-                .into_iter()
-                .next()
-                .ok_or("editgroup missing in FilesetAutoBatch".to_string())?,
-            entity_list: intermediate_rep
-                .entity_list
-                .into_iter()
-                .next()
-                .ok_or("entity_list missing in FilesetAutoBatch".to_string())?,
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<FilesetEntity> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<FilesetEntity>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<FilesetEntity>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for FilesetEntity - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FilesetEntity> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <FilesetEntity as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into FilesetEntity - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct FilesetEntity {
-    // Note: inline enums are not fully supported by openapi-generator
-    #[serde(rename = "state")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub state: Option<String>,
-
-    /// base32-encoded unique identifier
-    #[serde(rename = "ident")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ident: Option<String>,
-
-    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
-    #[serde(rename = "revision")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub revision: Option<String>,
-
-    /// base32-encoded unique identifier
-    #[serde(rename = "redirect")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub redirect: Option<String>,
-
-    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
-    #[serde(rename = "extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-
-    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
-    #[serde(rename = "edit_extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-
-    #[serde(rename = "manifest")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub manifest: Option<Vec<models::FilesetFile>>,
-
-    #[serde(rename = "urls")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub urls: Option<Vec<models::FilesetUrl>>,
-
-    /// Set of identifier of release entities this fileset represents a full manifestation of. Usually a single release.
-    #[serde(rename = "release_ids")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub release_ids: Option<Vec<String>>,
-
-    /// Full release entities, included in GET responses when `releases` included in `expand` parameter. Ignored if included in PUT or POST requests.
-    #[serde(rename = "releases")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub releases: Option<Vec<models::ReleaseEntity>>,
-}
-
-impl FilesetEntity {
-    pub fn new() -> FilesetEntity {
-        FilesetEntity {
-            state: None,
-            ident: None,
-            revision: None,
-            redirect: None,
-            extra: None,
-            edit_extra: None,
-            manifest: None,
-            urls: None,
-            release_ids: None,
-            releases: None,
-        }
-    }
-}
-
-/// Converts the FilesetEntity value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for FilesetEntity {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        if let Some(ref state) = self.state {
-            params.push("state".to_string());
-            params.push(state.to_string());
-        }
-
-        if let Some(ref ident) = self.ident {
-            params.push("ident".to_string());
-            params.push(ident.to_string());
-        }
-
-        if let Some(ref revision) = self.revision {
-            params.push("revision".to_string());
-            params.push(revision.to_string());
-        }
-
-        if let Some(ref redirect) = self.redirect {
-            params.push("redirect".to_string());
-            params.push(redirect.to_string());
-        }
-
-        // Skipping extra in query parameter serialization
-        // Skipping extra in query parameter serialization
-
-        // Skipping edit_extra in query parameter serialization
-        // Skipping edit_extra in query parameter serialization
-
-        // Skipping manifest in query parameter serialization
-
-        // Skipping urls in query parameter serialization
-
-        if let Some(ref release_ids) = self.release_ids {
-            params.push("release_ids".to_string());
-            params.push(
-                release_ids
-                    .iter()
-                    .map(|x| x.to_string())
-                    .collect::<Vec<_>>()
-                    .join(",")
-                    .to_string(),
-            );
-        }
-
-        // Skipping releases in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a FilesetEntity value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for FilesetEntity {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub state: Vec<String>,
-            pub ident: Vec<String>,
-            pub revision: Vec<String>,
-            pub redirect: Vec<String>,
-            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-            pub manifest: Vec<Vec<models::FilesetFile>>,
-            pub urls: Vec<Vec<models::FilesetUrl>>,
-            pub release_ids: Vec<Vec<String>>,
-            pub releases: Vec<Vec<models::ReleaseEntity>>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing FilesetEntity".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "state" => intermediate_rep
-                        .state
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "ident" => intermediate_rep
-                        .ident
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "revision" => intermediate_rep
-                        .revision
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "redirect" => intermediate_rep
-                        .redirect
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "extra" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in FilesetEntity"
-                                .to_string(),
-                        )
-                    }
-                    "edit_extra" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in FilesetEntity"
-                                .to_string(),
-                        )
-                    }
-                    "manifest" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in FilesetEntity"
-                                .to_string(),
-                        )
-                    }
-                    "urls" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in FilesetEntity"
-                                .to_string(),
-                        )
-                    }
-                    "release_ids" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in FilesetEntity"
-                                .to_string(),
-                        )
-                    }
-                    "releases" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in FilesetEntity"
-                                .to_string(),
-                        )
-                    }
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing FilesetEntity".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(FilesetEntity {
-            state: intermediate_rep.state.into_iter().next(),
-            ident: intermediate_rep.ident.into_iter().next(),
-            revision: intermediate_rep.revision.into_iter().next(),
-            redirect: intermediate_rep.redirect.into_iter().next(),
-            extra: intermediate_rep.extra.into_iter().next(),
-            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
-            manifest: intermediate_rep.manifest.into_iter().next(),
-            urls: intermediate_rep.urls.into_iter().next(),
-            release_ids: intermediate_rep.release_ids.into_iter().next(),
-            releases: intermediate_rep.releases.into_iter().next(),
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<FilesetFile> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<FilesetFile>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<FilesetFile>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for FilesetFile - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FilesetFile> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <FilesetFile as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into FilesetFile - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct FilesetFile {
-    /// Path name of file within this fileset (eg, directory)
-    #[serde(rename = "path")]
-    pub path: String,
-
-    /// File size in bytes
-    #[serde(rename = "size")]
-    pub size: i64,
-
-    /// MD5 hash of data, in hex encoding
-    #[serde(rename = "md5")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub md5: Option<String>,
-
-    /// SHA-1 hash of data, in hex encoding
-    #[serde(rename = "sha1")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub sha1: Option<String>,
-
-    /// SHA-256 hash of data, in hex encoding
-    #[serde(rename = "sha256")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub sha256: Option<String>,
-
-    /// Free-form additional metadata about this specific file in the set. Eg, `mimetype`. See guide for nomative (but unenforced) schema fields.
-    #[serde(rename = "extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-}
-
-impl FilesetFile {
-    pub fn new(path: String, size: i64) -> FilesetFile {
-        FilesetFile {
-            path: path,
-            size: size,
-            md5: None,
-            sha1: None,
-            sha256: None,
-            extra: None,
-        }
-    }
-}
-
-/// Converts the FilesetFile value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for FilesetFile {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        params.push("path".to_string());
-        params.push(self.path.to_string());
-
-        params.push("size".to_string());
-        params.push(self.size.to_string());
-
-        if let Some(ref md5) = self.md5 {
-            params.push("md5".to_string());
-            params.push(md5.to_string());
-        }
-
-        if let Some(ref sha1) = self.sha1 {
-            params.push("sha1".to_string());
-            params.push(sha1.to_string());
-        }
-
-        if let Some(ref sha256) = self.sha256 {
-            params.push("sha256".to_string());
-            params.push(sha256.to_string());
-        }
-
-        // Skipping extra in query parameter serialization
-        // Skipping extra in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a FilesetFile value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for FilesetFile {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub path: Vec<String>,
-            pub size: Vec<i64>,
-            pub md5: Vec<String>,
-            pub sha1: Vec<String>,
-            pub sha256: Vec<String>,
-            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing FilesetFile".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "path" => intermediate_rep
-                        .path
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "size" => intermediate_rep
-                        .size
-                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
-                    "md5" => intermediate_rep
-                        .md5
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "sha1" => intermediate_rep
-                        .sha1
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "sha256" => intermediate_rep
-                        .sha256
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "extra" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in FilesetFile"
-                                .to_string(),
-                        )
-                    }
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing FilesetFile".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(FilesetFile {
-            path: intermediate_rep
-                .path
-                .into_iter()
-                .next()
-                .ok_or("path missing in FilesetFile".to_string())?,
-            size: intermediate_rep
-                .size
-                .into_iter()
-                .next()
-                .ok_or("size missing in FilesetFile".to_string())?,
-            md5: intermediate_rep.md5.into_iter().next(),
-            sha1: intermediate_rep.sha1.into_iter().next(),
-            sha256: intermediate_rep.sha256.into_iter().next(),
-            extra: intermediate_rep.extra.into_iter().next(),
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<FilesetUrl> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<FilesetUrl>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<FilesetUrl>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for FilesetUrl - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FilesetUrl> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <FilesetUrl as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into FilesetUrl - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct FilesetUrl {
-    #[serde(rename = "url")]
-    pub url: String,
-
-    /// Indicates type of host this URL points to. See guide for list of acceptable values.
-    #[serde(rename = "rel")]
-    pub rel: String,
-}
-
-impl FilesetUrl {
-    pub fn new(url: String, rel: String) -> FilesetUrl {
-        FilesetUrl { url: url, rel: rel }
-    }
-}
-
-/// Converts the FilesetUrl value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for FilesetUrl {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        params.push("url".to_string());
-        params.push(self.url.to_string());
-
-        params.push("rel".to_string());
-        params.push(self.rel.to_string());
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a FilesetUrl value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for FilesetUrl {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub url: Vec<String>,
-            pub rel: Vec<String>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing FilesetUrl".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "url" => intermediate_rep
-                        .url
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "rel" => intermediate_rep
-                        .rel
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing FilesetUrl".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(FilesetUrl {
-            url: intermediate_rep
-                .url
-                .into_iter()
-                .next()
-                .ok_or("url missing in FilesetUrl".to_string())?,
-            rel: intermediate_rep
-                .rel
-                .into_iter()
-                .next()
-                .ok_or("rel missing in FilesetUrl".to_string())?,
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<ReleaseAbstract> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseAbstract>>
-    for hyper::header::HeaderValue
-{
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<ReleaseAbstract>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for ReleaseAbstract - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue>
-    for header::IntoHeaderValue<ReleaseAbstract>
-{
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <ReleaseAbstract as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into ReleaseAbstract - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct ReleaseAbstract {
-    /// SHA-1 hash of data, in hex encoding
-    #[serde(rename = "sha1")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub sha1: Option<String>,
-
-    /// Abstract content. May be encoded, as per `mimetype` field, but only string/text content may be included.
-    #[serde(rename = "content")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub content: Option<String>,
-
-    /// Mimetype of abstract contents. `text/plain` is the default if content isn't encoded.
-    #[serde(rename = "mimetype")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub mimetype: Option<String>,
-
-    /// ISO language code of the abstract. Same semantics as release `language` field.
-    #[serde(rename = "lang")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub lang: Option<String>,
-}
-
-impl ReleaseAbstract {
-    pub fn new() -> ReleaseAbstract {
-        ReleaseAbstract {
-            sha1: None,
-            content: None,
-            mimetype: None,
-            lang: None,
-        }
-    }
-}
-
-/// Converts the ReleaseAbstract value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for ReleaseAbstract {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        if let Some(ref sha1) = self.sha1 {
-            params.push("sha1".to_string());
-            params.push(sha1.to_string());
-        }
-
-        if let Some(ref content) = self.content {
-            params.push("content".to_string());
-            params.push(content.to_string());
-        }
-
-        if let Some(ref mimetype) = self.mimetype {
-            params.push("mimetype".to_string());
-            params.push(mimetype.to_string());
-        }
-
-        if let Some(ref lang) = self.lang {
-            params.push("lang".to_string());
-            params.push(lang.to_string());
-        }
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseAbstract value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for ReleaseAbstract {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub sha1: Vec<String>,
-            pub content: Vec<String>,
-            pub mimetype: Vec<String>,
-            pub lang: Vec<String>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing ReleaseAbstract".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "sha1" => intermediate_rep
-                        .sha1
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "content" => intermediate_rep
-                        .content
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "mimetype" => intermediate_rep
-                        .mimetype
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "lang" => intermediate_rep
-                        .lang
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing ReleaseAbstract".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(ReleaseAbstract {
-            sha1: intermediate_rep.sha1.into_iter().next(),
-            content: intermediate_rep.content.into_iter().next(),
-            mimetype: intermediate_rep.mimetype.into_iter().next(),
-            lang: intermediate_rep.lang.into_iter().next(),
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<ReleaseAutoBatch> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseAutoBatch>>
-    for hyper::header::HeaderValue
-{
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<ReleaseAutoBatch>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for ReleaseAutoBatch - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue>
-    for header::IntoHeaderValue<ReleaseAutoBatch>
-{
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <ReleaseAutoBatch as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into ReleaseAutoBatch - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct ReleaseAutoBatch {
-    #[serde(rename = "editgroup")]
-    pub editgroup: models::Editgroup,
-
-    #[serde(rename = "entity_list")]
-    pub entity_list: Vec<models::ReleaseEntity>,
-}
-
-impl ReleaseAutoBatch {
-    pub fn new(
-        editgroup: models::Editgroup,
-        entity_list: Vec<models::ReleaseEntity>,
-    ) -> ReleaseAutoBatch {
-        ReleaseAutoBatch {
-            editgroup: editgroup,
-            entity_list: entity_list,
-        }
-    }
-}
-
-/// Converts the ReleaseAutoBatch value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for ReleaseAutoBatch {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-        // Skipping editgroup in query parameter serialization
-
-        // Skipping entity_list in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseAutoBatch value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for ReleaseAutoBatch {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub editgroup: Vec<models::Editgroup>,
-            pub entity_list: Vec<Vec<models::ReleaseEntity>>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing ReleaseAutoBatch".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "editgroup" => intermediate_rep
-                        .editgroup
-                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
-                    "entity_list" => return std::result::Result::Err(
-                        "Parsing a container in this style is not supported in ReleaseAutoBatch"
-                            .to_string(),
-                    ),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing ReleaseAutoBatch".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(ReleaseAutoBatch {
-            editgroup: intermediate_rep
-                .editgroup
-                .into_iter()
-                .next()
-                .ok_or("editgroup missing in ReleaseAutoBatch".to_string())?,
-            entity_list: intermediate_rep
-                .entity_list
-                .into_iter()
-                .next()
-                .ok_or("entity_list missing in ReleaseAutoBatch".to_string())?,
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<ReleaseContrib> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseContrib>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<ReleaseContrib>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for ReleaseContrib - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseContrib> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <ReleaseContrib as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into ReleaseContrib - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct ReleaseContrib {
-    /// Internally assigned zero-indexed sequence number of contribution. Authors should come first; this encodes the order of attriubtion.
-    #[serde(rename = "index")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub index: Option<i64>,
-
-    /// If known, indicates the creator entity this contribution was made by.
-    #[serde(rename = "creator_id")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub creator_id: Option<String>,
-
-    #[serde(rename = "creator")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub creator: Option<models::CreatorEntity>,
-
-    /// Full name of the contributor as typeset in the release.
-    #[serde(rename = "raw_name")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub raw_name: Option<String>,
-
-    /// In English commonly the first name, but ordering is context and culture specific.
-    #[serde(rename = "given_name")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub given_name: Option<String>,
-
-    /// In English commonly the last, or family name, but ordering is context and culture specific.
-    #[serde(rename = "surname")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub surname: Option<String>,
-
-    /// Short string (slug) indicating type of contribution (eg, \"author\", \"translator\"). See guide for list of accpeted values.
-    #[serde(rename = "role")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub role: Option<String>,
-
-    /// Raw affiliation string as displayed in text
-    #[serde(rename = "raw_affiliation")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub raw_affiliation: Option<String>,
-
-    /// Additional free-form JSON metadata about this contributor/contribution. See guide for normative schema.
-    #[serde(rename = "extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-}
-
-impl ReleaseContrib {
-    pub fn new() -> ReleaseContrib {
-        ReleaseContrib {
-            index: None,
-            creator_id: None,
-            creator: None,
-            raw_name: None,
-            given_name: None,
-            surname: None,
-            role: None,
-            raw_affiliation: None,
-            extra: None,
-        }
-    }
-}
-
-/// Converts the ReleaseContrib value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for ReleaseContrib {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        if let Some(ref index) = self.index {
-            params.push("index".to_string());
-            params.push(index.to_string());
-        }
-
-        if let Some(ref creator_id) = self.creator_id {
-            params.push("creator_id".to_string());
-            params.push(creator_id.to_string());
-        }
-
-        // Skipping creator in query parameter serialization
-
-        if let Some(ref raw_name) = self.raw_name {
-            params.push("raw_name".to_string());
-            params.push(raw_name.to_string());
-        }
-
-        if let Some(ref given_name) = self.given_name {
-            params.push("given_name".to_string());
-            params.push(given_name.to_string());
-        }
-
-        if let Some(ref surname) = self.surname {
-            params.push("surname".to_string());
-            params.push(surname.to_string());
-        }
-
-        if let Some(ref role) = self.role {
-            params.push("role".to_string());
-            params.push(role.to_string());
-        }
-
-        if let Some(ref raw_affiliation) = self.raw_affiliation {
-            params.push("raw_affiliation".to_string());
-            params.push(raw_affiliation.to_string());
-        }
-
-        // Skipping extra in query parameter serialization
-        // Skipping extra in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseContrib value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for ReleaseContrib {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub index: Vec<i64>,
-            pub creator_id: Vec<String>,
-            pub creator: Vec<models::CreatorEntity>,
-            pub raw_name: Vec<String>,
-            pub given_name: Vec<String>,
-            pub surname: Vec<String>,
-            pub role: Vec<String>,
-            pub raw_affiliation: Vec<String>,
-            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing ReleaseContrib".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "index" => intermediate_rep
-                        .index
-                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
-                    "creator_id" => intermediate_rep
-                        .creator_id
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "creator" => intermediate_rep
-                        .creator
-                        .push(models::CreatorEntity::from_str(val).map_err(|x| format!("{}", x))?),
-                    "raw_name" => intermediate_rep
-                        .raw_name
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "given_name" => intermediate_rep
-                        .given_name
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "surname" => intermediate_rep
-                        .surname
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "role" => intermediate_rep
-                        .role
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "raw_affiliation" => intermediate_rep
-                        .raw_affiliation
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "extra" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in ReleaseContrib"
-                                .to_string(),
-                        )
-                    }
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing ReleaseContrib".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(ReleaseContrib {
-            index: intermediate_rep.index.into_iter().next(),
-            creator_id: intermediate_rep.creator_id.into_iter().next(),
-            creator: intermediate_rep.creator.into_iter().next(),
-            raw_name: intermediate_rep.raw_name.into_iter().next(),
-            given_name: intermediate_rep.given_name.into_iter().next(),
-            surname: intermediate_rep.surname.into_iter().next(),
-            role: intermediate_rep.role.into_iter().next(),
-            raw_affiliation: intermediate_rep.raw_affiliation.into_iter().next(),
-            extra: intermediate_rep.extra.into_iter().next(),
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<ReleaseEntity> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseEntity>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<ReleaseEntity>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for ReleaseEntity - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseEntity> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <ReleaseEntity as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into ReleaseEntity - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct ReleaseEntity {
-    // Note: inline enums are not fully supported by openapi-generator
-    #[serde(rename = "state")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub state: Option<String>,
-
-    /// base32-encoded unique identifier
-    #[serde(rename = "ident")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ident: Option<String>,
-
-    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
-    #[serde(rename = "revision")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub revision: Option<String>,
-
-    /// base32-encoded unique identifier
-    #[serde(rename = "redirect")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub redirect: Option<String>,
-
-    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
-    #[serde(rename = "extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-
-    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
-    #[serde(rename = "edit_extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-
-    /// Required for valid entities. The title used in citations and for display. Sometimes the English translation of title e even if release content is not English.
-    #[serde(rename = "title")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub title: Option<String>,
-
-    /// Subtitle of release. In many cases, better to merge with title than include as separate field (unless combined title would be very long). See guide for details.
-    #[serde(rename = "subtitle")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub subtitle: Option<String>,
-
-    /// Title in original language if `title` field has been translated. See guide for details.
-    #[serde(rename = "original_title")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub original_title: Option<String>,
-
-    /// Identifier of work this release is part of. In creation (POST) requests, a work entity will be created automatically if this field is not set.
-    #[serde(rename = "work_id")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub work_id: Option<String>,
-
-    #[serde(rename = "container")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub container: Option<models::ContainerEntity>,
-
-    /// Complete file entities identified by `file_ids` field. Only included in GET responses when `files` included in `expand` parameter; ignored in PUT or POST requests.
-    #[serde(rename = "files")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub files: Option<Vec<models::FileEntity>>,
-
-    /// Complete file entities identified by `filesets_ids` field. Only included in GET responses when `filesets` included in `expand` parameter; ignored in PUT or POST requests.
-    #[serde(rename = "filesets")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub filesets: Option<Vec<models::FilesetEntity>>,
-
-    /// Complete webcapture entities identified by `webcapture_ids` field. Only included in GET responses when `webcaptures` included in `expand` parameter; ignored in PUT or POST requests.
-    #[serde(rename = "webcaptures")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub webcaptures: Option<Vec<models::WebcaptureEntity>>,
-
-    /// Used to link this release to a container entity that the release was published as part of.
-    #[serde(rename = "container_id")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub container_id: Option<String>,
-
-    /// \"Type\" or \"medium\" that this release is published as. See guide for valid values.
-    #[serde(rename = "release_type")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub release_type: Option<String>,
-
-    /// The stage of publication of this specific release. See guide for valid values and semantics.
-    #[serde(rename = "release_stage")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub release_stage: Option<String>,
-
-    /// Full date when this release was formally published. ISO format, like `2019-03-05`. See guide for semantics.
-    #[serde(rename = "release_date")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub release_date: Option<chrono::NaiveDate>,
-
-    /// Year when this release was formally published. Must match `release_date` if that field is set; this field exists because sometimes only the year is known.
-    #[serde(rename = "release_year")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub release_year: Option<i64>,
-
-    /// Type of withdrawl or retraction of this release, if applicable. If release has not been withdrawn, should be `null` (aka, not set, not the string \"null\" or an empty string).
-    #[serde(rename = "withdrawn_status")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub withdrawn_status: Option<String>,
-
-    /// Full date when this release was formally withdrawn (if applicable). ISO format, like `release_date`.
-    #[serde(rename = "withdrawn_date")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub withdrawn_date: Option<chrono::NaiveDate>,
-
-    /// Year corresponding with `withdrawn_date` like `release_year`/`release_date`.
-    #[serde(rename = "withdrawn_year")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub withdrawn_year: Option<i64>,
-
-    #[serde(rename = "ext_ids")]
-    pub ext_ids: models::ReleaseExtIds,
-
-    /// Volume number of container that this release was published in. Often corresponds to the \"Nth\" year of publication, but can be any string. See guide.
-    #[serde(rename = "volume")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub volume: Option<String>,
-
-    /// Issue number of volume/container that this release was published in. Sometimes coresponds to a month number in the year, but can be any string. See guide.
-    #[serde(rename = "issue")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub issue: Option<String>,
-
-    /// Either a single page number (\"first page\") or a range of pages separated by a dash (\"-\"). See guide for details.
-    #[serde(rename = "pages")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub pages: Option<String>,
-
-    /// For, eg, technical reports, which are published in series or assigned some other institutional or container-specific identifier.
-    #[serde(rename = "number")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub number: Option<String>,
-
-    /// For, eg, updated technical reports or software packages, where the version string may be the only field disambiguating between releases.
-    #[serde(rename = "version")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub version: Option<String>,
-
-    /// Name, usually English, of the entity or institution responsible for publication of this release. Not necessarily the imprint/brand. See guide.
-    #[serde(rename = "publisher")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub publisher: Option<String>,
-
-    /// Primary language of the content of the full release. Two-letter RFC1766/ISO639-1 language code, with some custom extensions/additions. See guide.
-    #[serde(rename = "language")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub language: Option<String>,
-
-    /// Short string (slug) name of license under which release is openly published (if applicable).
-    #[serde(rename = "license_slug")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub license_slug: Option<String>,
-
-    #[serde(rename = "contribs")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub contribs: Option<Vec<models::ReleaseContrib>>,
-
-    #[serde(rename = "refs")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub refs: Option<Vec<models::ReleaseRef>>,
-
-    #[serde(rename = "abstracts")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub abstracts: Option<Vec<models::ReleaseAbstract>>,
-}
-
-impl ReleaseEntity {
-    pub fn new(ext_ids: models::ReleaseExtIds) -> ReleaseEntity {
-        ReleaseEntity {
-            state: None,
-            ident: None,
-            revision: None,
-            redirect: None,
-            extra: None,
-            edit_extra: None,
-            title: None,
-            subtitle: None,
-            original_title: None,
-            work_id: None,
-            container: None,
-            files: None,
-            filesets: None,
-            webcaptures: None,
-            container_id: None,
-            release_type: None,
-            release_stage: None,
-            release_date: None,
-            release_year: None,
-            withdrawn_status: None,
-            withdrawn_date: None,
-            withdrawn_year: None,
-            ext_ids: ext_ids,
-            volume: None,
-            issue: None,
-            pages: None,
-            number: None,
-            version: None,
-            publisher: None,
-            language: None,
-            license_slug: None,
-            contribs: None,
-            refs: None,
-            abstracts: None,
-        }
-    }
-}
-
-/// Converts the ReleaseEntity value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for ReleaseEntity {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        if let Some(ref state) = self.state {
-            params.push("state".to_string());
-            params.push(state.to_string());
-        }
-
-        if let Some(ref ident) = self.ident {
-            params.push("ident".to_string());
-            params.push(ident.to_string());
-        }
-
-        if let Some(ref revision) = self.revision {
-            params.push("revision".to_string());
-            params.push(revision.to_string());
-        }
-
-        if let Some(ref redirect) = self.redirect {
-            params.push("redirect".to_string());
-            params.push(redirect.to_string());
-        }
-
-        // Skipping extra in query parameter serialization
-        // Skipping extra in query parameter serialization
-
-        // Skipping edit_extra in query parameter serialization
-        // Skipping edit_extra in query parameter serialization
-
-        if let Some(ref title) = self.title {
-            params.push("title".to_string());
-            params.push(title.to_string());
-        }
-
-        if let Some(ref subtitle) = self.subtitle {
-            params.push("subtitle".to_string());
-            params.push(subtitle.to_string());
-        }
-
-        if let Some(ref original_title) = self.original_title {
-            params.push("original_title".to_string());
-            params.push(original_title.to_string());
-        }
-
-        if let Some(ref work_id) = self.work_id {
-            params.push("work_id".to_string());
-            params.push(work_id.to_string());
-        }
-
-        // Skipping container in query parameter serialization
-
-        // Skipping files in query parameter serialization
-
-        // Skipping filesets in query parameter serialization
-
-        // Skipping webcaptures in query parameter serialization
-
-        if let Some(ref container_id) = self.container_id {
-            params.push("container_id".to_string());
-            params.push(container_id.to_string());
-        }
-
-        if let Some(ref release_type) = self.release_type {
-            params.push("release_type".to_string());
-            params.push(release_type.to_string());
-        }
-
-        if let Some(ref release_stage) = self.release_stage {
-            params.push("release_stage".to_string());
-            params.push(release_stage.to_string());
-        }
-
-        // Skipping release_date in query parameter serialization
-
-        if let Some(ref release_year) = self.release_year {
-            params.push("release_year".to_string());
-            params.push(release_year.to_string());
-        }
-
-        if let Some(ref withdrawn_status) = self.withdrawn_status {
-            params.push("withdrawn_status".to_string());
-            params.push(withdrawn_status.to_string());
-        }
-
-        // Skipping withdrawn_date in query parameter serialization
-
-        if let Some(ref withdrawn_year) = self.withdrawn_year {
-            params.push("withdrawn_year".to_string());
-            params.push(withdrawn_year.to_string());
-        }
-
-        // Skipping ext_ids in query parameter serialization
-
-        if let Some(ref volume) = self.volume {
-            params.push("volume".to_string());
-            params.push(volume.to_string());
-        }
-
-        if let Some(ref issue) = self.issue {
-            params.push("issue".to_string());
-            params.push(issue.to_string());
-        }
-
-        if let Some(ref pages) = self.pages {
-            params.push("pages".to_string());
-            params.push(pages.to_string());
-        }
-
-        if let Some(ref number) = self.number {
-            params.push("number".to_string());
-            params.push(number.to_string());
-        }
-
-        if let Some(ref version) = self.version {
-            params.push("version".to_string());
-            params.push(version.to_string());
-        }
-
-        if let Some(ref publisher) = self.publisher {
-            params.push("publisher".to_string());
-            params.push(publisher.to_string());
-        }
-
-        if let Some(ref language) = self.language {
-            params.push("language".to_string());
-            params.push(language.to_string());
-        }
-
-        if let Some(ref license_slug) = self.license_slug {
-            params.push("license_slug".to_string());
-            params.push(license_slug.to_string());
-        }
-
-        // Skipping contribs in query parameter serialization
-
-        // Skipping refs in query parameter serialization
-
-        // Skipping abstracts in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseEntity value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for ReleaseEntity {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub state: Vec<String>,
-            pub ident: Vec<String>,
-            pub revision: Vec<String>,
-            pub redirect: Vec<String>,
-            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-            pub title: Vec<String>,
-            pub subtitle: Vec<String>,
-            pub original_title: Vec<String>,
-            pub work_id: Vec<String>,
-            pub container: Vec<models::ContainerEntity>,
-            pub files: Vec<Vec<models::FileEntity>>,
-            pub filesets: Vec<Vec<models::FilesetEntity>>,
-            pub webcaptures: Vec<Vec<models::WebcaptureEntity>>,
-            pub container_id: Vec<String>,
-            pub release_type: Vec<String>,
-            pub release_stage: Vec<String>,
-            pub release_date: Vec<chrono::NaiveDate>,
-            pub release_year: Vec<i64>,
-            pub withdrawn_status: Vec<String>,
-            pub withdrawn_date: Vec<chrono::NaiveDate>,
-            pub withdrawn_year: Vec<i64>,
-            pub ext_ids: Vec<models::ReleaseExtIds>,
-            pub volume: Vec<String>,
-            pub issue: Vec<String>,
-            pub pages: Vec<String>,
-            pub number: Vec<String>,
-            pub version: Vec<String>,
-            pub publisher: Vec<String>,
-            pub language: Vec<String>,
-            pub license_slug: Vec<String>,
-            pub contribs: Vec<Vec<models::ReleaseContrib>>,
-            pub refs: Vec<Vec<models::ReleaseRef>>,
-            pub abstracts: Vec<Vec<models::ReleaseAbstract>>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing ReleaseEntity".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "state" => intermediate_rep
-                        .state
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "ident" => intermediate_rep
-                        .ident
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "revision" => intermediate_rep
-                        .revision
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "redirect" => intermediate_rep
-                        .redirect
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "extra" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in ReleaseEntity"
-                                .to_string(),
-                        )
-                    }
-                    "edit_extra" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in ReleaseEntity"
-                                .to_string(),
-                        )
-                    }
-                    "title" => intermediate_rep
-                        .title
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "subtitle" => intermediate_rep
-                        .subtitle
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "original_title" => intermediate_rep
-                        .original_title
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "work_id" => intermediate_rep
-                        .work_id
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "container" => intermediate_rep.container.push(
-                        models::ContainerEntity::from_str(val).map_err(|x| format!("{}", x))?,
-                    ),
-                    "files" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in ReleaseEntity"
-                                .to_string(),
-                        )
-                    }
-                    "filesets" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in ReleaseEntity"
-                                .to_string(),
-                        )
-                    }
-                    "webcaptures" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in ReleaseEntity"
-                                .to_string(),
-                        )
-                    }
-                    "container_id" => intermediate_rep
-                        .container_id
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "release_type" => intermediate_rep
-                        .release_type
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "release_stage" => intermediate_rep
-                        .release_stage
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "release_date" => intermediate_rep
-                        .release_date
-                        .push(chrono::NaiveDate::from_str(val).map_err(|x| format!("{}", x))?),
-                    "release_year" => intermediate_rep
-                        .release_year
-                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
-                    "withdrawn_status" => intermediate_rep
-                        .withdrawn_status
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "withdrawn_date" => intermediate_rep
-                        .withdrawn_date
-                        .push(chrono::NaiveDate::from_str(val).map_err(|x| format!("{}", x))?),
-                    "withdrawn_year" => intermediate_rep
-                        .withdrawn_year
-                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
-                    "ext_ids" => intermediate_rep
-                        .ext_ids
-                        .push(models::ReleaseExtIds::from_str(val).map_err(|x| format!("{}", x))?),
-                    "volume" => intermediate_rep
-                        .volume
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "issue" => intermediate_rep
-                        .issue
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "pages" => intermediate_rep
-                        .pages
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "number" => intermediate_rep
-                        .number
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "version" => intermediate_rep
-                        .version
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "publisher" => intermediate_rep
-                        .publisher
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "language" => intermediate_rep
-                        .language
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "license_slug" => intermediate_rep
-                        .license_slug
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "contribs" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in ReleaseEntity"
-                                .to_string(),
-                        )
-                    }
-                    "refs" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in ReleaseEntity"
-                                .to_string(),
-                        )
-                    }
-                    "abstracts" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in ReleaseEntity"
-                                .to_string(),
-                        )
-                    }
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing ReleaseEntity".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(ReleaseEntity {
-            state: intermediate_rep.state.into_iter().next(),
-            ident: intermediate_rep.ident.into_iter().next(),
-            revision: intermediate_rep.revision.into_iter().next(),
-            redirect: intermediate_rep.redirect.into_iter().next(),
-            extra: intermediate_rep.extra.into_iter().next(),
-            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
-            title: intermediate_rep.title.into_iter().next(),
-            subtitle: intermediate_rep.subtitle.into_iter().next(),
-            original_title: intermediate_rep.original_title.into_iter().next(),
-            work_id: intermediate_rep.work_id.into_iter().next(),
-            container: intermediate_rep.container.into_iter().next(),
-            files: intermediate_rep.files.into_iter().next(),
-            filesets: intermediate_rep.filesets.into_iter().next(),
-            webcaptures: intermediate_rep.webcaptures.into_iter().next(),
-            container_id: intermediate_rep.container_id.into_iter().next(),
-            release_type: intermediate_rep.release_type.into_iter().next(),
-            release_stage: intermediate_rep.release_stage.into_iter().next(),
-            release_date: intermediate_rep.release_date.into_iter().next(),
-            release_year: intermediate_rep.release_year.into_iter().next(),
-            withdrawn_status: intermediate_rep.withdrawn_status.into_iter().next(),
-            withdrawn_date: intermediate_rep.withdrawn_date.into_iter().next(),
-            withdrawn_year: intermediate_rep.withdrawn_year.into_iter().next(),
-            ext_ids: intermediate_rep
-                .ext_ids
-                .into_iter()
-                .next()
-                .ok_or("ext_ids missing in ReleaseEntity".to_string())?,
-            volume: intermediate_rep.volume.into_iter().next(),
-            issue: intermediate_rep.issue.into_iter().next(),
-            pages: intermediate_rep.pages.into_iter().next(),
-            number: intermediate_rep.number.into_iter().next(),
-            version: intermediate_rep.version.into_iter().next(),
-            publisher: intermediate_rep.publisher.into_iter().next(),
-            language: intermediate_rep.language.into_iter().next(),
-            license_slug: intermediate_rep.license_slug.into_iter().next(),
-            contribs: intermediate_rep.contribs.into_iter().next(),
-            refs: intermediate_rep.refs.into_iter().next(),
-            abstracts: intermediate_rep.abstracts.into_iter().next(),
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<ReleaseExtIds> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseExtIds>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<ReleaseExtIds>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for ReleaseExtIds - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseExtIds> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <ReleaseExtIds as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into ReleaseExtIds - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct ReleaseExtIds {
-    /// Digital Object Identifier (DOI), mostly for published papers and datasets. Should be registered and resolvable via https://doi.org/
-    #[serde(rename = "doi")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub doi: Option<String>,
-
-    /// Wikidata entity QID
-    #[serde(rename = "wikidata_qid")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub wikidata_qid: Option<String>,
-
-    /// ISBN-13, for books. Usually not set for chapters. ISBN-10 should be converted to ISBN-13.
-    #[serde(rename = "isbn13")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub isbn13: Option<String>,
-
-    /// PubMed Identifier
-    #[serde(rename = "pmid")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub pmid: Option<String>,
-
-    /// PubMed Central Identifier
-    #[serde(rename = "pmcid")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub pmcid: Option<String>,
-
-    /// CORE (https://core.ac.uk) identifier
-    #[serde(rename = "core")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub core: Option<String>,
-
-    /// arXiv (https://arxiv.org) identifier; must include version
-    #[serde(rename = "arxiv")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub arxiv: Option<String>,
-
-    /// JSTOR work identifier
-    #[serde(rename = "jstor")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub jstor: Option<String>,
-
-    /// ARK identifier
-    #[serde(rename = "ark")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ark: Option<String>,
-
-    /// Microsoft Academic Graph identifier
-    #[serde(rename = "mag")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub mag: Option<String>,
-
-    /// DOAJ article-level identifier
-    #[serde(rename = "doaj")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub doaj: Option<String>,
-
-    /// dblp (https://dblp.uni-trier.de/) paper identifier; eg for conference proceedings
-    #[serde(rename = "dblp")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub dblp: Option<String>,
-
-    /// OAI-PMH identifier; only used when an OAI-PMH record is the only authoritative metadata (eg, journal OAI-PMH feeds w/o DOIs)
-    #[serde(rename = "oai")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub oai: Option<String>,
-}
-
-impl ReleaseExtIds {
-    pub fn new() -> ReleaseExtIds {
-        ReleaseExtIds {
-            doi: None,
-            wikidata_qid: None,
-            isbn13: None,
-            pmid: None,
-            pmcid: None,
-            core: None,
-            arxiv: None,
-            jstor: None,
-            ark: None,
-            mag: None,
-            doaj: None,
-            dblp: None,
-            oai: None,
-        }
-    }
-}
-
-/// Converts the ReleaseExtIds value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for ReleaseExtIds {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        if let Some(ref doi) = self.doi {
-            params.push("doi".to_string());
-            params.push(doi.to_string());
-        }
-
-        if let Some(ref wikidata_qid) = self.wikidata_qid {
-            params.push("wikidata_qid".to_string());
-            params.push(wikidata_qid.to_string());
-        }
-
-        if let Some(ref isbn13) = self.isbn13 {
-            params.push("isbn13".to_string());
-            params.push(isbn13.to_string());
-        }
-
-        if let Some(ref pmid) = self.pmid {
-            params.push("pmid".to_string());
-            params.push(pmid.to_string());
-        }
-
-        if let Some(ref pmcid) = self.pmcid {
-            params.push("pmcid".to_string());
-            params.push(pmcid.to_string());
-        }
-
-        if let Some(ref core) = self.core {
-            params.push("core".to_string());
-            params.push(core.to_string());
-        }
-
-        if let Some(ref arxiv) = self.arxiv {
-            params.push("arxiv".to_string());
-            params.push(arxiv.to_string());
-        }
-
-        if let Some(ref jstor) = self.jstor {
-            params.push("jstor".to_string());
-            params.push(jstor.to_string());
-        }
-
-        if let Some(ref ark) = self.ark {
-            params.push("ark".to_string());
-            params.push(ark.to_string());
-        }
-
-        if let Some(ref mag) = self.mag {
-            params.push("mag".to_string());
-            params.push(mag.to_string());
-        }
-
-        if let Some(ref doaj) = self.doaj {
-            params.push("doaj".to_string());
-            params.push(doaj.to_string());
-        }
-
-        if let Some(ref dblp) = self.dblp {
-            params.push("dblp".to_string());
-            params.push(dblp.to_string());
-        }
-
-        if let Some(ref oai) = self.oai {
-            params.push("oai".to_string());
-            params.push(oai.to_string());
-        }
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseExtIds value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for ReleaseExtIds {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub doi: Vec<String>,
-            pub wikidata_qid: Vec<String>,
-            pub isbn13: Vec<String>,
-            pub pmid: Vec<String>,
-            pub pmcid: Vec<String>,
-            pub core: Vec<String>,
-            pub arxiv: Vec<String>,
-            pub jstor: Vec<String>,
-            pub ark: Vec<String>,
-            pub mag: Vec<String>,
-            pub doaj: Vec<String>,
-            pub dblp: Vec<String>,
-            pub oai: Vec<String>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing ReleaseExtIds".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "doi" => intermediate_rep
-                        .doi
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "wikidata_qid" => intermediate_rep
-                        .wikidata_qid
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "isbn13" => intermediate_rep
-                        .isbn13
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "pmid" => intermediate_rep
-                        .pmid
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "pmcid" => intermediate_rep
-                        .pmcid
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "core" => intermediate_rep
-                        .core
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "arxiv" => intermediate_rep
-                        .arxiv
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "jstor" => intermediate_rep
-                        .jstor
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "ark" => intermediate_rep
-                        .ark
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "mag" => intermediate_rep
-                        .mag
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "doaj" => intermediate_rep
-                        .doaj
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "dblp" => intermediate_rep
-                        .dblp
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "oai" => intermediate_rep
-                        .oai
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing ReleaseExtIds".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(ReleaseExtIds {
-            doi: intermediate_rep.doi.into_iter().next(),
-            wikidata_qid: intermediate_rep.wikidata_qid.into_iter().next(),
-            isbn13: intermediate_rep.isbn13.into_iter().next(),
-            pmid: intermediate_rep.pmid.into_iter().next(),
-            pmcid: intermediate_rep.pmcid.into_iter().next(),
-            core: intermediate_rep.core.into_iter().next(),
-            arxiv: intermediate_rep.arxiv.into_iter().next(),
-            jstor: intermediate_rep.jstor.into_iter().next(),
-            ark: intermediate_rep.ark.into_iter().next(),
-            mag: intermediate_rep.mag.into_iter().next(),
-            doaj: intermediate_rep.doaj.into_iter().next(),
-            dblp: intermediate_rep.dblp.into_iter().next(),
-            oai: intermediate_rep.oai.into_iter().next(),
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<ReleaseRef> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseRef>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<ReleaseRef>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for ReleaseRef - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseRef> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <ReleaseRef as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into ReleaseRef - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct ReleaseRef {
-    /// Zero-indexed sequence number of this reference in the list of references. Assigned automatically and used internally; don't confuse with `key`.
-    #[serde(rename = "index")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub index: Option<i64>,
-
-    /// Optional, fatcat identifier of release entity that this reference is citing.
-    #[serde(rename = "target_release_id")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub target_release_id: Option<String>,
-
-    /// Additional free-form JSON metadata about this citation. Generally follows Citation Style Language (CSL) JSON schema. See guide for details.
-    #[serde(rename = "extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-
-    /// Short string used to indicate this reference from within the release text; or numbering of references as typeset in the release itself. Optional; don't confuse with `index` field.
-    #[serde(rename = "key")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub key: Option<String>,
-
-    /// Year that the cited work was published in.
-    #[serde(rename = "year")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub year: Option<i64>,
-
-    /// Name of the container (eg, journal) that the citation work was published as part of. May be an acronym or full name.
-    #[serde(rename = "container_name")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub container_name: Option<String>,
-
-    /// Name of the work being cited.
-    #[serde(rename = "title")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub title: Option<String>,
-
-    /// Page number or other indicator of the specific subset of a work being cited. Not to be confused with the first page (or page range) of an entire paper or chapter being cited.
-    #[serde(rename = "locator")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub locator: Option<String>,
-}
-
-impl ReleaseRef {
-    pub fn new() -> ReleaseRef {
-        ReleaseRef {
-            index: None,
-            target_release_id: None,
-            extra: None,
-            key: None,
-            year: None,
-            container_name: None,
-            title: None,
-            locator: None,
-        }
-    }
-}
-
-/// Converts the ReleaseRef value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for ReleaseRef {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        if let Some(ref index) = self.index {
-            params.push("index".to_string());
-            params.push(index.to_string());
-        }
-
-        if let Some(ref target_release_id) = self.target_release_id {
-            params.push("target_release_id".to_string());
-            params.push(target_release_id.to_string());
-        }
-
-        // Skipping extra in query parameter serialization
-        // Skipping extra in query parameter serialization
-
-        if let Some(ref key) = self.key {
-            params.push("key".to_string());
-            params.push(key.to_string());
-        }
-
-        if let Some(ref year) = self.year {
-            params.push("year".to_string());
-            params.push(year.to_string());
-        }
-
-        if let Some(ref container_name) = self.container_name {
-            params.push("container_name".to_string());
-            params.push(container_name.to_string());
-        }
-
-        if let Some(ref title) = self.title {
-            params.push("title".to_string());
-            params.push(title.to_string());
-        }
-
-        if let Some(ref locator) = self.locator {
-            params.push("locator".to_string());
-            params.push(locator.to_string());
-        }
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseRef value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for ReleaseRef {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub index: Vec<i64>,
-            pub target_release_id: Vec<String>,
-            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-            pub key: Vec<String>,
-            pub year: Vec<i64>,
-            pub container_name: Vec<String>,
-            pub title: Vec<String>,
-            pub locator: Vec<String>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing ReleaseRef".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "index" => intermediate_rep
-                        .index
-                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
-                    "target_release_id" => intermediate_rep
-                        .target_release_id
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "extra" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in ReleaseRef"
-                                .to_string(),
-                        )
-                    }
-                    "key" => intermediate_rep
-                        .key
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "year" => intermediate_rep
-                        .year
-                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
-                    "container_name" => intermediate_rep
-                        .container_name
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "title" => intermediate_rep
-                        .title
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "locator" => intermediate_rep
-                        .locator
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing ReleaseRef".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(ReleaseRef {
-            index: intermediate_rep.index.into_iter().next(),
-            target_release_id: intermediate_rep.target_release_id.into_iter().next(),
-            extra: intermediate_rep.extra.into_iter().next(),
-            key: intermediate_rep.key.into_iter().next(),
-            year: intermediate_rep.year.into_iter().next(),
-            container_name: intermediate_rep.container_name.into_iter().next(),
-            title: intermediate_rep.title.into_iter().next(),
-            locator: intermediate_rep.locator.into_iter().next(),
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<Success> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<Success>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<Success>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for Success - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Success> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <Success as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into Success - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct Success {
-    #[serde(rename = "success")]
-    pub success: bool,
-
-    #[serde(rename = "message")]
-    pub message: String,
-}
-
-impl Success {
-    pub fn new(success: bool, message: String) -> Success {
-        Success {
-            success: success,
-            message: message,
-        }
-    }
-}
-
-/// Converts the Success value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for Success {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        params.push("success".to_string());
-        params.push(self.success.to_string());
-
-        params.push("message".to_string());
-        params.push(self.message.to_string());
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a Success value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for Success {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub success: Vec<bool>,
-            pub message: Vec<String>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing Success".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "success" => intermediate_rep
-                        .success
-                        .push(bool::from_str(val).map_err(|x| format!("{}", x))?),
-                    "message" => intermediate_rep
-                        .message
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing Success".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(Success {
-            success: intermediate_rep
-                .success
-                .into_iter()
-                .next()
-                .ok_or("success missing in Success".to_string())?,
-            message: intermediate_rep
-                .message
-                .into_iter()
-                .next()
-                .ok_or("message missing in Success".to_string())?,
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<WebcaptureAutoBatch> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureAutoBatch>>
-    for hyper::header::HeaderValue
-{
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<WebcaptureAutoBatch>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for WebcaptureAutoBatch - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue>
-    for header::IntoHeaderValue<WebcaptureAutoBatch>
-{
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <WebcaptureAutoBatch as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into WebcaptureAutoBatch - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct WebcaptureAutoBatch {
-    #[serde(rename = "editgroup")]
-    pub editgroup: models::Editgroup,
-
-    #[serde(rename = "entity_list")]
-    pub entity_list: Vec<models::WebcaptureEntity>,
-}
-
-impl WebcaptureAutoBatch {
-    pub fn new(
-        editgroup: models::Editgroup,
-        entity_list: Vec<models::WebcaptureEntity>,
-    ) -> WebcaptureAutoBatch {
-        WebcaptureAutoBatch {
-            editgroup: editgroup,
-            entity_list: entity_list,
-        }
-    }
-}
-
-/// Converts the WebcaptureAutoBatch value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for WebcaptureAutoBatch {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-        // Skipping editgroup in query parameter serialization
-
-        // Skipping entity_list in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureAutoBatch value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for WebcaptureAutoBatch {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub editgroup: Vec<models::Editgroup>,
-            pub entity_list: Vec<Vec<models::WebcaptureEntity>>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing WebcaptureAutoBatch".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "editgroup" => intermediate_rep
-                        .editgroup
-                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
-                    "entity_list" => return std::result::Result::Err(
-                        "Parsing a container in this style is not supported in WebcaptureAutoBatch"
-                            .to_string(),
-                    ),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing WebcaptureAutoBatch".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(WebcaptureAutoBatch {
-            editgroup: intermediate_rep
-                .editgroup
-                .into_iter()
-                .next()
-                .ok_or("editgroup missing in WebcaptureAutoBatch".to_string())?,
-            entity_list: intermediate_rep
-                .entity_list
-                .into_iter()
-                .next()
-                .ok_or("entity_list missing in WebcaptureAutoBatch".to_string())?,
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<WebcaptureCdxLine> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureCdxLine>>
-    for hyper::header::HeaderValue
-{
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<WebcaptureCdxLine>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for WebcaptureCdxLine - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue>
-    for header::IntoHeaderValue<WebcaptureCdxLine>
-{
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <WebcaptureCdxLine as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into WebcaptureCdxLine - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct WebcaptureCdxLine {
-    /// \"Sortable URL\" format. See guide for details.
-    #[serde(rename = "surt")]
-    pub surt: String,
-
-    /// Date and time of capture, in ISO format. UTC, 'Z'-terminated, second (or better) precision.
-    #[serde(rename = "timestamp")]
-    pub timestamp: chrono::DateTime<chrono::Utc>,
-
-    /// Full URL/URI of resource captured.
-    #[serde(rename = "url")]
-    pub url: String,
-
-    /// Mimetype of the resource at this URL. May be the Content-Type header, or the actually sniffed file type.
-    #[serde(rename = "mimetype")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub mimetype: Option<String>,
-
-    /// HTTP status code. Should generally be 200, especially for the primary resource, but may be 3xx (redirect) or even error codes if embedded resources can not be fetched successfully.
-    #[serde(rename = "status_code")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub status_code: Option<i64>,
-
-    /// Resource (file) size in bytes
-    #[serde(rename = "size")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub size: Option<i64>,
-
-    /// SHA-1 hash of data, in hex encoding
-    #[serde(rename = "sha1")]
-    pub sha1: String,
-
-    /// SHA-256 hash of data, in hex encoding
-    #[serde(rename = "sha256")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub sha256: Option<String>,
-}
-
-impl WebcaptureCdxLine {
-    pub fn new(
-        surt: String,
-        timestamp: chrono::DateTime<chrono::Utc>,
-        url: String,
-        sha1: String,
-    ) -> WebcaptureCdxLine {
-        WebcaptureCdxLine {
-            surt: surt,
-            timestamp: timestamp,
-            url: url,
-            mimetype: None,
-            status_code: None,
-            size: None,
-            sha1: sha1,
-            sha256: None,
-        }
-    }
-}
-
-/// Converts the WebcaptureCdxLine value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for WebcaptureCdxLine {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        params.push("surt".to_string());
-        params.push(self.surt.to_string());
-
-        // Skipping timestamp in query parameter serialization
-
-        params.push("url".to_string());
-        params.push(self.url.to_string());
-
-        if let Some(ref mimetype) = self.mimetype {
-            params.push("mimetype".to_string());
-            params.push(mimetype.to_string());
-        }
-
-        if let Some(ref status_code) = self.status_code {
-            params.push("status_code".to_string());
-            params.push(status_code.to_string());
-        }
-
-        if let Some(ref size) = self.size {
-            params.push("size".to_string());
-            params.push(size.to_string());
-        }
-
-        params.push("sha1".to_string());
-        params.push(self.sha1.to_string());
-
-        if let Some(ref sha256) = self.sha256 {
-            params.push("sha256".to_string());
-            params.push(sha256.to_string());
-        }
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureCdxLine value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for WebcaptureCdxLine {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub surt: Vec<String>,
-            pub timestamp: Vec<chrono::DateTime<chrono::Utc>>,
-            pub url: Vec<String>,
-            pub mimetype: Vec<String>,
-            pub status_code: Vec<i64>,
-            pub size: Vec<i64>,
-            pub sha1: Vec<String>,
-            pub sha256: Vec<String>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing WebcaptureCdxLine".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "surt" => intermediate_rep
-                        .surt
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "timestamp" => intermediate_rep.timestamp.push(
-                        chrono::DateTime::<chrono::Utc>::from_str(val)
-                            .map_err(|x| format!("{}", x))?,
-                    ),
-                    "url" => intermediate_rep
-                        .url
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "mimetype" => intermediate_rep
-                        .mimetype
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "status_code" => intermediate_rep
-                        .status_code
-                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
-                    "size" => intermediate_rep
-                        .size
-                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
-                    "sha1" => intermediate_rep
-                        .sha1
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "sha256" => intermediate_rep
-                        .sha256
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing WebcaptureCdxLine".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(WebcaptureCdxLine {
-            surt: intermediate_rep
-                .surt
-                .into_iter()
-                .next()
-                .ok_or("surt missing in WebcaptureCdxLine".to_string())?,
-            timestamp: intermediate_rep
-                .timestamp
-                .into_iter()
-                .next()
-                .ok_or("timestamp missing in WebcaptureCdxLine".to_string())?,
-            url: intermediate_rep
-                .url
-                .into_iter()
-                .next()
-                .ok_or("url missing in WebcaptureCdxLine".to_string())?,
-            mimetype: intermediate_rep.mimetype.into_iter().next(),
-            status_code: intermediate_rep.status_code.into_iter().next(),
-            size: intermediate_rep.size.into_iter().next(),
-            sha1: intermediate_rep
-                .sha1
-                .into_iter()
-                .next()
-                .ok_or("sha1 missing in WebcaptureCdxLine".to_string())?,
-            sha256: intermediate_rep.sha256.into_iter().next(),
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<WebcaptureEntity> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureEntity>>
-    for hyper::header::HeaderValue
-{
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<WebcaptureEntity>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for WebcaptureEntity - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue>
-    for header::IntoHeaderValue<WebcaptureEntity>
-{
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <WebcaptureEntity as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into WebcaptureEntity - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct WebcaptureEntity {
-    // Note: inline enums are not fully supported by openapi-generator
-    #[serde(rename = "state")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub state: Option<String>,
-
-    /// base32-encoded unique identifier
-    #[serde(rename = "ident")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ident: Option<String>,
-
-    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
-    #[serde(rename = "revision")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub revision: Option<String>,
-
-    /// base32-encoded unique identifier
-    #[serde(rename = "redirect")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub redirect: Option<String>,
-
-    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
-    #[serde(rename = "extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-
-    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
-    #[serde(rename = "edit_extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-
-    #[serde(rename = "cdx")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cdx: Option<Vec<models::WebcaptureCdxLine>>,
-
-    #[serde(rename = "archive_urls")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub archive_urls: Option<Vec<models::WebcaptureUrl>>,
-
-    /// Base URL of the primary resource this is a capture of
-    #[serde(rename = "original_url")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub original_url: Option<String>,
-
-    /// Same format as CDX line timestamp (UTC, etc). Corresponds to the overall capture timestamp. Should generally be the timestamp of capture of the primary resource URL.
-    #[serde(rename = "timestamp")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub timestamp: Option<chrono::DateTime<chrono::Utc>>,
-
-    /// Set of identifier of release entities this fileset represents a full manifestation of. Usually a single release.
-    #[serde(rename = "release_ids")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub release_ids: Option<Vec<String>>,
-
-    /// Full release entities, included in GET responses when `releases` included in `expand` parameter. Ignored if included in PUT or POST requests.
-    #[serde(rename = "releases")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub releases: Option<Vec<models::ReleaseEntity>>,
-}
-
-impl WebcaptureEntity {
-    pub fn new() -> WebcaptureEntity {
-        WebcaptureEntity {
-            state: None,
-            ident: None,
-            revision: None,
-            redirect: None,
-            extra: None,
-            edit_extra: None,
-            cdx: None,
-            archive_urls: None,
-            original_url: None,
-            timestamp: None,
-            release_ids: None,
-            releases: None,
-        }
-    }
-}
-
-/// Converts the WebcaptureEntity value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for WebcaptureEntity {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        if let Some(ref state) = self.state {
-            params.push("state".to_string());
-            params.push(state.to_string());
-        }
-
-        if let Some(ref ident) = self.ident {
-            params.push("ident".to_string());
-            params.push(ident.to_string());
-        }
-
-        if let Some(ref revision) = self.revision {
-            params.push("revision".to_string());
-            params.push(revision.to_string());
-        }
-
-        if let Some(ref redirect) = self.redirect {
-            params.push("redirect".to_string());
-            params.push(redirect.to_string());
-        }
-
-        // Skipping extra in query parameter serialization
-        // Skipping extra in query parameter serialization
-
-        // Skipping edit_extra in query parameter serialization
-        // Skipping edit_extra in query parameter serialization
-
-        // Skipping cdx in query parameter serialization
-
-        // Skipping archive_urls in query parameter serialization
-
-        if let Some(ref original_url) = self.original_url {
-            params.push("original_url".to_string());
-            params.push(original_url.to_string());
-        }
-
-        // Skipping timestamp in query parameter serialization
-
-        if let Some(ref release_ids) = self.release_ids {
-            params.push("release_ids".to_string());
-            params.push(
-                release_ids
-                    .iter()
-                    .map(|x| x.to_string())
-                    .collect::<Vec<_>>()
-                    .join(",")
-                    .to_string(),
-            );
-        }
-
-        // Skipping releases in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureEntity value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for WebcaptureEntity {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub state: Vec<String>,
-            pub ident: Vec<String>,
-            pub revision: Vec<String>,
-            pub redirect: Vec<String>,
-            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-            pub cdx: Vec<Vec<models::WebcaptureCdxLine>>,
-            pub archive_urls: Vec<Vec<models::WebcaptureUrl>>,
-            pub original_url: Vec<String>,
-            pub timestamp: Vec<chrono::DateTime<chrono::Utc>>,
-            pub release_ids: Vec<Vec<String>>,
-            pub releases: Vec<Vec<models::ReleaseEntity>>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing WebcaptureEntity".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "state" => intermediate_rep
-                        .state
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "ident" => intermediate_rep
-                        .ident
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "revision" => intermediate_rep
-                        .revision
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "redirect" => intermediate_rep
-                        .redirect
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "extra" => return std::result::Result::Err(
-                        "Parsing a container in this style is not supported in WebcaptureEntity"
-                            .to_string(),
-                    ),
-                    "edit_extra" => return std::result::Result::Err(
-                        "Parsing a container in this style is not supported in WebcaptureEntity"
-                            .to_string(),
-                    ),
-                    "cdx" => return std::result::Result::Err(
-                        "Parsing a container in this style is not supported in WebcaptureEntity"
-                            .to_string(),
-                    ),
-                    "archive_urls" => return std::result::Result::Err(
-                        "Parsing a container in this style is not supported in WebcaptureEntity"
-                            .to_string(),
-                    ),
-                    "original_url" => intermediate_rep
-                        .original_url
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "timestamp" => intermediate_rep.timestamp.push(
-                        chrono::DateTime::<chrono::Utc>::from_str(val)
-                            .map_err(|x| format!("{}", x))?,
-                    ),
-                    "release_ids" => return std::result::Result::Err(
-                        "Parsing a container in this style is not supported in WebcaptureEntity"
-                            .to_string(),
-                    ),
-                    "releases" => return std::result::Result::Err(
-                        "Parsing a container in this style is not supported in WebcaptureEntity"
-                            .to_string(),
-                    ),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing WebcaptureEntity".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(WebcaptureEntity {
-            state: intermediate_rep.state.into_iter().next(),
-            ident: intermediate_rep.ident.into_iter().next(),
-            revision: intermediate_rep.revision.into_iter().next(),
-            redirect: intermediate_rep.redirect.into_iter().next(),
-            extra: intermediate_rep.extra.into_iter().next(),
-            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
-            cdx: intermediate_rep.cdx.into_iter().next(),
-            archive_urls: intermediate_rep.archive_urls.into_iter().next(),
-            original_url: intermediate_rep.original_url.into_iter().next(),
-            timestamp: intermediate_rep.timestamp.into_iter().next(),
-            release_ids: intermediate_rep.release_ids.into_iter().next(),
-            releases: intermediate_rep.releases.into_iter().next(),
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<WebcaptureUrl> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureUrl>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<WebcaptureUrl>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for WebcaptureUrl - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WebcaptureUrl> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <WebcaptureUrl as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into WebcaptureUrl - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct WebcaptureUrl {
-    /// URL/URI pointing to archive of this web resource.
-    #[serde(rename = "url")]
-    pub url: String,
-
-    /// Type of archive endpoint. Usually `wayback` (WBM replay of primary resource), or `warc` (direct URL to a WARC file containing all resources of the capture). See guide for full list.
-    #[serde(rename = "rel")]
-    pub rel: String,
-}
-
-impl WebcaptureUrl {
-    pub fn new(url: String, rel: String) -> WebcaptureUrl {
-        WebcaptureUrl { url: url, rel: rel }
-    }
-}
-
-/// Converts the WebcaptureUrl value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for WebcaptureUrl {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        params.push("url".to_string());
-        params.push(self.url.to_string());
-
-        params.push("rel".to_string());
-        params.push(self.rel.to_string());
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureUrl value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for WebcaptureUrl {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub url: Vec<String>,
-            pub rel: Vec<String>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing WebcaptureUrl".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "url" => intermediate_rep
-                        .url
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "rel" => intermediate_rep
-                        .rel
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing WebcaptureUrl".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(WebcaptureUrl {
-            url: intermediate_rep
-                .url
-                .into_iter()
-                .next()
-                .ok_or("url missing in WebcaptureUrl".to_string())?,
-            rel: intermediate_rep
-                .rel
-                .into_iter()
-                .next()
-                .ok_or("rel missing in WebcaptureUrl".to_string())?,
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<WorkAutoBatch> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<WorkAutoBatch>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<WorkAutoBatch>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for WorkAutoBatch - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WorkAutoBatch> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <WorkAutoBatch as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into WorkAutoBatch - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct WorkAutoBatch {
-    #[serde(rename = "editgroup")]
-    pub editgroup: models::Editgroup,
-
-    #[serde(rename = "entity_list")]
-    pub entity_list: Vec<models::WorkEntity>,
-}
-
-impl WorkAutoBatch {
-    pub fn new(
-        editgroup: models::Editgroup,
-        entity_list: Vec<models::WorkEntity>,
-    ) -> WorkAutoBatch {
-        WorkAutoBatch {
-            editgroup: editgroup,
-            entity_list: entity_list,
-        }
-    }
-}
-
-/// Converts the WorkAutoBatch value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for WorkAutoBatch {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-        // Skipping editgroup in query parameter serialization
-
-        // Skipping entity_list in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a WorkAutoBatch value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for WorkAutoBatch {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub editgroup: Vec<models::Editgroup>,
-            pub entity_list: Vec<Vec<models::WorkEntity>>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing WorkAutoBatch".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "editgroup" => intermediate_rep
-                        .editgroup
-                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
-                    "entity_list" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in WorkAutoBatch"
-                                .to_string(),
-                        )
-                    }
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing WorkAutoBatch".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(WorkAutoBatch {
-            editgroup: intermediate_rep
-                .editgroup
-                .into_iter()
-                .next()
-                .ok_or("editgroup missing in WorkAutoBatch".to_string())?,
-            entity_list: intermediate_rep
-                .entity_list
-                .into_iter()
-                .next()
-                .ok_or("entity_list missing in WorkAutoBatch".to_string())?,
-        })
-    }
-}
-
-// Methods for converting between header::IntoHeaderValue<WorkEntity> and hyper::header::HeaderValue
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<header::IntoHeaderValue<WorkEntity>> for hyper::header::HeaderValue {
-    type Error = String;
-
-    fn try_from(
-        hdr_value: header::IntoHeaderValue<WorkEntity>,
-    ) -> std::result::Result<Self, Self::Error> {
-        let hdr_value = hdr_value.to_string();
-        match hyper::header::HeaderValue::from_str(&hdr_value) {
-            std::result::Result::Ok(value) => std::result::Result::Ok(value),
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Invalid header value for WorkEntity - value: {} is invalid {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "client", feature = "server"))]
-impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WorkEntity> {
-    type Error = String;
-
-    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
-        match hdr_value.to_str() {
-            std::result::Result::Ok(value) => {
-                match <WorkEntity as std::str::FromStr>::from_str(value) {
-                    std::result::Result::Ok(value) => {
-                        std::result::Result::Ok(header::IntoHeaderValue(value))
-                    }
-                    std::result::Result::Err(err) => std::result::Result::Err(format!(
-                        "Unable to convert header value '{}' into WorkEntity - {}",
-                        value, err
-                    )),
-                }
-            }
-            std::result::Result::Err(e) => std::result::Result::Err(format!(
-                "Unable to convert header: {:?} to string: {}",
-                hdr_value, e
-            )),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
-pub struct WorkEntity {
-    // Note: inline enums are not fully supported by openapi-generator
-    #[serde(rename = "state")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub state: Option<String>,
-
-    /// base32-encoded unique identifier
-    #[serde(rename = "ident")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ident: Option<String>,
-
-    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
-    #[serde(rename = "revision")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub revision: Option<String>,
-
-    /// base32-encoded unique identifier
-    #[serde(rename = "redirect")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub redirect: Option<String>,
-
-    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
-    #[serde(rename = "extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-
-    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
-    #[serde(rename = "edit_extra")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
-}
-
-impl WorkEntity {
-    pub fn new() -> WorkEntity {
-        WorkEntity {
-            state: None,
-            ident: None,
-            revision: None,
-            redirect: None,
-            extra: None,
-            edit_extra: None,
-        }
-    }
-}
-
-/// Converts the WorkEntity value to the Query Parameters representation (style=form, explode=false)
-/// specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde serializer
-impl std::string::ToString for WorkEntity {
-    fn to_string(&self) -> String {
-        let mut params: Vec<String> = vec![];
-
-        if let Some(ref state) = self.state {
-            params.push("state".to_string());
-            params.push(state.to_string());
-        }
-
-        if let Some(ref ident) = self.ident {
-            params.push("ident".to_string());
-            params.push(ident.to_string());
-        }
-
-        if let Some(ref revision) = self.revision {
-            params.push("revision".to_string());
-            params.push(revision.to_string());
-        }
-
-        if let Some(ref redirect) = self.redirect {
-            params.push("redirect".to_string());
-            params.push(redirect.to_string());
-        }
-
-        // Skipping extra in query parameter serialization
-        // Skipping extra in query parameter serialization
-
-        // Skipping edit_extra in query parameter serialization
-        // Skipping edit_extra in query parameter serialization
-
-        params.join(",").to_string()
-    }
-}
-
-/// Converts Query Parameters representation (style=form, explode=false) to a WorkEntity value
-/// as specified in https://swagger.io/docs/specification/serialization/
-/// Should be implemented in a serde deserializer
-impl std::str::FromStr for WorkEntity {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        #[derive(Default)]
-        // An intermediate representation of the struct to use for parsing.
-        struct IntermediateRep {
-            pub state: Vec<String>,
-            pub ident: Vec<String>,
-            pub revision: Vec<String>,
-            pub redirect: Vec<String>,
-            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
-        }
-
-        let mut intermediate_rep = IntermediateRep::default();
-
-        // Parse into intermediate representation
-        let mut string_iter = s.split(',').into_iter();
-        let mut key_result = string_iter.next();
-
-        while key_result.is_some() {
-            let val = match string_iter.next() {
-                Some(x) => x,
-                None => {
-                    return std::result::Result::Err(
-                        "Missing value while parsing WorkEntity".to_string(),
-                    )
-                }
-            };
-
-            if let Some(key) = key_result {
-                match key {
-                    "state" => intermediate_rep
-                        .state
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "ident" => intermediate_rep
-                        .ident
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "revision" => intermediate_rep
-                        .revision
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "redirect" => intermediate_rep
-                        .redirect
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "extra" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in WorkEntity"
-                                .to_string(),
-                        )
-                    }
-                    "edit_extra" => {
-                        return std::result::Result::Err(
-                            "Parsing a container in this style is not supported in WorkEntity"
-                                .to_string(),
-                        )
-                    }
-                    _ => {
-                        return std::result::Result::Err(
-                            "Unexpected key while parsing WorkEntity".to_string(),
-                        )
-                    }
-                }
-            }
-
-            // Get the next key
-            key_result = string_iter.next();
-        }
-
-        // Use the intermediate representation to return the struct
-        std::result::Result::Ok(WorkEntity {
-            state: intermediate_rep.state.into_iter().next(),
-            ident: intermediate_rep.ident.into_iter().next(),
-            revision: intermediate_rep.revision.into_iter().next(),
-            redirect: intermediate_rep.redirect.into_iter().next(),
-            extra: intermediate_rep.extra.into_iter().next(),
-            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
-        })
-    }
-}
diff --git a/rust/fatcat-openapi/src/server/mod.rs b/rust/fatcat-openapi/src/server/mod.rs
deleted file mode 100644
index ac07c6e..0000000
--- a/rust/fatcat-openapi/src/server/mod.rs
+++ /dev/null
@@ -1,15856 +0,0 @@
-use futures::{future, future::BoxFuture, future::FutureExt, stream, stream::TryStreamExt, Stream};
-use hyper::header::{HeaderName, HeaderValue, CONTENT_TYPE};
-use hyper::{Body, HeaderMap, Request, Response, StatusCode};
-use log::warn;
-#[allow(unused_imports)]
-use std::convert::{TryFrom, TryInto};
-use std::error::Error;
-use std::future::Future;
-use std::marker::PhantomData;
-use std::task::{Context, Poll};
-pub use swagger::auth::Authorization;
-use swagger::auth::Scopes;
-use swagger::{ApiError, BodyExt, Has, RequestParser, XSpanIdString};
-use url::form_urlencoded;
-
-use crate::header;
-#[allow(unused_imports)]
-use crate::models;
-
-pub use crate::context;
-
-type ServiceFuture = BoxFuture<'static, Result<Response<Body>, crate::ServiceError>>;
-
-use crate::{
-    AcceptEditgroupResponse, Api, AuthCheckResponse, AuthOidcResponse, CreateAuthTokenResponse,
-    CreateContainerAutoBatchResponse, CreateContainerResponse, CreateCreatorAutoBatchResponse,
-    CreateCreatorResponse, CreateEditgroupAnnotationResponse, CreateEditgroupResponse,
-    CreateFileAutoBatchResponse, CreateFileResponse, CreateFilesetAutoBatchResponse,
-    CreateFilesetResponse, CreateReleaseAutoBatchResponse, CreateReleaseResponse,
-    CreateWebcaptureAutoBatchResponse, CreateWebcaptureResponse, CreateWorkAutoBatchResponse,
-    CreateWorkResponse, DeleteContainerEditResponse, DeleteContainerResponse,
-    DeleteCreatorEditResponse, DeleteCreatorResponse, DeleteFileEditResponse, DeleteFileResponse,
-    DeleteFilesetEditResponse, DeleteFilesetResponse, DeleteReleaseEditResponse,
-    DeleteReleaseResponse, DeleteWebcaptureEditResponse, DeleteWebcaptureResponse,
-    DeleteWorkEditResponse, DeleteWorkResponse, GetChangelogEntryResponse, GetChangelogResponse,
-    GetContainerEditResponse, GetContainerHistoryResponse, GetContainerRedirectsResponse,
-    GetContainerResponse, GetContainerRevisionResponse, GetCreatorEditResponse,
-    GetCreatorHistoryResponse, GetCreatorRedirectsResponse, GetCreatorReleasesResponse,
-    GetCreatorResponse, GetCreatorRevisionResponse, GetEditgroupAnnotationsResponse,
-    GetEditgroupResponse, GetEditgroupsReviewableResponse, GetEditorAnnotationsResponse,
-    GetEditorEditgroupsResponse, GetEditorResponse, GetFileEditResponse, GetFileHistoryResponse,
-    GetFileRedirectsResponse, GetFileResponse, GetFileRevisionResponse, GetFilesetEditResponse,
-    GetFilesetHistoryResponse, GetFilesetRedirectsResponse, GetFilesetResponse,
-    GetFilesetRevisionResponse, GetReleaseEditResponse, GetReleaseFilesResponse,
-    GetReleaseFilesetsResponse, GetReleaseHistoryResponse, GetReleaseRedirectsResponse,
-    GetReleaseResponse, GetReleaseRevisionResponse, GetReleaseWebcapturesResponse,
-    GetWebcaptureEditResponse, GetWebcaptureHistoryResponse, GetWebcaptureRedirectsResponse,
-    GetWebcaptureResponse, GetWebcaptureRevisionResponse, GetWorkEditResponse,
-    GetWorkHistoryResponse, GetWorkRedirectsResponse, GetWorkReleasesResponse, GetWorkResponse,
-    GetWorkRevisionResponse, LookupContainerResponse, LookupCreatorResponse, LookupFileResponse,
-    LookupReleaseResponse, UpdateContainerResponse, UpdateCreatorResponse, UpdateEditgroupResponse,
-    UpdateEditorResponse, UpdateFileResponse, UpdateFilesetResponse, UpdateReleaseResponse,
-    UpdateWebcaptureResponse, UpdateWorkResponse,
-};
-
-mod paths {
-    use lazy_static::lazy_static;
-
-    lazy_static! {
-        pub static ref GLOBAL_REGEX_SET: regex::RegexSet = regex::RegexSet::new(vec![
-            r"^/v0/auth/check$",
-            r"^/v0/auth/oidc$",
-            r"^/v0/auth/token/(?P<editor_id>[^/?#]*)$",
-            r"^/v0/changelog$",
-            r"^/v0/changelog/(?P<index>[^/?#]*)$",
-            r"^/v0/container/edit/(?P<edit_id>[^/?#]*)$",
-            r"^/v0/container/lookup$",
-            r"^/v0/container/rev/(?P<rev_id>[^/?#]*)$",
-            r"^/v0/container/(?P<ident>[^/?#]*)$",
-            r"^/v0/container/(?P<ident>[^/?#]*)/history$",
-            r"^/v0/container/(?P<ident>[^/?#]*)/redirects$",
-            r"^/v0/creator/edit/(?P<edit_id>[^/?#]*)$",
-            r"^/v0/creator/lookup$",
-            r"^/v0/creator/rev/(?P<rev_id>[^/?#]*)$",
-            r"^/v0/creator/(?P<ident>[^/?#]*)$",
-            r"^/v0/creator/(?P<ident>[^/?#]*)/history$",
-            r"^/v0/creator/(?P<ident>[^/?#]*)/redirects$",
-            r"^/v0/creator/(?P<ident>[^/?#]*)/releases$",
-            r"^/v0/editgroup$",
-            r"^/v0/editgroup/auto/container/batch$",
-            r"^/v0/editgroup/auto/creator/batch$",
-            r"^/v0/editgroup/auto/file/batch$",
-            r"^/v0/editgroup/auto/fileset/batch$",
-            r"^/v0/editgroup/auto/release/batch$",
-            r"^/v0/editgroup/auto/webcapture/batch$",
-            r"^/v0/editgroup/auto/work/batch$",
-            r"^/v0/editgroup/reviewable$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/accept$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/annotation$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/annotations$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/container$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/container/edit/(?P<edit_id>[^/?#]*)$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/container/(?P<ident>[^/?#]*)$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/creator$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/creator/edit/(?P<edit_id>[^/?#]*)$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/creator/(?P<ident>[^/?#]*)$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/file$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/file/edit/(?P<edit_id>[^/?#]*)$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/file/(?P<ident>[^/?#]*)$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/fileset$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/fileset/edit/(?P<edit_id>[^/?#]*)$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/fileset/(?P<ident>[^/?#]*)$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/release$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/release/edit/(?P<edit_id>[^/?#]*)$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/release/(?P<ident>[^/?#]*)$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/webcapture$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/webcapture/edit/(?P<edit_id>[^/?#]*)$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/webcapture/(?P<ident>[^/?#]*)$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/work$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/work/edit/(?P<edit_id>[^/?#]*)$",
-            r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/work/(?P<ident>[^/?#]*)$",
-            r"^/v0/editor/(?P<editor_id>[^/?#]*)$",
-            r"^/v0/editor/(?P<editor_id>[^/?#]*)/annotations$",
-            r"^/v0/editor/(?P<editor_id>[^/?#]*)/editgroups$",
-            r"^/v0/file/edit/(?P<edit_id>[^/?#]*)$",
-            r"^/v0/file/lookup$",
-            r"^/v0/file/rev/(?P<rev_id>[^/?#]*)$",
-            r"^/v0/file/(?P<ident>[^/?#]*)$",
-            r"^/v0/file/(?P<ident>[^/?#]*)/history$",
-            r"^/v0/file/(?P<ident>[^/?#]*)/redirects$",
-            r"^/v0/fileset/edit/(?P<edit_id>[^/?#]*)$",
-            r"^/v0/fileset/rev/(?P<rev_id>[^/?#]*)$",
-            r"^/v0/fileset/(?P<ident>[^/?#]*)$",
-            r"^/v0/fileset/(?P<ident>[^/?#]*)/history$",
-            r"^/v0/fileset/(?P<ident>[^/?#]*)/redirects$",
-            r"^/v0/release/edit/(?P<edit_id>[^/?#]*)$",
-            r"^/v0/release/lookup$",
-            r"^/v0/release/rev/(?P<rev_id>[^/?#]*)$",
-            r"^/v0/release/(?P<ident>[^/?#]*)$",
-            r"^/v0/release/(?P<ident>[^/?#]*)/files$",
-            r"^/v0/release/(?P<ident>[^/?#]*)/filesets$",
-            r"^/v0/release/(?P<ident>[^/?#]*)/history$",
-            r"^/v0/release/(?P<ident>[^/?#]*)/redirects$",
-            r"^/v0/release/(?P<ident>[^/?#]*)/webcaptures$",
-            r"^/v0/webcapture/edit/(?P<edit_id>[^/?#]*)$",
-            r"^/v0/webcapture/rev/(?P<rev_id>[^/?#]*)$",
-            r"^/v0/webcapture/(?P<ident>[^/?#]*)$",
-            r"^/v0/webcapture/(?P<ident>[^/?#]*)/history$",
-            r"^/v0/webcapture/(?P<ident>[^/?#]*)/redirects$",
-            r"^/v0/work/edit/(?P<edit_id>[^/?#]*)$",
-            r"^/v0/work/rev/(?P<rev_id>[^/?#]*)$",
-            r"^/v0/work/(?P<ident>[^/?#]*)$",
-            r"^/v0/work/(?P<ident>[^/?#]*)/history$",
-            r"^/v0/work/(?P<ident>[^/?#]*)/redirects$",
-            r"^/v0/work/(?P<ident>[^/?#]*)/releases$"
-        ])
-        .expect("Unable to create global regex set");
-    }
-    pub(crate) static ID_AUTH_CHECK: usize = 0;
-    pub(crate) static ID_AUTH_OIDC: usize = 1;
-    pub(crate) static ID_AUTH_TOKEN_EDITOR_ID: usize = 2;
-    lazy_static! {
-        pub static ref REGEX_AUTH_TOKEN_EDITOR_ID: regex::Regex =
-            regex::Regex::new(r"^/v0/auth/token/(?P<editor_id>[^/?#]*)$")
-                .expect("Unable to create regex for AUTH_TOKEN_EDITOR_ID");
-    }
-    pub(crate) static ID_CHANGELOG: usize = 3;
-    pub(crate) static ID_CHANGELOG_INDEX: usize = 4;
-    lazy_static! {
-        pub static ref REGEX_CHANGELOG_INDEX: regex::Regex =
-            regex::Regex::new(r"^/v0/changelog/(?P<index>[^/?#]*)$")
-                .expect("Unable to create regex for CHANGELOG_INDEX");
-    }
-    pub(crate) static ID_CONTAINER_EDIT_EDIT_ID: usize = 5;
-    lazy_static! {
-        pub static ref REGEX_CONTAINER_EDIT_EDIT_ID: regex::Regex =
-            regex::Regex::new(r"^/v0/container/edit/(?P<edit_id>[^/?#]*)$")
-                .expect("Unable to create regex for CONTAINER_EDIT_EDIT_ID");
-    }
-    pub(crate) static ID_CONTAINER_LOOKUP: usize = 6;
-    pub(crate) static ID_CONTAINER_REV_REV_ID: usize = 7;
-    lazy_static! {
-        pub static ref REGEX_CONTAINER_REV_REV_ID: regex::Regex =
-            regex::Regex::new(r"^/v0/container/rev/(?P<rev_id>[^/?#]*)$")
-                .expect("Unable to create regex for CONTAINER_REV_REV_ID");
-    }
-    pub(crate) static ID_CONTAINER_IDENT: usize = 8;
-    lazy_static! {
-        pub static ref REGEX_CONTAINER_IDENT: regex::Regex =
-            regex::Regex::new(r"^/v0/container/(?P<ident>[^/?#]*)$")
-                .expect("Unable to create regex for CONTAINER_IDENT");
-    }
-    pub(crate) static ID_CONTAINER_IDENT_HISTORY: usize = 9;
-    lazy_static! {
-        pub static ref REGEX_CONTAINER_IDENT_HISTORY: regex::Regex =
-            regex::Regex::new(r"^/v0/container/(?P<ident>[^/?#]*)/history$")
-                .expect("Unable to create regex for CONTAINER_IDENT_HISTORY");
-    }
-    pub(crate) static ID_CONTAINER_IDENT_REDIRECTS: usize = 10;
-    lazy_static! {
-        pub static ref REGEX_CONTAINER_IDENT_REDIRECTS: regex::Regex =
-            regex::Regex::new(r"^/v0/container/(?P<ident>[^/?#]*)/redirects$")
-                .expect("Unable to create regex for CONTAINER_IDENT_REDIRECTS");
-    }
-    pub(crate) static ID_CREATOR_EDIT_EDIT_ID: usize = 11;
-    lazy_static! {
-        pub static ref REGEX_CREATOR_EDIT_EDIT_ID: regex::Regex =
-            regex::Regex::new(r"^/v0/creator/edit/(?P<edit_id>[^/?#]*)$")
-                .expect("Unable to create regex for CREATOR_EDIT_EDIT_ID");
-    }
-    pub(crate) static ID_CREATOR_LOOKUP: usize = 12;
-    pub(crate) static ID_CREATOR_REV_REV_ID: usize = 13;
-    lazy_static! {
-        pub static ref REGEX_CREATOR_REV_REV_ID: regex::Regex =
-            regex::Regex::new(r"^/v0/creator/rev/(?P<rev_id>[^/?#]*)$")
-                .expect("Unable to create regex for CREATOR_REV_REV_ID");
-    }
-    pub(crate) static ID_CREATOR_IDENT: usize = 14;
-    lazy_static! {
-        pub static ref REGEX_CREATOR_IDENT: regex::Regex =
-            regex::Regex::new(r"^/v0/creator/(?P<ident>[^/?#]*)$")
-                .expect("Unable to create regex for CREATOR_IDENT");
-    }
-    pub(crate) static ID_CREATOR_IDENT_HISTORY: usize = 15;
-    lazy_static! {
-        pub static ref REGEX_CREATOR_IDENT_HISTORY: regex::Regex =
-            regex::Regex::new(r"^/v0/creator/(?P<ident>[^/?#]*)/history$")
-                .expect("Unable to create regex for CREATOR_IDENT_HISTORY");
-    }
-    pub(crate) static ID_CREATOR_IDENT_REDIRECTS: usize = 16;
-    lazy_static! {
-        pub static ref REGEX_CREATOR_IDENT_REDIRECTS: regex::Regex =
-            regex::Regex::new(r"^/v0/creator/(?P<ident>[^/?#]*)/redirects$")
-                .expect("Unable to create regex for CREATOR_IDENT_REDIRECTS");
-    }
-    pub(crate) static ID_CREATOR_IDENT_RELEASES: usize = 17;
-    lazy_static! {
-        pub static ref REGEX_CREATOR_IDENT_RELEASES: regex::Regex =
-            regex::Regex::new(r"^/v0/creator/(?P<ident>[^/?#]*)/releases$")
-                .expect("Unable to create regex for CREATOR_IDENT_RELEASES");
-    }
-    pub(crate) static ID_EDITGROUP: usize = 18;
-    pub(crate) static ID_EDITGROUP_AUTO_CONTAINER_BATCH: usize = 19;
-    pub(crate) static ID_EDITGROUP_AUTO_CREATOR_BATCH: usize = 20;
-    pub(crate) static ID_EDITGROUP_AUTO_FILE_BATCH: usize = 21;
-    pub(crate) static ID_EDITGROUP_AUTO_FILESET_BATCH: usize = 22;
-    pub(crate) static ID_EDITGROUP_AUTO_RELEASE_BATCH: usize = 23;
-    pub(crate) static ID_EDITGROUP_AUTO_WEBCAPTURE_BATCH: usize = 24;
-    pub(crate) static ID_EDITGROUP_AUTO_WORK_BATCH: usize = 25;
-    pub(crate) static ID_EDITGROUP_REVIEWABLE: usize = 26;
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID: usize = 27;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID: regex::Regex =
-            regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)$")
-                .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_ACCEPT: usize = 28;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_ACCEPT: regex::Regex =
-            regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/accept$")
-                .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_ACCEPT");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_ANNOTATION: usize = 29;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_ANNOTATION: regex::Regex =
-            regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/annotation$")
-                .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_ANNOTATION");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_ANNOTATIONS: usize = 30;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_ANNOTATIONS: regex::Regex =
-            regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/annotations$")
-                .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_ANNOTATIONS");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_CONTAINER: usize = 31;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER: regex::Regex =
-            regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/container$")
-                .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_CONTAINER");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID: usize = 32;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID: regex::Regex =
-            regex::Regex::new(
-                r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/container/edit/(?P<edit_id>[^/?#]*)$"
-            )
-            .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT: usize = 33;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT: regex::Regex =
-            regex::Regex::new(
-                r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/container/(?P<ident>[^/?#]*)$"
-            )
-            .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_CREATOR: usize = 34;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_CREATOR: regex::Regex =
-            regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/creator$")
-                .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_CREATOR");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID: usize = 35;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID: regex::Regex =
-            regex::Regex::new(
-                r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/creator/edit/(?P<edit_id>[^/?#]*)$"
-            )
-            .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT: usize = 36;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT: regex::Regex =
-            regex::Regex::new(
-                r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/creator/(?P<ident>[^/?#]*)$"
-            )
-            .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_CREATOR_IDENT");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_FILE: usize = 37;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_FILE: regex::Regex =
-            regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/file$")
-                .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_FILE");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID: usize = 38;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID: regex::Regex =
-            regex::Regex::new(
-                r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/file/edit/(?P<edit_id>[^/?#]*)$"
-            )
-            .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_FILE_IDENT: usize = 39;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_FILE_IDENT: regex::Regex =
-            regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/file/(?P<ident>[^/?#]*)$")
-                .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_FILE_IDENT");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_FILESET: usize = 40;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_FILESET: regex::Regex =
-            regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/fileset$")
-                .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_FILESET");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID: usize = 41;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID: regex::Regex =
-            regex::Regex::new(
-                r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/fileset/edit/(?P<edit_id>[^/?#]*)$"
-            )
-            .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_FILESET_IDENT: usize = 42;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_FILESET_IDENT: regex::Regex =
-            regex::Regex::new(
-                r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/fileset/(?P<ident>[^/?#]*)$"
-            )
-            .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_FILESET_IDENT");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_RELEASE: usize = 43;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_RELEASE: regex::Regex =
-            regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/release$")
-                .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_RELEASE");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID: usize = 44;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID: regex::Regex =
-            regex::Regex::new(
-                r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/release/edit/(?P<edit_id>[^/?#]*)$"
-            )
-            .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT: usize = 45;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT: regex::Regex =
-            regex::Regex::new(
-                r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/release/(?P<ident>[^/?#]*)$"
-            )
-            .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_RELEASE_IDENT");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE: usize = 46;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE: regex::Regex =
-            regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/webcapture$")
-                .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_WEBCAPTURE");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID: usize = 47;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID: regex::Regex =
-            regex::Regex::new(
-                r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/webcapture/edit/(?P<edit_id>[^/?#]*)$"
-            )
-            .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT: usize = 48;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT: regex::Regex =
-            regex::Regex::new(
-                r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/webcapture/(?P<ident>[^/?#]*)$"
-            )
-            .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_WORK: usize = 49;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_WORK: regex::Regex =
-            regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/work$")
-                .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_WORK");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID: usize = 50;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID: regex::Regex =
-            regex::Regex::new(
-                r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/work/edit/(?P<edit_id>[^/?#]*)$"
-            )
-            .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID");
-    }
-    pub(crate) static ID_EDITGROUP_EDITGROUP_ID_WORK_IDENT: usize = 51;
-    lazy_static! {
-        pub static ref REGEX_EDITGROUP_EDITGROUP_ID_WORK_IDENT: regex::Regex =
-            regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/work/(?P<ident>[^/?#]*)$")
-                .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_WORK_IDENT");
-    }
-    pub(crate) static ID_EDITOR_EDITOR_ID: usize = 52;
-    lazy_static! {
-        pub static ref REGEX_EDITOR_EDITOR_ID: regex::Regex =
-            regex::Regex::new(r"^/v0/editor/(?P<editor_id>[^/?#]*)$")
-                .expect("Unable to create regex for EDITOR_EDITOR_ID");
-    }
-    pub(crate) static ID_EDITOR_EDITOR_ID_ANNOTATIONS: usize = 53;
-    lazy_static! {
-        pub static ref REGEX_EDITOR_EDITOR_ID_ANNOTATIONS: regex::Regex =
-            regex::Regex::new(r"^/v0/editor/(?P<editor_id>[^/?#]*)/annotations$")
-                .expect("Unable to create regex for EDITOR_EDITOR_ID_ANNOTATIONS");
-    }
-    pub(crate) static ID_EDITOR_EDITOR_ID_EDITGROUPS: usize = 54;
-    lazy_static! {
-        pub static ref REGEX_EDITOR_EDITOR_ID_EDITGROUPS: regex::Regex =
-            regex::Regex::new(r"^/v0/editor/(?P<editor_id>[^/?#]*)/editgroups$")
-                .expect("Unable to create regex for EDITOR_EDITOR_ID_EDITGROUPS");
-    }
-    pub(crate) static ID_FILE_EDIT_EDIT_ID: usize = 55;
-    lazy_static! {
-        pub static ref REGEX_FILE_EDIT_EDIT_ID: regex::Regex =
-            regex::Regex::new(r"^/v0/file/edit/(?P<edit_id>[^/?#]*)$")
-                .expect("Unable to create regex for FILE_EDIT_EDIT_ID");
-    }
-    pub(crate) static ID_FILE_LOOKUP: usize = 56;
-    pub(crate) static ID_FILE_REV_REV_ID: usize = 57;
-    lazy_static! {
-        pub static ref REGEX_FILE_REV_REV_ID: regex::Regex =
-            regex::Regex::new(r"^/v0/file/rev/(?P<rev_id>[^/?#]*)$")
-                .expect("Unable to create regex for FILE_REV_REV_ID");
-    }
-    pub(crate) static ID_FILE_IDENT: usize = 58;
-    lazy_static! {
-        pub static ref REGEX_FILE_IDENT: regex::Regex =
-            regex::Regex::new(r"^/v0/file/(?P<ident>[^/?#]*)$")
-                .expect("Unable to create regex for FILE_IDENT");
-    }
-    pub(crate) static ID_FILE_IDENT_HISTORY: usize = 59;
-    lazy_static! {
-        pub static ref REGEX_FILE_IDENT_HISTORY: regex::Regex =
-            regex::Regex::new(r"^/v0/file/(?P<ident>[^/?#]*)/history$")
-                .expect("Unable to create regex for FILE_IDENT_HISTORY");
-    }
-    pub(crate) static ID_FILE_IDENT_REDIRECTS: usize = 60;
-    lazy_static! {
-        pub static ref REGEX_FILE_IDENT_REDIRECTS: regex::Regex =
-            regex::Regex::new(r"^/v0/file/(?P<ident>[^/?#]*)/redirects$")
-                .expect("Unable to create regex for FILE_IDENT_REDIRECTS");
-    }
-    pub(crate) static ID_FILESET_EDIT_EDIT_ID: usize = 61;
-    lazy_static! {
-        pub static ref REGEX_FILESET_EDIT_EDIT_ID: regex::Regex =
-            regex::Regex::new(r"^/v0/fileset/edit/(?P<edit_id>[^/?#]*)$")
-                .expect("Unable to create regex for FILESET_EDIT_EDIT_ID");
-    }
-    pub(crate) static ID_FILESET_REV_REV_ID: usize = 62;
-    lazy_static! {
-        pub static ref REGEX_FILESET_REV_REV_ID: regex::Regex =
-            regex::Regex::new(r"^/v0/fileset/rev/(?P<rev_id>[^/?#]*)$")
-                .expect("Unable to create regex for FILESET_REV_REV_ID");
-    }
-    pub(crate) static ID_FILESET_IDENT: usize = 63;
-    lazy_static! {
-        pub static ref REGEX_FILESET_IDENT: regex::Regex =
-            regex::Regex::new(r"^/v0/fileset/(?P<ident>[^/?#]*)$")
-                .expect("Unable to create regex for FILESET_IDENT");
-    }
-    pub(crate) static ID_FILESET_IDENT_HISTORY: usize = 64;
-    lazy_static! {
-        pub static ref REGEX_FILESET_IDENT_HISTORY: regex::Regex =
-            regex::Regex::new(r"^/v0/fileset/(?P<ident>[^/?#]*)/history$")
-                .expect("Unable to create regex for FILESET_IDENT_HISTORY");
-    }
-    pub(crate) static ID_FILESET_IDENT_REDIRECTS: usize = 65;
-    lazy_static! {
-        pub static ref REGEX_FILESET_IDENT_REDIRECTS: regex::Regex =
-            regex::Regex::new(r"^/v0/fileset/(?P<ident>[^/?#]*)/redirects$")
-                .expect("Unable to create regex for FILESET_IDENT_REDIRECTS");
-    }
-    pub(crate) static ID_RELEASE_EDIT_EDIT_ID: usize = 66;
-    lazy_static! {
-        pub static ref REGEX_RELEASE_EDIT_EDIT_ID: regex::Regex =
-            regex::Regex::new(r"^/v0/release/edit/(?P<edit_id>[^/?#]*)$")
-                .expect("Unable to create regex for RELEASE_EDIT_EDIT_ID");
-    }
-    pub(crate) static ID_RELEASE_LOOKUP: usize = 67;
-    pub(crate) static ID_RELEASE_REV_REV_ID: usize = 68;
-    lazy_static! {
-        pub static ref REGEX_RELEASE_REV_REV_ID: regex::Regex =
-            regex::Regex::new(r"^/v0/release/rev/(?P<rev_id>[^/?#]*)$")
-                .expect("Unable to create regex for RELEASE_REV_REV_ID");
-    }
-    pub(crate) static ID_RELEASE_IDENT: usize = 69;
-    lazy_static! {
-        pub static ref REGEX_RELEASE_IDENT: regex::Regex =
-            regex::Regex::new(r"^/v0/release/(?P<ident>[^/?#]*)$")
-                .expect("Unable to create regex for RELEASE_IDENT");
-    }
-    pub(crate) static ID_RELEASE_IDENT_FILES: usize = 70;
-    lazy_static! {
-        pub static ref REGEX_RELEASE_IDENT_FILES: regex::Regex =
-            regex::Regex::new(r"^/v0/release/(?P<ident>[^/?#]*)/files$")
-                .expect("Unable to create regex for RELEASE_IDENT_FILES");
-    }
-    pub(crate) static ID_RELEASE_IDENT_FILESETS: usize = 71;
-    lazy_static! {
-        pub static ref REGEX_RELEASE_IDENT_FILESETS: regex::Regex =
-            regex::Regex::new(r"^/v0/release/(?P<ident>[^/?#]*)/filesets$")
-                .expect("Unable to create regex for RELEASE_IDENT_FILESETS");
-    }
-    pub(crate) static ID_RELEASE_IDENT_HISTORY: usize = 72;
-    lazy_static! {
-        pub static ref REGEX_RELEASE_IDENT_HISTORY: regex::Regex =
-            regex::Regex::new(r"^/v0/release/(?P<ident>[^/?#]*)/history$")
-                .expect("Unable to create regex for RELEASE_IDENT_HISTORY");
-    }
-    pub(crate) static ID_RELEASE_IDENT_REDIRECTS: usize = 73;
-    lazy_static! {
-        pub static ref REGEX_RELEASE_IDENT_REDIRECTS: regex::Regex =
-            regex::Regex::new(r"^/v0/release/(?P<ident>[^/?#]*)/redirects$")
-                .expect("Unable to create regex for RELEASE_IDENT_REDIRECTS");
-    }
-    pub(crate) static ID_RELEASE_IDENT_WEBCAPTURES: usize = 74;
-    lazy_static! {
-        pub static ref REGEX_RELEASE_IDENT_WEBCAPTURES: regex::Regex =
-            regex::Regex::new(r"^/v0/release/(?P<ident>[^/?#]*)/webcaptures$")
-                .expect("Unable to create regex for RELEASE_IDENT_WEBCAPTURES");
-    }
-    pub(crate) static ID_WEBCAPTURE_EDIT_EDIT_ID: usize = 75;
-    lazy_static! {
-        pub static ref REGEX_WEBCAPTURE_EDIT_EDIT_ID: regex::Regex =
-            regex::Regex::new(r"^/v0/webcapture/edit/(?P<edit_id>[^/?#]*)$")
-                .expect("Unable to create regex for WEBCAPTURE_EDIT_EDIT_ID");
-    }
-    pub(crate) static ID_WEBCAPTURE_REV_REV_ID: usize = 76;
-    lazy_static! {
-        pub static ref REGEX_WEBCAPTURE_REV_REV_ID: regex::Regex =
-            regex::Regex::new(r"^/v0/webcapture/rev/(?P<rev_id>[^/?#]*)$")
-                .expect("Unable to create regex for WEBCAPTURE_REV_REV_ID");
-    }
-    pub(crate) static ID_WEBCAPTURE_IDENT: usize = 77;
-    lazy_static! {
-        pub static ref REGEX_WEBCAPTURE_IDENT: regex::Regex =
-            regex::Regex::new(r"^/v0/webcapture/(?P<ident>[^/?#]*)$")
-                .expect("Unable to create regex for WEBCAPTURE_IDENT");
-    }
-    pub(crate) static ID_WEBCAPTURE_IDENT_HISTORY: usize = 78;
-    lazy_static! {
-        pub static ref REGEX_WEBCAPTURE_IDENT_HISTORY: regex::Regex =
-            regex::Regex::new(r"^/v0/webcapture/(?P<ident>[^/?#]*)/history$")
-                .expect("Unable to create regex for WEBCAPTURE_IDENT_HISTORY");
-    }
-    pub(crate) static ID_WEBCAPTURE_IDENT_REDIRECTS: usize = 79;
-    lazy_static! {
-        pub static ref REGEX_WEBCAPTURE_IDENT_REDIRECTS: regex::Regex =
-            regex::Regex::new(r"^/v0/webcapture/(?P<ident>[^/?#]*)/redirects$")
-                .expect("Unable to create regex for WEBCAPTURE_IDENT_REDIRECTS");
-    }
-    pub(crate) static ID_WORK_EDIT_EDIT_ID: usize = 80;
-    lazy_static! {
-        pub static ref REGEX_WORK_EDIT_EDIT_ID: regex::Regex =
-            regex::Regex::new(r"^/v0/work/edit/(?P<edit_id>[^/?#]*)$")
-                .expect("Unable to create regex for WORK_EDIT_EDIT_ID");
-    }
-    pub(crate) static ID_WORK_REV_REV_ID: usize = 81;
-    lazy_static! {
-        pub static ref REGEX_WORK_REV_REV_ID: regex::Regex =
-            regex::Regex::new(r"^/v0/work/rev/(?P<rev_id>[^/?#]*)$")
-                .expect("Unable to create regex for WORK_REV_REV_ID");
-    }
-    pub(crate) static ID_WORK_IDENT: usize = 82;
-    lazy_static! {
-        pub static ref REGEX_WORK_IDENT: regex::Regex =
-            regex::Regex::new(r"^/v0/work/(?P<ident>[^/?#]*)$")
-                .expect("Unable to create regex for WORK_IDENT");
-    }
-    pub(crate) static ID_WORK_IDENT_HISTORY: usize = 83;
-    lazy_static! {
-        pub static ref REGEX_WORK_IDENT_HISTORY: regex::Regex =
-            regex::Regex::new(r"^/v0/work/(?P<ident>[^/?#]*)/history$")
-                .expect("Unable to create regex for WORK_IDENT_HISTORY");
-    }
-    pub(crate) static ID_WORK_IDENT_REDIRECTS: usize = 84;
-    lazy_static! {
-        pub static ref REGEX_WORK_IDENT_REDIRECTS: regex::Regex =
-            regex::Regex::new(r"^/v0/work/(?P<ident>[^/?#]*)/redirects$")
-                .expect("Unable to create regex for WORK_IDENT_REDIRECTS");
-    }
-    pub(crate) static ID_WORK_IDENT_RELEASES: usize = 85;
-    lazy_static! {
-        pub static ref REGEX_WORK_IDENT_RELEASES: regex::Regex =
-            regex::Regex::new(r"^/v0/work/(?P<ident>[^/?#]*)/releases$")
-                .expect("Unable to create regex for WORK_IDENT_RELEASES");
-    }
-}
-
-pub struct MakeService<T, C>
-where
-    T: Api<C> + Clone + Send + 'static,
-    C: Has<XSpanIdString> + Has<Option<Authorization>> + Send + Sync + 'static,
-{
-    api_impl: T,
-    marker: PhantomData<C>,
-}
-
-impl<T, C> MakeService<T, C>
-where
-    T: Api<C> + Clone + Send + 'static,
-    C: Has<XSpanIdString> + Has<Option<Authorization>> + Send + Sync + 'static,
-{
-    pub fn new(api_impl: T) -> Self {
-        MakeService {
-            api_impl,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<T, C, Target> hyper::service::Service<Target> for MakeService<T, C>
-where
-    T: Api<C> + Clone + Send + 'static,
-    C: Has<XSpanIdString> + Has<Option<Authorization>> + Send + Sync + 'static,
-{
-    type Response = Service<T, C>;
-    type Error = crate::ServiceError;
-    type Future = future::Ready<Result<Self::Response, Self::Error>>;
-
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, target: Target) -> Self::Future {
-        futures::future::ok(Service::new(self.api_impl.clone()))
-    }
-}
-
-fn method_not_allowed() -> Result<Response<Body>, crate::ServiceError> {
-    Ok(Response::builder()
-        .status(StatusCode::METHOD_NOT_ALLOWED)
-        .body(Body::empty())
-        .expect("Unable to create Method Not Allowed response"))
-}
-
-pub struct Service<T, C>
-where
-    T: Api<C> + Clone + Send + 'static,
-    C: Has<XSpanIdString> + Has<Option<Authorization>> + Send + Sync + 'static,
-{
-    api_impl: T,
-    marker: PhantomData<C>,
-}
-
-impl<T, C> Service<T, C>
-where
-    T: Api<C> + Clone + Send + 'static,
-    C: Has<XSpanIdString> + Has<Option<Authorization>> + Send + Sync + 'static,
-{
-    pub fn new(api_impl: T) -> Self {
-        Service {
-            api_impl: api_impl,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<T, C> Clone for Service<T, C>
-where
-    T: Api<C> + Clone + Send + 'static,
-    C: Has<XSpanIdString> + Has<Option<Authorization>> + Send + Sync + 'static,
-{
-    fn clone(&self) -> Self {
-        Service {
-            api_impl: self.api_impl.clone(),
-            marker: self.marker.clone(),
-        }
-    }
-}
-
-impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C>
-where
-    T: Api<C> + Clone + Send + Sync + 'static,
-    C: Has<XSpanIdString> + Has<Option<Authorization>> + Send + Sync + 'static,
-{
-    type Response = Response<Body>;
-    type Error = crate::ServiceError;
-    type Future = ServiceFuture;
-
-    fn poll_ready(&mut self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
-        self.api_impl.poll_ready(cx)
-    }
-
-    fn call(&mut self, req: (Request<Body>, C)) -> Self::Future {
-        async fn run<T, C>(
-            mut api_impl: T,
-            req: (Request<Body>, C),
-        ) -> Result<Response<Body>, crate::ServiceError>
-        where
-            T: Api<C> + Clone + Send + 'static,
-            C: Has<XSpanIdString> + Has<Option<Authorization>> + Send + Sync + 'static,
-        {
-            let (request, context) = req;
-            let (parts, body) = request.into_parts();
-            let (method, uri, headers) = (parts.method, parts.uri, parts.headers);
-            let path = paths::GLOBAL_REGEX_SET.matches(uri.path());
-
-            match &method {
-                // AcceptEditgroup - POST /editgroup/{editgroup_id}/accept
-                &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ACCEPT) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_ACCEPT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_ACCEPT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_ACCEPT.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl
-                        .accept_editgroup(param_editgroup_id, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            AcceptEditgroupResponse::MergedSuccessfully(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for ACCEPT_EDITGROUP_MERGED_SUCCESSFULLY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            AcceptEditgroupResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for ACCEPT_EDITGROUP_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            AcceptEditgroupResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for ACCEPT_EDITGROUP_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            AcceptEditgroupResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for ACCEPT_EDITGROUP_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            AcceptEditgroupResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for ACCEPT_EDITGROUP_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            AcceptEditgroupResponse::EditConflict(body) => {
-                                *response.status_mut() = StatusCode::from_u16(409)
-                                    .expect("Unable to turn 409 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for ACCEPT_EDITGROUP_EDIT_CONFLICT"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            AcceptEditgroupResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for ACCEPT_EDITGROUP_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // AuthCheck - GET /auth/check
-                &hyper::Method::GET if path.matched(paths::ID_AUTH_CHECK) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_role = query_params
-                        .iter()
-                        .filter(|e| e.0 == "role")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_role = match param_role {
-                        Some(param_role) => {
-                            let param_role = <String as std::str::FromStr>::from_str(&param_role);
-                            match param_role {
-                            Ok(param_role) => Some(param_role),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter role - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter role")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl.auth_check(param_role, &context).await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            AuthCheckResponse::Success(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for AUTH_CHECK_SUCCESS"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            AuthCheckResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for AUTH_CHECK_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            AuthCheckResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for AUTH_CHECK_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            AuthCheckResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for AUTH_CHECK_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            AuthCheckResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for AUTH_CHECK_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // AuthOidc - POST /auth/oidc
-                &hyper::Method::POST if path.matched(paths::ID_AUTH_OIDC) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_auth_oidc: Option<models::AuthOidc> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_auth_oidc) => param_auth_oidc,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter AuthOidc - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter AuthOidc due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_auth_oidc = match param_auth_oidc {
-                                    Some(param_auth_oidc) => param_auth_oidc,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter AuthOidc"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter AuthOidc")),
-                                };
-
-                                let result = api_impl.auth_oidc(
-                                            param_auth_oidc,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                AuthOidcResponse::Found
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for AUTH_OIDC_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                AuthOidcResponse::Created
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for AUTH_OIDC_CREATED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                AuthOidcResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for AUTH_OIDC_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                AuthOidcResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for AUTH_OIDC_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                AuthOidcResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for AUTH_OIDC_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                AuthOidcResponse::Conflict
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(409).expect("Unable to turn 409 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for AUTH_OIDC_CONFLICT"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                AuthOidcResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for AUTH_OIDC_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter AuthOidc: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter AuthOidc")),
-                        }
-                }
-
-                // CreateAuthToken - POST /auth/token/{editor_id}
-                &hyper::Method::POST if path.matched(paths::ID_AUTH_TOKEN_EDITOR_ID) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_AUTH_TOKEN_EDITOR_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE AUTH_TOKEN_EDITOR_ID in set but failed match against \"{}\"", path, paths::REGEX_AUTH_TOKEN_EDITOR_ID.as_str())
-                    );
-
-                    let param_editor_id = match percent_encoding::percent_decode(path_params["editor_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editor_id) => match param_editor_id.parse::<String>() {
-                        Ok(param_editor_id) => param_editor_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editor_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editor_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_duration_seconds = query_params
-                        .iter()
-                        .filter(|e| e.0 == "duration_seconds")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_duration_seconds = match param_duration_seconds {
-                        Some(param_duration_seconds) => {
-                            let param_duration_seconds =
-                                <i32 as std::str::FromStr>::from_str(&param_duration_seconds);
-                            match param_duration_seconds {
-                            Ok(param_duration_seconds) => Some(param_duration_seconds),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter duration_seconds - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter duration_seconds")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .create_auth_token(param_editor_id, param_duration_seconds, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            CreateAuthTokenResponse::Success(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_AUTH_TOKEN_SUCCESS"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            CreateAuthTokenResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_AUTH_TOKEN_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            CreateAuthTokenResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_AUTH_TOKEN_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            CreateAuthTokenResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_AUTH_TOKEN_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            CreateAuthTokenResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_AUTH_TOKEN_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // CreateContainer - POST /editgroup/{editgroup_id}/container
-                &hyper::Method::POST
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_CONTAINER in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_container_entity: Option<models::ContainerEntity> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_container_entity) => param_container_entity,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter ContainerEntity - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter ContainerEntity due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_container_entity = match param_container_entity {
-                                    Some(param_container_entity) => param_container_entity,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter ContainerEntity"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter ContainerEntity")),
-                                };
-
-                                let result = api_impl.create_container(
-                                            param_editgroup_id,
-                                            param_container_entity,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                CreateContainerResponse::CreatedEntity
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CONTAINER_CREATED_ENTITY"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateContainerResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CONTAINER_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateContainerResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CONTAINER_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateContainerResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CONTAINER_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateContainerResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CONTAINER_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateContainerResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CONTAINER_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter ContainerEntity: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter ContainerEntity")),
-                        }
-                }
-
-                // CreateContainerAutoBatch - POST /editgroup/auto/container/batch
-                &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_CONTAINER_BATCH) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_container_auto_batch: Option<models::ContainerAutoBatch> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_container_auto_batch) => param_container_auto_batch,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter ContainerAutoBatch - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter ContainerAutoBatch due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_container_auto_batch = match param_container_auto_batch {
-                                    Some(param_container_auto_batch) => param_container_auto_batch,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter ContainerAutoBatch"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter ContainerAutoBatch")),
-                                };
-
-                                let result = api_impl.create_container_auto_batch(
-                                            param_container_auto_batch,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                CreateContainerAutoBatchResponse::CreatedEditgroup
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CONTAINER_AUTO_BATCH_CREATED_EDITGROUP"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateContainerAutoBatchResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CONTAINER_AUTO_BATCH_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateContainerAutoBatchResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CONTAINER_AUTO_BATCH_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateContainerAutoBatchResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CONTAINER_AUTO_BATCH_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateContainerAutoBatchResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CONTAINER_AUTO_BATCH_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateContainerAutoBatchResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CONTAINER_AUTO_BATCH_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter ContainerAutoBatch: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter ContainerAutoBatch")),
-                        }
-                }
-
-                // CreateCreator - POST /editgroup/{editgroup_id}/creator
-                &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_CREATOR
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_CREATOR in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_CREATOR.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_creator_entity: Option<models::CreatorEntity> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_creator_entity) => param_creator_entity,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter CreatorEntity - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter CreatorEntity due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_creator_entity = match param_creator_entity {
-                                    Some(param_creator_entity) => param_creator_entity,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter CreatorEntity"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter CreatorEntity")),
-                                };
-
-                                let result = api_impl.create_creator(
-                                            param_editgroup_id,
-                                            param_creator_entity,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                CreateCreatorResponse::CreatedEntity
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CREATOR_CREATED_ENTITY"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateCreatorResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CREATOR_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateCreatorResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CREATOR_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateCreatorResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CREATOR_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateCreatorResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CREATOR_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateCreatorResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CREATOR_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter CreatorEntity: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter CreatorEntity")),
-                        }
-                }
-
-                // CreateCreatorAutoBatch - POST /editgroup/auto/creator/batch
-                &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_CREATOR_BATCH) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_creator_auto_batch: Option<models::CreatorAutoBatch> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_creator_auto_batch) => param_creator_auto_batch,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter CreatorAutoBatch - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter CreatorAutoBatch due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_creator_auto_batch = match param_creator_auto_batch {
-                                    Some(param_creator_auto_batch) => param_creator_auto_batch,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter CreatorAutoBatch"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter CreatorAutoBatch")),
-                                };
-
-                                let result = api_impl.create_creator_auto_batch(
-                                            param_creator_auto_batch,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                CreateCreatorAutoBatchResponse::CreatedEditgroup
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CREATOR_AUTO_BATCH_CREATED_EDITGROUP"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateCreatorAutoBatchResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CREATOR_AUTO_BATCH_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateCreatorAutoBatchResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CREATOR_AUTO_BATCH_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateCreatorAutoBatchResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CREATOR_AUTO_BATCH_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateCreatorAutoBatchResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CREATOR_AUTO_BATCH_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateCreatorAutoBatchResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_CREATOR_AUTO_BATCH_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter CreatorAutoBatch: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter CreatorAutoBatch")),
-                        }
-                }
-
-                // CreateEditgroup - POST /editgroup
-                &hyper::Method::POST if path.matched(paths::ID_EDITGROUP) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_editgroup: Option<models::Editgroup> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_editgroup) => param_editgroup,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter Editgroup - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter Editgroup due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_editgroup = match param_editgroup {
-                                    Some(param_editgroup) => param_editgroup,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter Editgroup"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter Editgroup")),
-                                };
-
-                                let result = api_impl.create_editgroup(
-                                            param_editgroup,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                CreateEditgroupResponse::SuccessfullyCreated
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_EDITGROUP_SUCCESSFULLY_CREATED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateEditgroupResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_EDITGROUP_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateEditgroupResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_EDITGROUP_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateEditgroupResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_EDITGROUP_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateEditgroupResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_EDITGROUP_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateEditgroupResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_EDITGROUP_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter Editgroup: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter Editgroup")),
-                        }
-                }
-
-                // CreateEditgroupAnnotation - POST /editgroup/{editgroup_id}/annotation
-                &hyper::Method::POST
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ANNOTATION) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_ANNOTATION
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_ANNOTATION in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_ANNOTATION.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_editgroup_annotation: Option<models::EditgroupAnnotation> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_editgroup_annotation) => param_editgroup_annotation,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter EditgroupAnnotation - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter EditgroupAnnotation due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_editgroup_annotation = match param_editgroup_annotation {
-                                    Some(param_editgroup_annotation) => param_editgroup_annotation,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter EditgroupAnnotation"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter EditgroupAnnotation")),
-                                };
-
-                                let result = api_impl.create_editgroup_annotation(
-                                            param_editgroup_id,
-                                            param_editgroup_annotation,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                CreateEditgroupAnnotationResponse::Created
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_EDITGROUP_ANNOTATION_CREATED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateEditgroupAnnotationResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_EDITGROUP_ANNOTATION_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateEditgroupAnnotationResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_EDITGROUP_ANNOTATION_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateEditgroupAnnotationResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_EDITGROUP_ANNOTATION_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateEditgroupAnnotationResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_EDITGROUP_ANNOTATION_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateEditgroupAnnotationResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_EDITGROUP_ANNOTATION_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter EditgroupAnnotation: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter EditgroupAnnotation")),
-                        }
-                }
-
-                // CreateFile - POST /editgroup/{editgroup_id}/file
-                &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_FILE
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_FILE in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_FILE.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_file_entity: Option<models::FileEntity> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_file_entity) => param_file_entity,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter FileEntity - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter FileEntity due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_file_entity = match param_file_entity {
-                                    Some(param_file_entity) => param_file_entity,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter FileEntity"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter FileEntity")),
-                                };
-
-                                let result = api_impl.create_file(
-                                            param_editgroup_id,
-                                            param_file_entity,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                CreateFileResponse::CreatedEntity
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILE_CREATED_ENTITY"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFileResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILE_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFileResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILE_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFileResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILE_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFileResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILE_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFileResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILE_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter FileEntity: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter FileEntity")),
-                        }
-                }
-
-                // CreateFileAutoBatch - POST /editgroup/auto/file/batch
-                &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_FILE_BATCH) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_file_auto_batch: Option<models::FileAutoBatch> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_file_auto_batch) => param_file_auto_batch,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter FileAutoBatch - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter FileAutoBatch due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_file_auto_batch = match param_file_auto_batch {
-                                    Some(param_file_auto_batch) => param_file_auto_batch,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter FileAutoBatch"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter FileAutoBatch")),
-                                };
-
-                                let result = api_impl.create_file_auto_batch(
-                                            param_file_auto_batch,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                CreateFileAutoBatchResponse::CreatedEditgroup
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILE_AUTO_BATCH_CREATED_EDITGROUP"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFileAutoBatchResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILE_AUTO_BATCH_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFileAutoBatchResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILE_AUTO_BATCH_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFileAutoBatchResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILE_AUTO_BATCH_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFileAutoBatchResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILE_AUTO_BATCH_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFileAutoBatchResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILE_AUTO_BATCH_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter FileAutoBatch: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter FileAutoBatch")),
-                        }
-                }
-
-                // CreateFileset - POST /editgroup/{editgroup_id}/fileset
-                &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_FILESET
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_FILESET in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_FILESET.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_fileset_entity: Option<models::FilesetEntity> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_fileset_entity) => param_fileset_entity,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter FilesetEntity - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter FilesetEntity due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_fileset_entity = match param_fileset_entity {
-                                    Some(param_fileset_entity) => param_fileset_entity,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter FilesetEntity"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter FilesetEntity")),
-                                };
-
-                                let result = api_impl.create_fileset(
-                                            param_editgroup_id,
-                                            param_fileset_entity,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                CreateFilesetResponse::CreatedEntity
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILESET_CREATED_ENTITY"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFilesetResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILESET_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFilesetResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILESET_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFilesetResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILESET_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFilesetResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILESET_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFilesetResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILESET_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter FilesetEntity: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter FilesetEntity")),
-                        }
-                }
-
-                // CreateFilesetAutoBatch - POST /editgroup/auto/fileset/batch
-                &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_FILESET_BATCH) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_fileset_auto_batch: Option<models::FilesetAutoBatch> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_fileset_auto_batch) => param_fileset_auto_batch,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter FilesetAutoBatch - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter FilesetAutoBatch due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_fileset_auto_batch = match param_fileset_auto_batch {
-                                    Some(param_fileset_auto_batch) => param_fileset_auto_batch,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter FilesetAutoBatch"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter FilesetAutoBatch")),
-                                };
-
-                                let result = api_impl.create_fileset_auto_batch(
-                                            param_fileset_auto_batch,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                CreateFilesetAutoBatchResponse::CreatedEditgroup
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILESET_AUTO_BATCH_CREATED_EDITGROUP"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFilesetAutoBatchResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILESET_AUTO_BATCH_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFilesetAutoBatchResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILESET_AUTO_BATCH_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFilesetAutoBatchResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILESET_AUTO_BATCH_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFilesetAutoBatchResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILESET_AUTO_BATCH_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateFilesetAutoBatchResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_FILESET_AUTO_BATCH_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter FilesetAutoBatch: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter FilesetAutoBatch")),
-                        }
-                }
-
-                // CreateRelease - POST /editgroup/{editgroup_id}/release
-                &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_RELEASE
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_RELEASE in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_RELEASE.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_release_entity: Option<models::ReleaseEntity> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_release_entity) => param_release_entity,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter ReleaseEntity - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter ReleaseEntity due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_release_entity = match param_release_entity {
-                                    Some(param_release_entity) => param_release_entity,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter ReleaseEntity"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter ReleaseEntity")),
-                                };
-
-                                let result = api_impl.create_release(
-                                            param_editgroup_id,
-                                            param_release_entity,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                CreateReleaseResponse::CreatedEntity
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_RELEASE_CREATED_ENTITY"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateReleaseResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_RELEASE_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateReleaseResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_RELEASE_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateReleaseResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_RELEASE_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateReleaseResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_RELEASE_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateReleaseResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_RELEASE_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter ReleaseEntity: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter ReleaseEntity")),
-                        }
-                }
-
-                // CreateReleaseAutoBatch - POST /editgroup/auto/release/batch
-                &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_RELEASE_BATCH) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_release_auto_batch: Option<models::ReleaseAutoBatch> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_release_auto_batch) => param_release_auto_batch,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter ReleaseAutoBatch - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter ReleaseAutoBatch due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_release_auto_batch = match param_release_auto_batch {
-                                    Some(param_release_auto_batch) => param_release_auto_batch,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter ReleaseAutoBatch"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter ReleaseAutoBatch")),
-                                };
-
-                                let result = api_impl.create_release_auto_batch(
-                                            param_release_auto_batch,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                CreateReleaseAutoBatchResponse::CreatedEditgroup
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_RELEASE_AUTO_BATCH_CREATED_EDITGROUP"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateReleaseAutoBatchResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_RELEASE_AUTO_BATCH_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateReleaseAutoBatchResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_RELEASE_AUTO_BATCH_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateReleaseAutoBatchResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_RELEASE_AUTO_BATCH_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateReleaseAutoBatchResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_RELEASE_AUTO_BATCH_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateReleaseAutoBatchResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_RELEASE_AUTO_BATCH_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter ReleaseAutoBatch: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter ReleaseAutoBatch")),
-                        }
-                }
-
-                // CreateWebcapture - POST /editgroup/{editgroup_id}/webcapture
-                &hyper::Method::POST
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_WEBCAPTURE in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_webcapture_entity: Option<models::WebcaptureEntity> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_webcapture_entity) => param_webcapture_entity,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter WebcaptureEntity - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter WebcaptureEntity due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_webcapture_entity = match param_webcapture_entity {
-                                    Some(param_webcapture_entity) => param_webcapture_entity,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter WebcaptureEntity"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter WebcaptureEntity")),
-                                };
-
-                                let result = api_impl.create_webcapture(
-                                            param_editgroup_id,
-                                            param_webcapture_entity,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                CreateWebcaptureResponse::CreatedEntity
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_CREATED_ENTITY"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWebcaptureResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWebcaptureResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWebcaptureResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWebcaptureResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWebcaptureResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter WebcaptureEntity: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter WebcaptureEntity")),
-                        }
-                }
-
-                // CreateWebcaptureAutoBatch - POST /editgroup/auto/webcapture/batch
-                &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_WEBCAPTURE_BATCH) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_webcapture_auto_batch: Option<models::WebcaptureAutoBatch> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_webcapture_auto_batch) => param_webcapture_auto_batch,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter WebcaptureAutoBatch - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter WebcaptureAutoBatch due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_webcapture_auto_batch = match param_webcapture_auto_batch {
-                                    Some(param_webcapture_auto_batch) => param_webcapture_auto_batch,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter WebcaptureAutoBatch"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter WebcaptureAutoBatch")),
-                                };
-
-                                let result = api_impl.create_webcapture_auto_batch(
-                                            param_webcapture_auto_batch,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                CreateWebcaptureAutoBatchResponse::CreatedEditgroup
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_AUTO_BATCH_CREATED_EDITGROUP"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWebcaptureAutoBatchResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_AUTO_BATCH_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWebcaptureAutoBatchResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_AUTO_BATCH_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWebcaptureAutoBatchResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_AUTO_BATCH_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWebcaptureAutoBatchResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_AUTO_BATCH_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWebcaptureAutoBatchResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_AUTO_BATCH_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter WebcaptureAutoBatch: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter WebcaptureAutoBatch")),
-                        }
-                }
-
-                // CreateWork - POST /editgroup/{editgroup_id}/work
-                &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_WORK
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_WORK in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_WORK.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_work_entity: Option<models::WorkEntity> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_work_entity) => param_work_entity,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter WorkEntity - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter WorkEntity due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_work_entity = match param_work_entity {
-                                    Some(param_work_entity) => param_work_entity,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter WorkEntity"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter WorkEntity")),
-                                };
-
-                                let result = api_impl.create_work(
-                                            param_editgroup_id,
-                                            param_work_entity,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                CreateWorkResponse::CreatedEntity
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WORK_CREATED_ENTITY"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWorkResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WORK_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWorkResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WORK_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWorkResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WORK_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWorkResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WORK_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWorkResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WORK_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter WorkEntity: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter WorkEntity")),
-                        }
-                }
-
-                // CreateWorkAutoBatch - POST /editgroup/auto/work/batch
-                &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_WORK_BATCH) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_work_auto_batch: Option<models::WorkAutoBatch> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_work_auto_batch) => param_work_auto_batch,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter WorkAutoBatch - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter WorkAutoBatch due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_work_auto_batch = match param_work_auto_batch {
-                                    Some(param_work_auto_batch) => param_work_auto_batch,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter WorkAutoBatch"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter WorkAutoBatch")),
-                                };
-
-                                let result = api_impl.create_work_auto_batch(
-                                            param_work_auto_batch,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                CreateWorkAutoBatchResponse::CreatedEditgroup
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WORK_AUTO_BATCH_CREATED_EDITGROUP"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWorkAutoBatchResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WORK_AUTO_BATCH_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWorkAutoBatchResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WORK_AUTO_BATCH_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWorkAutoBatchResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WORK_AUTO_BATCH_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWorkAutoBatchResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WORK_AUTO_BATCH_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                CreateWorkAutoBatchResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for CREATE_WORK_AUTO_BATCH_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter WorkAutoBatch: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter WorkAutoBatch")),
-                        }
-                }
-
-                // DeleteContainer - DELETE /editgroup/{editgroup_id}/container/{ident}
-                &hyper::Method::DELETE
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl
-                        .delete_container(param_editgroup_id, param_ident, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            DeleteContainerResponse::DeletedEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CONTAINER_DELETED_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteContainerResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CONTAINER_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteContainerResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CONTAINER_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteContainerResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CONTAINER_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteContainerResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CONTAINER_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteContainerResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CONTAINER_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // DeleteContainerEdit - DELETE /editgroup/{editgroup_id}/container/edit/{edit_id}
-                &hyper::Method::DELETE
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
-                    Ok(param_edit_id) => match param_edit_id.parse::<String>() {
-                        Ok(param_edit_id) => param_edit_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl
-                        .delete_container_edit(param_editgroup_id, param_edit_id, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            DeleteContainerEditResponse::DeletedEdit(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CONTAINER_EDIT_DELETED_EDIT"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteContainerEditResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CONTAINER_EDIT_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteContainerEditResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CONTAINER_EDIT_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteContainerEditResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CONTAINER_EDIT_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteContainerEditResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CONTAINER_EDIT_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteContainerEditResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CONTAINER_EDIT_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // DeleteCreator - DELETE /editgroup/{editgroup_id}/creator/{ident}
-                &hyper::Method::DELETE
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_CREATOR_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl
-                        .delete_creator(param_editgroup_id, param_ident, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            DeleteCreatorResponse::DeletedEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CREATOR_DELETED_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteCreatorResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CREATOR_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteCreatorResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CREATOR_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteCreatorResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CREATOR_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteCreatorResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CREATOR_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteCreatorResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CREATOR_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // DeleteCreatorEdit - DELETE /editgroup/{editgroup_id}/creator/edit/{edit_id}
-                &hyper::Method::DELETE
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
-                    Ok(param_edit_id) => match param_edit_id.parse::<String>() {
-                        Ok(param_edit_id) => param_edit_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl
-                        .delete_creator_edit(param_editgroup_id, param_edit_id, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            DeleteCreatorEditResponse::DeletedEdit(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CREATOR_EDIT_DELETED_EDIT"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteCreatorEditResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CREATOR_EDIT_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteCreatorEditResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CREATOR_EDIT_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteCreatorEditResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CREATOR_EDIT_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteCreatorEditResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CREATOR_EDIT_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteCreatorEditResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_CREATOR_EDIT_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // DeleteFile - DELETE /editgroup/{editgroup_id}/file/{ident}
-                &hyper::Method::DELETE
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE_IDENT) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_FILE_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_FILE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_FILE_IDENT.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl
-                        .delete_file(param_editgroup_id, param_ident, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            DeleteFileResponse::DeletedEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILE_DELETED_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFileResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILE_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFileResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILE_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFileResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILE_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFileResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILE_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFileResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILE_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // DeleteFileEdit - DELETE /editgroup/{editgroup_id}/file/edit/{edit_id}
-                &hyper::Method::DELETE
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
-                    Ok(param_edit_id) => match param_edit_id.parse::<String>() {
-                        Ok(param_edit_id) => param_edit_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl
-                        .delete_file_edit(param_editgroup_id, param_edit_id, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            DeleteFileEditResponse::DeletedEdit(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILE_EDIT_DELETED_EDIT"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFileEditResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILE_EDIT_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFileEditResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILE_EDIT_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFileEditResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILE_EDIT_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFileEditResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILE_EDIT_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFileEditResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILE_EDIT_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // DeleteFileset - DELETE /editgroup/{editgroup_id}/fileset/{ident}
-                &hyper::Method::DELETE
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET_IDENT) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_FILESET_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_FILESET_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_FILESET_IDENT.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl
-                        .delete_fileset(param_editgroup_id, param_ident, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            DeleteFilesetResponse::DeletedEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILESET_DELETED_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFilesetResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILESET_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFilesetResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILESET_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFilesetResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILESET_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFilesetResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILESET_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFilesetResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILESET_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // DeleteFilesetEdit - DELETE /editgroup/{editgroup_id}/fileset/edit/{edit_id}
-                &hyper::Method::DELETE
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
-                    Ok(param_edit_id) => match param_edit_id.parse::<String>() {
-                        Ok(param_edit_id) => param_edit_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl
-                        .delete_fileset_edit(param_editgroup_id, param_edit_id, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            DeleteFilesetEditResponse::DeletedEdit(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILESET_EDIT_DELETED_EDIT"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFilesetEditResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILESET_EDIT_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFilesetEditResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILESET_EDIT_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFilesetEditResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILESET_EDIT_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFilesetEditResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILESET_EDIT_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteFilesetEditResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_FILESET_EDIT_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // DeleteRelease - DELETE /editgroup/{editgroup_id}/release/{ident}
-                &hyper::Method::DELETE
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_RELEASE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl
-                        .delete_release(param_editgroup_id, param_ident, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            DeleteReleaseResponse::DeletedEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_RELEASE_DELETED_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteReleaseResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_RELEASE_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteReleaseResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_RELEASE_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteReleaseResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_RELEASE_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteReleaseResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_RELEASE_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteReleaseResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_RELEASE_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // DeleteReleaseEdit - DELETE /editgroup/{editgroup_id}/release/edit/{edit_id}
-                &hyper::Method::DELETE
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
-                    Ok(param_edit_id) => match param_edit_id.parse::<String>() {
-                        Ok(param_edit_id) => param_edit_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl
-                        .delete_release_edit(param_editgroup_id, param_edit_id, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            DeleteReleaseEditResponse::DeletedEdit(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_RELEASE_EDIT_DELETED_EDIT"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteReleaseEditResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_RELEASE_EDIT_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteReleaseEditResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_RELEASE_EDIT_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteReleaseEditResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_RELEASE_EDIT_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteReleaseEditResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_RELEASE_EDIT_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteReleaseEditResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_RELEASE_EDIT_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // DeleteWebcapture - DELETE /editgroup/{editgroup_id}/webcapture/{ident}
-                &hyper::Method::DELETE
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl
-                        .delete_webcapture(param_editgroup_id, param_ident, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            DeleteWebcaptureResponse::DeletedEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_DELETED_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWebcaptureResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWebcaptureResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWebcaptureResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWebcaptureResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWebcaptureResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // DeleteWebcaptureEdit - DELETE /editgroup/{editgroup_id}/webcapture/edit/{edit_id}
-                &hyper::Method::DELETE
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
-                    Ok(param_edit_id) => match param_edit_id.parse::<String>() {
-                        Ok(param_edit_id) => param_edit_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl
-                        .delete_webcapture_edit(param_editgroup_id, param_edit_id, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            DeleteWebcaptureEditResponse::DeletedEdit(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_EDIT_DELETED_EDIT"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWebcaptureEditResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_EDIT_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWebcaptureEditResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_EDIT_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWebcaptureEditResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_EDIT_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWebcaptureEditResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_EDIT_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWebcaptureEditResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_EDIT_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // DeleteWork - DELETE /editgroup/{editgroup_id}/work/{ident}
-                &hyper::Method::DELETE
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK_IDENT) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_WORK_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_WORK_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_WORK_IDENT.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl
-                        .delete_work(param_editgroup_id, param_ident, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            DeleteWorkResponse::DeletedEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WORK_DELETED_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWorkResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WORK_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWorkResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WORK_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWorkResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WORK_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWorkResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WORK_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWorkResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WORK_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // DeleteWorkEdit - DELETE /editgroup/{editgroup_id}/work/edit/{edit_id}
-                &hyper::Method::DELETE
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
-                    Ok(param_edit_id) => match param_edit_id.parse::<String>() {
-                        Ok(param_edit_id) => param_edit_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl
-                        .delete_work_edit(param_editgroup_id, param_edit_id, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            DeleteWorkEditResponse::DeletedEdit(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WORK_EDIT_DELETED_EDIT"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWorkEditResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WORK_EDIT_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWorkEditResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WORK_EDIT_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWorkEditResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WORK_EDIT_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWorkEditResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WORK_EDIT_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            DeleteWorkEditResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for DELETE_WORK_EDIT_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetChangelog - GET /changelog
-                &hyper::Method::GET if path.matched(paths::ID_CHANGELOG) => {
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_limit = query_params
-                        .iter()
-                        .filter(|e| e.0 == "limit")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_limit = match param_limit {
-                        Some(param_limit) => {
-                            let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
-                            match param_limit {
-                            Ok(param_limit) => Some(param_limit),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter limit")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl.get_changelog(param_limit, &context).await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetChangelogResponse::Success(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CHANGELOG_SUCCESS"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetChangelogResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CHANGELOG_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetChangelogResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CHANGELOG_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetChangelogEntry - GET /changelog/{index}
-                &hyper::Method::GET if path.matched(paths::ID_CHANGELOG_INDEX) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_CHANGELOG_INDEX
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE CHANGELOG_INDEX in set but failed match against \"{}\"", path, paths::REGEX_CHANGELOG_INDEX.as_str())
-                    );
-
-                    let param_index = match percent_encoding::percent_decode(path_params["index"].as_bytes()).decode_utf8() {
-                    Ok(param_index) => match param_index.parse::<i64>() {
-                        Ok(param_index) => param_index,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter index: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["index"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl.get_changelog_entry(param_index, &context).await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetChangelogEntryResponse::FoundChangelogEntry(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CHANGELOG_ENTRY_FOUND_CHANGELOG_ENTRY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetChangelogEntryResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CHANGELOG_ENTRY_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetChangelogEntryResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CHANGELOG_ENTRY_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetChangelogEntryResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CHANGELOG_ENTRY_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetContainer - GET /container/{ident}
-                &hyper::Method::GET if path.matched(paths::ID_CONTAINER_IDENT) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_CONTAINER_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE CONTAINER_IDENT in set but failed match against \"{}\"", path, paths::REGEX_CONTAINER_IDENT.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_container(param_ident, param_expand, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetContainerResponse::FoundEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_FOUND_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetContainerResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetContainerResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetContainerResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetContainerEdit - GET /container/edit/{edit_id}
-                &hyper::Method::GET if path.matched(paths::ID_CONTAINER_EDIT_EDIT_ID) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_CONTAINER_EDIT_EDIT_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE CONTAINER_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_CONTAINER_EDIT_EDIT_ID.as_str())
-                    );
-
-                    let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
-                    Ok(param_edit_id) => match param_edit_id.parse::<String>() {
-                        Ok(param_edit_id) => param_edit_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl.get_container_edit(param_edit_id, &context).await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetContainerEditResponse::FoundEdit(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_EDIT_FOUND_EDIT"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetContainerEditResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_EDIT_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetContainerEditResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_EDIT_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetContainerEditResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_EDIT_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetContainerHistory - GET /container/{ident}/history
-                &hyper::Method::GET if path.matched(paths::ID_CONTAINER_IDENT_HISTORY) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_CONTAINER_IDENT_HISTORY
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE CONTAINER_IDENT_HISTORY in set but failed match against \"{}\"", path, paths::REGEX_CONTAINER_IDENT_HISTORY.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_limit = query_params
-                        .iter()
-                        .filter(|e| e.0 == "limit")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_limit = match param_limit {
-                        Some(param_limit) => {
-                            let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
-                            match param_limit {
-                            Ok(param_limit) => Some(param_limit),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter limit")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_container_history(param_ident, param_limit, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetContainerHistoryResponse::FoundEntityHistory(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_HISTORY_FOUND_ENTITY_HISTORY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetContainerHistoryResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_HISTORY_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetContainerHistoryResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_HISTORY_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetContainerHistoryResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_HISTORY_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetContainerRedirects - GET /container/{ident}/redirects
-                &hyper::Method::GET if path.matched(paths::ID_CONTAINER_IDENT_REDIRECTS) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_CONTAINER_IDENT_REDIRECTS
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE CONTAINER_IDENT_REDIRECTS in set but failed match against \"{}\"", path, paths::REGEX_CONTAINER_IDENT_REDIRECTS.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl
-                        .get_container_redirects(param_ident, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetContainerRedirectsResponse::FoundEntityRedirects(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_REDIRECTS_FOUND_ENTITY_REDIRECTS"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetContainerRedirectsResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_REDIRECTS_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetContainerRedirectsResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_REDIRECTS_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetContainerRedirectsResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_REDIRECTS_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetContainerRevision - GET /container/rev/{rev_id}
-                &hyper::Method::GET if path.matched(paths::ID_CONTAINER_REV_REV_ID) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_CONTAINER_REV_REV_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE CONTAINER_REV_REV_ID in set but failed match against \"{}\"", path, paths::REGEX_CONTAINER_REV_REV_ID.as_str())
-                    );
-
-                    let param_rev_id = match percent_encoding::percent_decode(path_params["rev_id"].as_bytes()).decode_utf8() {
-                    Ok(param_rev_id) => match param_rev_id.parse::<String>() {
-                        Ok(param_rev_id) => param_rev_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter rev_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["rev_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_container_revision(param_rev_id, param_expand, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetContainerRevisionResponse::FoundEntityRevision(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_REVISION_FOUND_ENTITY_REVISION"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetContainerRevisionResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_REVISION_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetContainerRevisionResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_REVISION_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetContainerRevisionResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CONTAINER_REVISION_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetCreator - GET /creator/{ident}
-                &hyper::Method::GET if path.matched(paths::ID_CREATOR_IDENT) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_CREATOR_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE CREATOR_IDENT in set but failed match against \"{}\"", path, paths::REGEX_CREATOR_IDENT.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_creator(param_ident, param_expand, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetCreatorResponse::FoundEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_FOUND_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetCreatorEdit - GET /creator/edit/{edit_id}
-                &hyper::Method::GET if path.matched(paths::ID_CREATOR_EDIT_EDIT_ID) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_CREATOR_EDIT_EDIT_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE CREATOR_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_CREATOR_EDIT_EDIT_ID.as_str())
-                    );
-
-                    let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
-                    Ok(param_edit_id) => match param_edit_id.parse::<String>() {
-                        Ok(param_edit_id) => param_edit_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl.get_creator_edit(param_edit_id, &context).await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetCreatorEditResponse::FoundEdit(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_EDIT_FOUND_EDIT"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorEditResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_EDIT_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorEditResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_EDIT_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorEditResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_EDIT_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetCreatorHistory - GET /creator/{ident}/history
-                &hyper::Method::GET if path.matched(paths::ID_CREATOR_IDENT_HISTORY) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_CREATOR_IDENT_HISTORY
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE CREATOR_IDENT_HISTORY in set but failed match against \"{}\"", path, paths::REGEX_CREATOR_IDENT_HISTORY.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_limit = query_params
-                        .iter()
-                        .filter(|e| e.0 == "limit")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_limit = match param_limit {
-                        Some(param_limit) => {
-                            let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
-                            match param_limit {
-                            Ok(param_limit) => Some(param_limit),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter limit")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_creator_history(param_ident, param_limit, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetCreatorHistoryResponse::FoundEntityHistory(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_HISTORY_FOUND_ENTITY_HISTORY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorHistoryResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_HISTORY_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorHistoryResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_HISTORY_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorHistoryResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_HISTORY_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetCreatorRedirects - GET /creator/{ident}/redirects
-                &hyper::Method::GET if path.matched(paths::ID_CREATOR_IDENT_REDIRECTS) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_CREATOR_IDENT_REDIRECTS
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE CREATOR_IDENT_REDIRECTS in set but failed match against \"{}\"", path, paths::REGEX_CREATOR_IDENT_REDIRECTS.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl.get_creator_redirects(param_ident, &context).await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetCreatorRedirectsResponse::FoundEntityRedirects(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_REDIRECTS_FOUND_ENTITY_REDIRECTS"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorRedirectsResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_REDIRECTS_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorRedirectsResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_REDIRECTS_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorRedirectsResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_REDIRECTS_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetCreatorReleases - GET /creator/{ident}/releases
-                &hyper::Method::GET if path.matched(paths::ID_CREATOR_IDENT_RELEASES) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_CREATOR_IDENT_RELEASES
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE CREATOR_IDENT_RELEASES in set but failed match against \"{}\"", path, paths::REGEX_CREATOR_IDENT_RELEASES.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_creator_releases(param_ident, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetCreatorReleasesResponse::Found(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_RELEASES_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorReleasesResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_RELEASES_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorReleasesResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_RELEASES_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorReleasesResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_RELEASES_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetCreatorRevision - GET /creator/rev/{rev_id}
-                &hyper::Method::GET if path.matched(paths::ID_CREATOR_REV_REV_ID) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_CREATOR_REV_REV_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE CREATOR_REV_REV_ID in set but failed match against \"{}\"", path, paths::REGEX_CREATOR_REV_REV_ID.as_str())
-                    );
-
-                    let param_rev_id = match percent_encoding::percent_decode(path_params["rev_id"].as_bytes()).decode_utf8() {
-                    Ok(param_rev_id) => match param_rev_id.parse::<String>() {
-                        Ok(param_rev_id) => param_rev_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter rev_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["rev_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_creator_revision(param_rev_id, param_expand, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetCreatorRevisionResponse::FoundEntityRevision(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_REVISION_FOUND_ENTITY_REVISION"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorRevisionResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_REVISION_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorRevisionResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_REVISION_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetCreatorRevisionResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_CREATOR_REVISION_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetEditgroup - GET /editgroup/{editgroup_id}
-                &hyper::Method::GET if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl.get_editgroup(param_editgroup_id, &context).await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetEditgroupResponse::Found(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITGROUP_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditgroupResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITGROUP_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditgroupResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITGROUP_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditgroupResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITGROUP_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetEditgroupAnnotations - GET /editgroup/{editgroup_id}/annotations
-                &hyper::Method::GET
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ANNOTATIONS) =>
-                {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_ANNOTATIONS
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_ANNOTATIONS in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_ANNOTATIONS.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_editgroup_annotations(param_editgroup_id, param_expand, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetEditgroupAnnotationsResponse::Success(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITGROUP_ANNOTATIONS_SUCCESS"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditgroupAnnotationsResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITGROUP_ANNOTATIONS_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditgroupAnnotationsResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITGROUP_ANNOTATIONS_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditgroupAnnotationsResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITGROUP_ANNOTATIONS_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditgroupAnnotationsResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITGROUP_ANNOTATIONS_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditgroupAnnotationsResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITGROUP_ANNOTATIONS_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetEditgroupsReviewable - GET /editgroup/reviewable
-                &hyper::Method::GET if path.matched(paths::ID_EDITGROUP_REVIEWABLE) => {
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_limit = query_params
-                        .iter()
-                        .filter(|e| e.0 == "limit")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_limit = match param_limit {
-                        Some(param_limit) => {
-                            let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
-                            match param_limit {
-                            Ok(param_limit) => Some(param_limit),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter limit")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_before = query_params
-                        .iter()
-                        .filter(|e| e.0 == "before")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_before = match param_before {
-                        Some(param_before) => {
-                            let param_before =
-                                <chrono::DateTime<chrono::Utc> as std::str::FromStr>::from_str(
-                                    &param_before,
-                                );
-                            match param_before {
-                            Ok(param_before) => Some(param_before),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter before - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter before")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_since = query_params
-                        .iter()
-                        .filter(|e| e.0 == "since")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_since = match param_since {
-                        Some(param_since) => {
-                            let param_since =
-                                <chrono::DateTime<chrono::Utc> as std::str::FromStr>::from_str(
-                                    &param_since,
-                                );
-                            match param_since {
-                            Ok(param_since) => Some(param_since),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter since - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter since")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_editgroups_reviewable(
-                            param_expand,
-                            param_limit,
-                            param_before,
-                            param_since,
-                            &context,
-                        )
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetEditgroupsReviewableResponse::Found(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITGROUPS_REVIEWABLE_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditgroupsReviewableResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITGROUPS_REVIEWABLE_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditgroupsReviewableResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITGROUPS_REVIEWABLE_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditgroupsReviewableResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITGROUPS_REVIEWABLE_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetEditor - GET /editor/{editor_id}
-                &hyper::Method::GET if path.matched(paths::ID_EDITOR_EDITOR_ID) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITOR_EDITOR_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITOR_EDITOR_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITOR_EDITOR_ID.as_str())
-                    );
-
-                    let param_editor_id = match percent_encoding::percent_decode(path_params["editor_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editor_id) => match param_editor_id.parse::<String>() {
-                        Ok(param_editor_id) => param_editor_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editor_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editor_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl.get_editor(param_editor_id, &context).await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => {
-                            match rsp {
-                                GetEditorResponse::Found(body) => {
-                                    *response.status_mut() = StatusCode::from_u16(200)
-                                        .expect("Unable to turn 200 into a StatusCode");
-                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITOR_FOUND"));
-                                    let body = serde_json::to_string(&body)
-                                        .expect("impossible to fail to serialize");
-                                    *response.body_mut() = Body::from(body);
-                                }
-                                GetEditorResponse::BadRequest(body) => {
-                                    *response.status_mut() = StatusCode::from_u16(400)
-                                        .expect("Unable to turn 400 into a StatusCode");
-                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITOR_BAD_REQUEST"));
-                                    let body = serde_json::to_string(&body)
-                                        .expect("impossible to fail to serialize");
-                                    *response.body_mut() = Body::from(body);
-                                }
-                                GetEditorResponse::NotFound(body) => {
-                                    *response.status_mut() = StatusCode::from_u16(404)
-                                        .expect("Unable to turn 404 into a StatusCode");
-                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITOR_NOT_FOUND"));
-                                    let body = serde_json::to_string(&body)
-                                        .expect("impossible to fail to serialize");
-                                    *response.body_mut() = Body::from(body);
-                                }
-                                GetEditorResponse::GenericError(body) => {
-                                    *response.status_mut() = StatusCode::from_u16(500)
-                                        .expect("Unable to turn 500 into a StatusCode");
-                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITOR_GENERIC_ERROR"));
-                                    let body = serde_json::to_string(&body)
-                                        .expect("impossible to fail to serialize");
-                                    *response.body_mut() = Body::from(body);
-                                }
-                            }
-                        }
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetEditorAnnotations - GET /editor/{editor_id}/annotations
-                &hyper::Method::GET if path.matched(paths::ID_EDITOR_EDITOR_ID_ANNOTATIONS) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITOR_EDITOR_ID_ANNOTATIONS
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITOR_EDITOR_ID_ANNOTATIONS in set but failed match against \"{}\"", path, paths::REGEX_EDITOR_EDITOR_ID_ANNOTATIONS.as_str())
-                    );
-
-                    let param_editor_id = match percent_encoding::percent_decode(path_params["editor_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editor_id) => match param_editor_id.parse::<String>() {
-                        Ok(param_editor_id) => param_editor_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editor_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editor_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_limit = query_params
-                        .iter()
-                        .filter(|e| e.0 == "limit")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_limit = match param_limit {
-                        Some(param_limit) => {
-                            let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
-                            match param_limit {
-                            Ok(param_limit) => Some(param_limit),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter limit")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_before = query_params
-                        .iter()
-                        .filter(|e| e.0 == "before")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_before = match param_before {
-                        Some(param_before) => {
-                            let param_before =
-                                <chrono::DateTime<chrono::Utc> as std::str::FromStr>::from_str(
-                                    &param_before,
-                                );
-                            match param_before {
-                            Ok(param_before) => Some(param_before),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter before - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter before")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_since = query_params
-                        .iter()
-                        .filter(|e| e.0 == "since")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_since = match param_since {
-                        Some(param_since) => {
-                            let param_since =
-                                <chrono::DateTime<chrono::Utc> as std::str::FromStr>::from_str(
-                                    &param_since,
-                                );
-                            match param_since {
-                            Ok(param_since) => Some(param_since),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter since - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter since")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_editor_annotations(
-                            param_editor_id,
-                            param_limit,
-                            param_before,
-                            param_since,
-                            &context,
-                        )
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetEditorAnnotationsResponse::Success(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITOR_ANNOTATIONS_SUCCESS"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditorAnnotationsResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITOR_ANNOTATIONS_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditorAnnotationsResponse::NotAuthorized {
-                                body,
-                                www_authenticate,
-                            } => {
-                                if let Some(www_authenticate) = www_authenticate {
-                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                    response.headers_mut().insert(
-                                        HeaderName::from_static("www_authenticate"),
-                                        www_authenticate,
-                                    );
-                                }
-                                *response.status_mut() = StatusCode::from_u16(401)
-                                    .expect("Unable to turn 401 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITOR_ANNOTATIONS_NOT_AUTHORIZED"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditorAnnotationsResponse::Forbidden(body) => {
-                                *response.status_mut() = StatusCode::from_u16(403)
-                                    .expect("Unable to turn 403 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITOR_ANNOTATIONS_FORBIDDEN"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditorAnnotationsResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITOR_ANNOTATIONS_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditorAnnotationsResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITOR_ANNOTATIONS_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetEditorEditgroups - GET /editor/{editor_id}/editgroups
-                &hyper::Method::GET if path.matched(paths::ID_EDITOR_EDITOR_ID_EDITGROUPS) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITOR_EDITOR_ID_EDITGROUPS
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITOR_EDITOR_ID_EDITGROUPS in set but failed match against \"{}\"", path, paths::REGEX_EDITOR_EDITOR_ID_EDITGROUPS.as_str())
-                    );
-
-                    let param_editor_id = match percent_encoding::percent_decode(path_params["editor_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editor_id) => match param_editor_id.parse::<String>() {
-                        Ok(param_editor_id) => param_editor_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editor_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editor_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_limit = query_params
-                        .iter()
-                        .filter(|e| e.0 == "limit")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_limit = match param_limit {
-                        Some(param_limit) => {
-                            let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
-                            match param_limit {
-                            Ok(param_limit) => Some(param_limit),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter limit")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_before = query_params
-                        .iter()
-                        .filter(|e| e.0 == "before")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_before = match param_before {
-                        Some(param_before) => {
-                            let param_before =
-                                <chrono::DateTime<chrono::Utc> as std::str::FromStr>::from_str(
-                                    &param_before,
-                                );
-                            match param_before {
-                            Ok(param_before) => Some(param_before),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter before - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter before")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_since = query_params
-                        .iter()
-                        .filter(|e| e.0 == "since")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_since = match param_since {
-                        Some(param_since) => {
-                            let param_since =
-                                <chrono::DateTime<chrono::Utc> as std::str::FromStr>::from_str(
-                                    &param_since,
-                                );
-                            match param_since {
-                            Ok(param_since) => Some(param_since),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter since - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter since")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_editor_editgroups(
-                            param_editor_id,
-                            param_limit,
-                            param_before,
-                            param_since,
-                            &context,
-                        )
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetEditorEditgroupsResponse::Found(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITOR_EDITGROUPS_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditorEditgroupsResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITOR_EDITGROUPS_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditorEditgroupsResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITOR_EDITGROUPS_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetEditorEditgroupsResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_EDITOR_EDITGROUPS_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetFile - GET /file/{ident}
-                &hyper::Method::GET if path.matched(paths::ID_FILE_IDENT) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_FILE_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE FILE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_FILE_IDENT.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_file(param_ident, param_expand, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetFileResponse::FoundEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_FOUND_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFileResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFileResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFileResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetFileEdit - GET /file/edit/{edit_id}
-                &hyper::Method::GET if path.matched(paths::ID_FILE_EDIT_EDIT_ID) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_FILE_EDIT_EDIT_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE FILE_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_FILE_EDIT_EDIT_ID.as_str())
-                    );
-
-                    let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
-                    Ok(param_edit_id) => match param_edit_id.parse::<String>() {
-                        Ok(param_edit_id) => param_edit_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl.get_file_edit(param_edit_id, &context).await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetFileEditResponse::FoundEdit(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_EDIT_FOUND_EDIT"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFileEditResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_EDIT_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFileEditResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_EDIT_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFileEditResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_EDIT_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetFileHistory - GET /file/{ident}/history
-                &hyper::Method::GET if path.matched(paths::ID_FILE_IDENT_HISTORY) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_FILE_IDENT_HISTORY
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE FILE_IDENT_HISTORY in set but failed match against \"{}\"", path, paths::REGEX_FILE_IDENT_HISTORY.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_limit = query_params
-                        .iter()
-                        .filter(|e| e.0 == "limit")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_limit = match param_limit {
-                        Some(param_limit) => {
-                            let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
-                            match param_limit {
-                            Ok(param_limit) => Some(param_limit),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter limit")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_file_history(param_ident, param_limit, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetFileHistoryResponse::FoundEntityHistory(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_HISTORY_FOUND_ENTITY_HISTORY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFileHistoryResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_HISTORY_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFileHistoryResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_HISTORY_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFileHistoryResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_HISTORY_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetFileRedirects - GET /file/{ident}/redirects
-                &hyper::Method::GET if path.matched(paths::ID_FILE_IDENT_REDIRECTS) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_FILE_IDENT_REDIRECTS
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE FILE_IDENT_REDIRECTS in set but failed match against \"{}\"", path, paths::REGEX_FILE_IDENT_REDIRECTS.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl.get_file_redirects(param_ident, &context).await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetFileRedirectsResponse::FoundEntityRedirects(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_REDIRECTS_FOUND_ENTITY_REDIRECTS"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFileRedirectsResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_REDIRECTS_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFileRedirectsResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_REDIRECTS_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFileRedirectsResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_REDIRECTS_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetFileRevision - GET /file/rev/{rev_id}
-                &hyper::Method::GET if path.matched(paths::ID_FILE_REV_REV_ID) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_FILE_REV_REV_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE FILE_REV_REV_ID in set but failed match against \"{}\"", path, paths::REGEX_FILE_REV_REV_ID.as_str())
-                    );
-
-                    let param_rev_id = match percent_encoding::percent_decode(path_params["rev_id"].as_bytes()).decode_utf8() {
-                    Ok(param_rev_id) => match param_rev_id.parse::<String>() {
-                        Ok(param_rev_id) => param_rev_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter rev_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["rev_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_file_revision(param_rev_id, param_expand, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetFileRevisionResponse::FoundEntityRevision(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_REVISION_FOUND_ENTITY_REVISION"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFileRevisionResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_REVISION_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFileRevisionResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_REVISION_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFileRevisionResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILE_REVISION_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetFileset - GET /fileset/{ident}
-                &hyper::Method::GET if path.matched(paths::ID_FILESET_IDENT) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_FILESET_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE FILESET_IDENT in set but failed match against \"{}\"", path, paths::REGEX_FILESET_IDENT.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_fileset(param_ident, param_expand, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetFilesetResponse::FoundEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_FOUND_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFilesetResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFilesetResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFilesetResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetFilesetEdit - GET /fileset/edit/{edit_id}
-                &hyper::Method::GET if path.matched(paths::ID_FILESET_EDIT_EDIT_ID) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_FILESET_EDIT_EDIT_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE FILESET_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_FILESET_EDIT_EDIT_ID.as_str())
-                    );
-
-                    let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
-                    Ok(param_edit_id) => match param_edit_id.parse::<String>() {
-                        Ok(param_edit_id) => param_edit_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl.get_fileset_edit(param_edit_id, &context).await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetFilesetEditResponse::FoundEdit(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_EDIT_FOUND_EDIT"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFilesetEditResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_EDIT_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFilesetEditResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_EDIT_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFilesetEditResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_EDIT_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetFilesetHistory - GET /fileset/{ident}/history
-                &hyper::Method::GET if path.matched(paths::ID_FILESET_IDENT_HISTORY) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_FILESET_IDENT_HISTORY
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE FILESET_IDENT_HISTORY in set but failed match against \"{}\"", path, paths::REGEX_FILESET_IDENT_HISTORY.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_limit = query_params
-                        .iter()
-                        .filter(|e| e.0 == "limit")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_limit = match param_limit {
-                        Some(param_limit) => {
-                            let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
-                            match param_limit {
-                            Ok(param_limit) => Some(param_limit),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter limit")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_fileset_history(param_ident, param_limit, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetFilesetHistoryResponse::FoundEntityHistory(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_HISTORY_FOUND_ENTITY_HISTORY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFilesetHistoryResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_HISTORY_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFilesetHistoryResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_HISTORY_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFilesetHistoryResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_HISTORY_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetFilesetRedirects - GET /fileset/{ident}/redirects
-                &hyper::Method::GET if path.matched(paths::ID_FILESET_IDENT_REDIRECTS) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_FILESET_IDENT_REDIRECTS
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE FILESET_IDENT_REDIRECTS in set but failed match against \"{}\"", path, paths::REGEX_FILESET_IDENT_REDIRECTS.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl.get_fileset_redirects(param_ident, &context).await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetFilesetRedirectsResponse::FoundEntityRedirects(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_REDIRECTS_FOUND_ENTITY_REDIRECTS"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFilesetRedirectsResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_REDIRECTS_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFilesetRedirectsResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_REDIRECTS_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFilesetRedirectsResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_REDIRECTS_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetFilesetRevision - GET /fileset/rev/{rev_id}
-                &hyper::Method::GET if path.matched(paths::ID_FILESET_REV_REV_ID) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_FILESET_REV_REV_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE FILESET_REV_REV_ID in set but failed match against \"{}\"", path, paths::REGEX_FILESET_REV_REV_ID.as_str())
-                    );
-
-                    let param_rev_id = match percent_encoding::percent_decode(path_params["rev_id"].as_bytes()).decode_utf8() {
-                    Ok(param_rev_id) => match param_rev_id.parse::<String>() {
-                        Ok(param_rev_id) => param_rev_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter rev_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["rev_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_fileset_revision(param_rev_id, param_expand, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetFilesetRevisionResponse::FoundEntityRevision(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_REVISION_FOUND_ENTITY_REVISION"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFilesetRevisionResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_REVISION_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFilesetRevisionResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_REVISION_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetFilesetRevisionResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_FILESET_REVISION_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetRelease - GET /release/{ident}
-                &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_RELEASE_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE RELEASE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_RELEASE_IDENT.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_release(param_ident, param_expand, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetReleaseResponse::FoundEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_FOUND_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetReleaseEdit - GET /release/edit/{edit_id}
-                &hyper::Method::GET if path.matched(paths::ID_RELEASE_EDIT_EDIT_ID) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_RELEASE_EDIT_EDIT_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE RELEASE_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_RELEASE_EDIT_EDIT_ID.as_str())
-                    );
-
-                    let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
-                    Ok(param_edit_id) => match param_edit_id.parse::<String>() {
-                        Ok(param_edit_id) => param_edit_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl.get_release_edit(param_edit_id, &context).await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetReleaseEditResponse::FoundEdit(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_EDIT_FOUND_EDIT"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseEditResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_EDIT_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseEditResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_EDIT_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseEditResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_EDIT_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetReleaseFiles - GET /release/{ident}/files
-                &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_FILES) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_RELEASE_IDENT_FILES
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE RELEASE_IDENT_FILES in set but failed match against \"{}\"", path, paths::REGEX_RELEASE_IDENT_FILES.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_release_files(param_ident, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetReleaseFilesResponse::Found(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_FILES_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseFilesResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_FILES_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseFilesResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_FILES_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseFilesResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_FILES_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetReleaseFilesets - GET /release/{ident}/filesets
-                &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_FILESETS) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_RELEASE_IDENT_FILESETS
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE RELEASE_IDENT_FILESETS in set but failed match against \"{}\"", path, paths::REGEX_RELEASE_IDENT_FILESETS.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_release_filesets(param_ident, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetReleaseFilesetsResponse::Found(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_FILESETS_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseFilesetsResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_FILESETS_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseFilesetsResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_FILESETS_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseFilesetsResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_FILESETS_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetReleaseHistory - GET /release/{ident}/history
-                &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_HISTORY) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_RELEASE_IDENT_HISTORY
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE RELEASE_IDENT_HISTORY in set but failed match against \"{}\"", path, paths::REGEX_RELEASE_IDENT_HISTORY.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_limit = query_params
-                        .iter()
-                        .filter(|e| e.0 == "limit")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_limit = match param_limit {
-                        Some(param_limit) => {
-                            let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
-                            match param_limit {
-                            Ok(param_limit) => Some(param_limit),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter limit")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_release_history(param_ident, param_limit, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetReleaseHistoryResponse::FoundEntityHistory(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_HISTORY_FOUND_ENTITY_HISTORY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseHistoryResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_HISTORY_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseHistoryResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_HISTORY_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseHistoryResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_HISTORY_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetReleaseRedirects - GET /release/{ident}/redirects
-                &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_REDIRECTS) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_RELEASE_IDENT_REDIRECTS
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE RELEASE_IDENT_REDIRECTS in set but failed match against \"{}\"", path, paths::REGEX_RELEASE_IDENT_REDIRECTS.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl.get_release_redirects(param_ident, &context).await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetReleaseRedirectsResponse::FoundEntityRedirects(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_REDIRECTS_FOUND_ENTITY_REDIRECTS"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseRedirectsResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_REDIRECTS_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseRedirectsResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_REDIRECTS_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseRedirectsResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_REDIRECTS_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetReleaseRevision - GET /release/rev/{rev_id}
-                &hyper::Method::GET if path.matched(paths::ID_RELEASE_REV_REV_ID) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_RELEASE_REV_REV_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE RELEASE_REV_REV_ID in set but failed match against \"{}\"", path, paths::REGEX_RELEASE_REV_REV_ID.as_str())
-                    );
-
-                    let param_rev_id = match percent_encoding::percent_decode(path_params["rev_id"].as_bytes()).decode_utf8() {
-                    Ok(param_rev_id) => match param_rev_id.parse::<String>() {
-                        Ok(param_rev_id) => param_rev_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter rev_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["rev_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_release_revision(param_rev_id, param_expand, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetReleaseRevisionResponse::FoundEntityRevision(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_REVISION_FOUND_ENTITY_REVISION"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseRevisionResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_REVISION_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseRevisionResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_REVISION_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseRevisionResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_REVISION_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetReleaseWebcaptures - GET /release/{ident}/webcaptures
-                &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_WEBCAPTURES) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_RELEASE_IDENT_WEBCAPTURES
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE RELEASE_IDENT_WEBCAPTURES in set but failed match against \"{}\"", path, paths::REGEX_RELEASE_IDENT_WEBCAPTURES.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_release_webcaptures(param_ident, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetReleaseWebcapturesResponse::Found(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_WEBCAPTURES_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseWebcapturesResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_WEBCAPTURES_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseWebcapturesResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_WEBCAPTURES_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetReleaseWebcapturesResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_RELEASE_WEBCAPTURES_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetWebcapture - GET /webcapture/{ident}
-                &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_IDENT) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_WEBCAPTURE_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE WEBCAPTURE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_WEBCAPTURE_IDENT.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_webcapture(param_ident, param_expand, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetWebcaptureResponse::FoundEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_FOUND_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWebcaptureResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWebcaptureResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWebcaptureResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetWebcaptureEdit - GET /webcapture/edit/{edit_id}
-                &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_EDIT_EDIT_ID) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_WEBCAPTURE_EDIT_EDIT_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE WEBCAPTURE_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_WEBCAPTURE_EDIT_EDIT_ID.as_str())
-                    );
-
-                    let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
-                    Ok(param_edit_id) => match param_edit_id.parse::<String>() {
-                        Ok(param_edit_id) => param_edit_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl.get_webcapture_edit(param_edit_id, &context).await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetWebcaptureEditResponse::FoundEdit(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_EDIT_FOUND_EDIT"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWebcaptureEditResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_EDIT_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWebcaptureEditResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_EDIT_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWebcaptureEditResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_EDIT_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetWebcaptureHistory - GET /webcapture/{ident}/history
-                &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_IDENT_HISTORY) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_WEBCAPTURE_IDENT_HISTORY
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE WEBCAPTURE_IDENT_HISTORY in set but failed match against \"{}\"", path, paths::REGEX_WEBCAPTURE_IDENT_HISTORY.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_limit = query_params
-                        .iter()
-                        .filter(|e| e.0 == "limit")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_limit = match param_limit {
-                        Some(param_limit) => {
-                            let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
-                            match param_limit {
-                            Ok(param_limit) => Some(param_limit),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter limit")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_webcapture_history(param_ident, param_limit, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetWebcaptureHistoryResponse::FoundEntityHistory(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_HISTORY_FOUND_ENTITY_HISTORY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWebcaptureHistoryResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_HISTORY_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWebcaptureHistoryResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_HISTORY_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWebcaptureHistoryResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_HISTORY_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetWebcaptureRedirects - GET /webcapture/{ident}/redirects
-                &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_IDENT_REDIRECTS) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_WEBCAPTURE_IDENT_REDIRECTS
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE WEBCAPTURE_IDENT_REDIRECTS in set but failed match against \"{}\"", path, paths::REGEX_WEBCAPTURE_IDENT_REDIRECTS.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl
-                        .get_webcapture_redirects(param_ident, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetWebcaptureRedirectsResponse::FoundEntityRedirects(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_REDIRECTS_FOUND_ENTITY_REDIRECTS"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWebcaptureRedirectsResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_REDIRECTS_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWebcaptureRedirectsResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_REDIRECTS_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWebcaptureRedirectsResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_REDIRECTS_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetWebcaptureRevision - GET /webcapture/rev/{rev_id}
-                &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_REV_REV_ID) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_WEBCAPTURE_REV_REV_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE WEBCAPTURE_REV_REV_ID in set but failed match against \"{}\"", path, paths::REGEX_WEBCAPTURE_REV_REV_ID.as_str())
-                    );
-
-                    let param_rev_id = match percent_encoding::percent_decode(path_params["rev_id"].as_bytes()).decode_utf8() {
-                    Ok(param_rev_id) => match param_rev_id.parse::<String>() {
-                        Ok(param_rev_id) => param_rev_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter rev_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["rev_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_webcapture_revision(param_rev_id, param_expand, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetWebcaptureRevisionResponse::FoundEntityRevision(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_REVISION_FOUND_ENTITY_REVISION"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWebcaptureRevisionResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_REVISION_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWebcaptureRevisionResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_REVISION_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWebcaptureRevisionResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WEBCAPTURE_REVISION_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetWork - GET /work/{ident}
-                &hyper::Method::GET if path.matched(paths::ID_WORK_IDENT) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_WORK_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE WORK_IDENT in set but failed match against \"{}\"", path, paths::REGEX_WORK_IDENT.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_work(param_ident, param_expand, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetWorkResponse::FoundEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_FOUND_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetWorkEdit - GET /work/edit/{edit_id}
-                &hyper::Method::GET if path.matched(paths::ID_WORK_EDIT_EDIT_ID) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_WORK_EDIT_EDIT_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE WORK_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_WORK_EDIT_EDIT_ID.as_str())
-                    );
-
-                    let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
-                    Ok(param_edit_id) => match param_edit_id.parse::<String>() {
-                        Ok(param_edit_id) => param_edit_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl.get_work_edit(param_edit_id, &context).await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetWorkEditResponse::FoundEdit(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_EDIT_FOUND_EDIT"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkEditResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_EDIT_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkEditResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_EDIT_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkEditResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_EDIT_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetWorkHistory - GET /work/{ident}/history
-                &hyper::Method::GET if path.matched(paths::ID_WORK_IDENT_HISTORY) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_WORK_IDENT_HISTORY
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE WORK_IDENT_HISTORY in set but failed match against \"{}\"", path, paths::REGEX_WORK_IDENT_HISTORY.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_limit = query_params
-                        .iter()
-                        .filter(|e| e.0 == "limit")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_limit = match param_limit {
-                        Some(param_limit) => {
-                            let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
-                            match param_limit {
-                            Ok(param_limit) => Some(param_limit),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter limit")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_work_history(param_ident, param_limit, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetWorkHistoryResponse::FoundEntityHistory(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_HISTORY_FOUND_ENTITY_HISTORY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkHistoryResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_HISTORY_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkHistoryResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_HISTORY_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkHistoryResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_HISTORY_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetWorkRedirects - GET /work/{ident}/redirects
-                &hyper::Method::GET if path.matched(paths::ID_WORK_IDENT_REDIRECTS) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_WORK_IDENT_REDIRECTS
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE WORK_IDENT_REDIRECTS in set but failed match against \"{}\"", path, paths::REGEX_WORK_IDENT_REDIRECTS.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let result = api_impl.get_work_redirects(param_ident, &context).await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetWorkRedirectsResponse::FoundEntityRedirects(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_REDIRECTS_FOUND_ENTITY_REDIRECTS"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkRedirectsResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_REDIRECTS_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkRedirectsResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_REDIRECTS_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkRedirectsResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_REDIRECTS_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetWorkReleases - GET /work/{ident}/releases
-                &hyper::Method::GET if path.matched(paths::ID_WORK_IDENT_RELEASES) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_WORK_IDENT_RELEASES
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE WORK_IDENT_RELEASES in set but failed match against \"{}\"", path, paths::REGEX_WORK_IDENT_RELEASES.as_str())
-                    );
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_work_releases(param_ident, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetWorkReleasesResponse::Found(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_RELEASES_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkReleasesResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_RELEASES_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkReleasesResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_RELEASES_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkReleasesResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_RELEASES_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // GetWorkRevision - GET /work/rev/{rev_id}
-                &hyper::Method::GET if path.matched(paths::ID_WORK_REV_REV_ID) => {
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_WORK_REV_REV_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE WORK_REV_REV_ID in set but failed match against \"{}\"", path, paths::REGEX_WORK_REV_REV_ID.as_str())
-                    );
-
-                    let param_rev_id = match percent_encoding::percent_decode(path_params["rev_id"].as_bytes()).decode_utf8() {
-                    Ok(param_rev_id) => match param_rev_id.parse::<String>() {
-                        Ok(param_rev_id) => param_rev_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter rev_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["rev_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .get_work_revision(param_rev_id, param_expand, param_hide, &context)
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            GetWorkRevisionResponse::FoundEntityRevision(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_REVISION_FOUND_ENTITY_REVISION"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkRevisionResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_REVISION_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkRevisionResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_REVISION_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            GetWorkRevisionResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for GET_WORK_REVISION_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // LookupContainer - GET /container/lookup
-                &hyper::Method::GET if path.matched(paths::ID_CONTAINER_LOOKUP) => {
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_issnl = query_params
-                        .iter()
-                        .filter(|e| e.0 == "issnl")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_issnl = match param_issnl {
-                        Some(param_issnl) => {
-                            let param_issnl = <String as std::str::FromStr>::from_str(&param_issnl);
-                            match param_issnl {
-                            Ok(param_issnl) => Some(param_issnl),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter issnl - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter issnl")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_wikidata_qid = query_params
-                        .iter()
-                        .filter(|e| e.0 == "wikidata_qid")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_wikidata_qid = match param_wikidata_qid {
-                        Some(param_wikidata_qid) => {
-                            let param_wikidata_qid =
-                                <String as std::str::FromStr>::from_str(&param_wikidata_qid);
-                            match param_wikidata_qid {
-                            Ok(param_wikidata_qid) => Some(param_wikidata_qid),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter wikidata_qid - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter wikidata_qid")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .lookup_container(
-                            param_issnl,
-                            param_wikidata_qid,
-                            param_expand,
-                            param_hide,
-                            &context,
-                        )
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            LookupContainerResponse::FoundEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for LOOKUP_CONTAINER_FOUND_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            LookupContainerResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for LOOKUP_CONTAINER_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            LookupContainerResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for LOOKUP_CONTAINER_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            LookupContainerResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for LOOKUP_CONTAINER_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // LookupCreator - GET /creator/lookup
-                &hyper::Method::GET if path.matched(paths::ID_CREATOR_LOOKUP) => {
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_orcid = query_params
-                        .iter()
-                        .filter(|e| e.0 == "orcid")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_orcid = match param_orcid {
-                        Some(param_orcid) => {
-                            let param_orcid = <String as std::str::FromStr>::from_str(&param_orcid);
-                            match param_orcid {
-                            Ok(param_orcid) => Some(param_orcid),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter orcid - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter orcid")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_wikidata_qid = query_params
-                        .iter()
-                        .filter(|e| e.0 == "wikidata_qid")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_wikidata_qid = match param_wikidata_qid {
-                        Some(param_wikidata_qid) => {
-                            let param_wikidata_qid =
-                                <String as std::str::FromStr>::from_str(&param_wikidata_qid);
-                            match param_wikidata_qid {
-                            Ok(param_wikidata_qid) => Some(param_wikidata_qid),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter wikidata_qid - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter wikidata_qid")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .lookup_creator(
-                            param_orcid,
-                            param_wikidata_qid,
-                            param_expand,
-                            param_hide,
-                            &context,
-                        )
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            LookupCreatorResponse::FoundEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for LOOKUP_CREATOR_FOUND_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            LookupCreatorResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for LOOKUP_CREATOR_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            LookupCreatorResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for LOOKUP_CREATOR_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            LookupCreatorResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for LOOKUP_CREATOR_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // LookupFile - GET /file/lookup
-                &hyper::Method::GET if path.matched(paths::ID_FILE_LOOKUP) => {
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_md5 = query_params
-                        .iter()
-                        .filter(|e| e.0 == "md5")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_md5 = match param_md5 {
-                        Some(param_md5) => {
-                            let param_md5 = <String as std::str::FromStr>::from_str(&param_md5);
-                            match param_md5 {
-                            Ok(param_md5) => Some(param_md5),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter md5 - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter md5")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_sha1 = query_params
-                        .iter()
-                        .filter(|e| e.0 == "sha1")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_sha1 = match param_sha1 {
-                        Some(param_sha1) => {
-                            let param_sha1 = <String as std::str::FromStr>::from_str(&param_sha1);
-                            match param_sha1 {
-                            Ok(param_sha1) => Some(param_sha1),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter sha1 - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter sha1")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_sha256 = query_params
-                        .iter()
-                        .filter(|e| e.0 == "sha256")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_sha256 = match param_sha256 {
-                        Some(param_sha256) => {
-                            let param_sha256 =
-                                <String as std::str::FromStr>::from_str(&param_sha256);
-                            match param_sha256 {
-                            Ok(param_sha256) => Some(param_sha256),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter sha256 - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter sha256")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .lookup_file(
-                            param_md5,
-                            param_sha1,
-                            param_sha256,
-                            param_expand,
-                            param_hide,
-                            &context,
-                        )
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            LookupFileResponse::FoundEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for LOOKUP_FILE_FOUND_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            LookupFileResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for LOOKUP_FILE_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            LookupFileResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for LOOKUP_FILE_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            LookupFileResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for LOOKUP_FILE_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // LookupRelease - GET /release/lookup
-                &hyper::Method::GET if path.matched(paths::ID_RELEASE_LOOKUP) => {
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_doi = query_params
-                        .iter()
-                        .filter(|e| e.0 == "doi")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_doi = match param_doi {
-                        Some(param_doi) => {
-                            let param_doi = <String as std::str::FromStr>::from_str(&param_doi);
-                            match param_doi {
-                            Ok(param_doi) => Some(param_doi),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter doi - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter doi")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_wikidata_qid = query_params
-                        .iter()
-                        .filter(|e| e.0 == "wikidata_qid")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_wikidata_qid = match param_wikidata_qid {
-                        Some(param_wikidata_qid) => {
-                            let param_wikidata_qid =
-                                <String as std::str::FromStr>::from_str(&param_wikidata_qid);
-                            match param_wikidata_qid {
-                            Ok(param_wikidata_qid) => Some(param_wikidata_qid),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter wikidata_qid - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter wikidata_qid")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_isbn13 = query_params
-                        .iter()
-                        .filter(|e| e.0 == "isbn13")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_isbn13 = match param_isbn13 {
-                        Some(param_isbn13) => {
-                            let param_isbn13 =
-                                <String as std::str::FromStr>::from_str(&param_isbn13);
-                            match param_isbn13 {
-                            Ok(param_isbn13) => Some(param_isbn13),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter isbn13 - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter isbn13")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_pmid = query_params
-                        .iter()
-                        .filter(|e| e.0 == "pmid")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_pmid = match param_pmid {
-                        Some(param_pmid) => {
-                            let param_pmid = <String as std::str::FromStr>::from_str(&param_pmid);
-                            match param_pmid {
-                            Ok(param_pmid) => Some(param_pmid),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter pmid - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter pmid")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_pmcid = query_params
-                        .iter()
-                        .filter(|e| e.0 == "pmcid")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_pmcid = match param_pmcid {
-                        Some(param_pmcid) => {
-                            let param_pmcid = <String as std::str::FromStr>::from_str(&param_pmcid);
-                            match param_pmcid {
-                            Ok(param_pmcid) => Some(param_pmcid),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter pmcid - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter pmcid")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_core = query_params
-                        .iter()
-                        .filter(|e| e.0 == "core")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_core = match param_core {
-                        Some(param_core) => {
-                            let param_core = <String as std::str::FromStr>::from_str(&param_core);
-                            match param_core {
-                            Ok(param_core) => Some(param_core),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter core - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter core")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_arxiv = query_params
-                        .iter()
-                        .filter(|e| e.0 == "arxiv")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_arxiv = match param_arxiv {
-                        Some(param_arxiv) => {
-                            let param_arxiv = <String as std::str::FromStr>::from_str(&param_arxiv);
-                            match param_arxiv {
-                            Ok(param_arxiv) => Some(param_arxiv),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter arxiv - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter arxiv")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_jstor = query_params
-                        .iter()
-                        .filter(|e| e.0 == "jstor")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_jstor = match param_jstor {
-                        Some(param_jstor) => {
-                            let param_jstor = <String as std::str::FromStr>::from_str(&param_jstor);
-                            match param_jstor {
-                            Ok(param_jstor) => Some(param_jstor),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter jstor - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter jstor")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_ark = query_params
-                        .iter()
-                        .filter(|e| e.0 == "ark")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_ark = match param_ark {
-                        Some(param_ark) => {
-                            let param_ark = <String as std::str::FromStr>::from_str(&param_ark);
-                            match param_ark {
-                            Ok(param_ark) => Some(param_ark),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter ark - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter ark")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_mag = query_params
-                        .iter()
-                        .filter(|e| e.0 == "mag")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_mag = match param_mag {
-                        Some(param_mag) => {
-                            let param_mag = <String as std::str::FromStr>::from_str(&param_mag);
-                            match param_mag {
-                            Ok(param_mag) => Some(param_mag),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter mag - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter mag")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_doaj = query_params
-                        .iter()
-                        .filter(|e| e.0 == "doaj")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_doaj = match param_doaj {
-                        Some(param_doaj) => {
-                            let param_doaj = <String as std::str::FromStr>::from_str(&param_doaj);
-                            match param_doaj {
-                            Ok(param_doaj) => Some(param_doaj),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter doaj - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter doaj")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_dblp = query_params
-                        .iter()
-                        .filter(|e| e.0 == "dblp")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_dblp = match param_dblp {
-                        Some(param_dblp) => {
-                            let param_dblp = <String as std::str::FromStr>::from_str(&param_dblp);
-                            match param_dblp {
-                            Ok(param_dblp) => Some(param_dblp),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter dblp - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter dblp")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_oai = query_params
-                        .iter()
-                        .filter(|e| e.0 == "oai")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_oai = match param_oai {
-                        Some(param_oai) => {
-                            let param_oai = <String as std::str::FromStr>::from_str(&param_oai);
-                            match param_oai {
-                            Ok(param_oai) => Some(param_oai),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter oai - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter oai")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_expand = query_params
-                        .iter()
-                        .filter(|e| e.0 == "expand")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_expand = match param_expand {
-                        Some(param_expand) => {
-                            let param_expand =
-                                <String as std::str::FromStr>::from_str(&param_expand);
-                            match param_expand {
-                            Ok(param_expand) => Some(param_expand),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter expand")),
-                        }
-                        }
-                        None => None,
-                    };
-                    let param_hide = query_params
-                        .iter()
-                        .filter(|e| e.0 == "hide")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_hide = match param_hide {
-                        Some(param_hide) => {
-                            let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
-                            match param_hide {
-                            Ok(param_hide) => Some(param_hide),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter hide")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    let result = api_impl
-                        .lookup_release(
-                            param_doi,
-                            param_wikidata_qid,
-                            param_isbn13,
-                            param_pmid,
-                            param_pmcid,
-                            param_core,
-                            param_arxiv,
-                            param_jstor,
-                            param_ark,
-                            param_mag,
-                            param_doaj,
-                            param_dblp,
-                            param_oai,
-                            param_expand,
-                            param_hide,
-                            &context,
-                        )
-                        .await;
-                    let mut response = Response::new(Body::empty());
-                    response.headers_mut().insert(
-                        HeaderName::from_static("x-span-id"),
-                        HeaderValue::from_str(
-                            (&context as &dyn Has<XSpanIdString>)
-                                .get()
-                                .0
-                                .clone()
-                                .to_string()
-                                .as_str(),
-                        )
-                        .expect("Unable to create X-Span-ID header value"),
-                    );
-
-                    match result {
-                        Ok(rsp) => match rsp {
-                            LookupReleaseResponse::FoundEntity(body) => {
-                                *response.status_mut() = StatusCode::from_u16(200)
-                                    .expect("Unable to turn 200 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for LOOKUP_RELEASE_FOUND_ENTITY"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            LookupReleaseResponse::BadRequest(body) => {
-                                *response.status_mut() = StatusCode::from_u16(400)
-                                    .expect("Unable to turn 400 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for LOOKUP_RELEASE_BAD_REQUEST"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            LookupReleaseResponse::NotFound(body) => {
-                                *response.status_mut() = StatusCode::from_u16(404)
-                                    .expect("Unable to turn 404 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for LOOKUP_RELEASE_NOT_FOUND"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                            LookupReleaseResponse::GenericError(body) => {
-                                *response.status_mut() = StatusCode::from_u16(500)
-                                    .expect("Unable to turn 500 into a StatusCode");
-                                response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for LOOKUP_RELEASE_GENERIC_ERROR"));
-                                let body = serde_json::to_string(&body)
-                                    .expect("impossible to fail to serialize");
-                                *response.body_mut() = Body::from(body);
-                            }
-                        },
-                        Err(_) => {
-                            // Application code returned an error. This should not happen, as the implementation should
-                            // return a valid response.
-                            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                            *response.body_mut() = Body::from("An internal error occurred");
-                        }
-                    }
-
-                    Ok(response)
-                }
-
-                // UpdateContainer - PUT /editgroup/{editgroup_id}/container/{ident}
-                &hyper::Method::PUT
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_container_entity: Option<models::ContainerEntity> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_container_entity) => param_container_entity,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter ContainerEntity - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter ContainerEntity due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_container_entity = match param_container_entity {
-                                    Some(param_container_entity) => param_container_entity,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter ContainerEntity"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter ContainerEntity")),
-                                };
-
-                                let result = api_impl.update_container(
-                                            param_editgroup_id,
-                                            param_ident,
-                                            param_container_entity,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                UpdateContainerResponse::UpdatedEntity
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_CONTAINER_UPDATED_ENTITY"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateContainerResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_CONTAINER_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateContainerResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_CONTAINER_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateContainerResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_CONTAINER_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateContainerResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_CONTAINER_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateContainerResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_CONTAINER_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter ContainerEntity: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter ContainerEntity")),
-                        }
-                }
-
-                // UpdateCreator - PUT /editgroup/{editgroup_id}/creator/{ident}
-                &hyper::Method::PUT
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_CREATOR_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_creator_entity: Option<models::CreatorEntity> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_creator_entity) => param_creator_entity,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter CreatorEntity - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter CreatorEntity due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_creator_entity = match param_creator_entity {
-                                    Some(param_creator_entity) => param_creator_entity,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter CreatorEntity"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter CreatorEntity")),
-                                };
-
-                                let result = api_impl.update_creator(
-                                            param_editgroup_id,
-                                            param_ident,
-                                            param_creator_entity,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                UpdateCreatorResponse::UpdatedEntity
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_CREATOR_UPDATED_ENTITY"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateCreatorResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_CREATOR_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateCreatorResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_CREATOR_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateCreatorResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_CREATOR_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateCreatorResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_CREATOR_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateCreatorResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_CREATOR_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter CreatorEntity: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter CreatorEntity")),
-                        }
-                }
-
-                // UpdateEditgroup - PUT /editgroup/{editgroup_id}
-                &hyper::Method::PUT if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
-                    let query_params =
-                        form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes())
-                            .collect::<Vec<_>>();
-                    let param_submit = query_params
-                        .iter()
-                        .filter(|e| e.0 == "submit")
-                        .map(|e| e.1.to_owned())
-                        .nth(0);
-                    let param_submit = match param_submit {
-                        Some(param_submit) => {
-                            let param_submit = <bool as std::str::FromStr>::from_str(&param_submit);
-                            match param_submit {
-                            Ok(param_submit) => Some(param_submit),
-                            Err(e) => return Ok(Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Body::from(format!("Couldn't parse query parameter submit - doesn't match schema: {}", e)))
-                                .expect("Unable to create Bad Request response for invalid query parameter submit")),
-                        }
-                        }
-                        None => None,
-                    };
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_editgroup: Option<models::Editgroup> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_editgroup) => param_editgroup,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter Editgroup - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter Editgroup due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_editgroup = match param_editgroup {
-                                    Some(param_editgroup) => param_editgroup,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter Editgroup"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter Editgroup")),
-                                };
-
-                                let result = api_impl.update_editgroup(
-                                            param_editgroup_id,
-                                            param_editgroup,
-                                            param_submit,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                UpdateEditgroupResponse::UpdatedEditgroup
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_EDITGROUP_UPDATED_EDITGROUP"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateEditgroupResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_EDITGROUP_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateEditgroupResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_EDITGROUP_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateEditgroupResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_EDITGROUP_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateEditgroupResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_EDITGROUP_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateEditgroupResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_EDITGROUP_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter Editgroup: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter Editgroup")),
-                        }
-                }
-
-                // UpdateEditor - PUT /editor/{editor_id}
-                &hyper::Method::PUT if path.matched(paths::ID_EDITOR_EDITOR_ID) => {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITOR_EDITOR_ID
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITOR_EDITOR_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITOR_EDITOR_ID.as_str())
-                    );
-
-                    let param_editor_id = match percent_encoding::percent_decode(path_params["editor_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editor_id) => match param_editor_id.parse::<String>() {
-                        Ok(param_editor_id) => param_editor_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editor_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editor_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_editor: Option<models::Editor> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_editor) => param_editor,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter Editor - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter Editor due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_editor = match param_editor {
-                                    Some(param_editor) => param_editor,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter Editor"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter Editor")),
-                                };
-
-                                let result = api_impl.update_editor(
-                                            param_editor_id,
-                                            param_editor,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                UpdateEditorResponse::UpdatedEditor
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_EDITOR_UPDATED_EDITOR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateEditorResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_EDITOR_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateEditorResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_EDITOR_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateEditorResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_EDITOR_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateEditorResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_EDITOR_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateEditorResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_EDITOR_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter Editor: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter Editor")),
-                        }
-                }
-
-                // UpdateFile - PUT /editgroup/{editgroup_id}/file/{ident}
-                &hyper::Method::PUT
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE_IDENT) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_FILE_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_FILE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_FILE_IDENT.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_file_entity: Option<models::FileEntity> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_file_entity) => param_file_entity,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter FileEntity - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter FileEntity due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_file_entity = match param_file_entity {
-                                    Some(param_file_entity) => param_file_entity,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter FileEntity"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter FileEntity")),
-                                };
-
-                                let result = api_impl.update_file(
-                                            param_editgroup_id,
-                                            param_ident,
-                                            param_file_entity,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                UpdateFileResponse::UpdatedEntity
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_FILE_UPDATED_ENTITY"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateFileResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_FILE_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateFileResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_FILE_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateFileResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_FILE_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateFileResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_FILE_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateFileResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_FILE_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter FileEntity: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter FileEntity")),
-                        }
-                }
-
-                // UpdateFileset - PUT /editgroup/{editgroup_id}/fileset/{ident}
-                &hyper::Method::PUT
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET_IDENT) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_FILESET_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_FILESET_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_FILESET_IDENT.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_fileset_entity: Option<models::FilesetEntity> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_fileset_entity) => param_fileset_entity,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter FilesetEntity - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter FilesetEntity due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_fileset_entity = match param_fileset_entity {
-                                    Some(param_fileset_entity) => param_fileset_entity,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter FilesetEntity"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter FilesetEntity")),
-                                };
-
-                                let result = api_impl.update_fileset(
-                                            param_editgroup_id,
-                                            param_ident,
-                                            param_fileset_entity,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                UpdateFilesetResponse::UpdatedEntity
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_FILESET_UPDATED_ENTITY"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateFilesetResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_FILESET_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateFilesetResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_FILESET_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateFilesetResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_FILESET_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateFilesetResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_FILESET_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateFilesetResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_FILESET_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter FilesetEntity: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter FilesetEntity")),
-                        }
-                }
-
-                // UpdateRelease - PUT /editgroup/{editgroup_id}/release/{ident}
-                &hyper::Method::PUT
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_RELEASE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_release_entity: Option<models::ReleaseEntity> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_release_entity) => param_release_entity,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter ReleaseEntity - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter ReleaseEntity due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_release_entity = match param_release_entity {
-                                    Some(param_release_entity) => param_release_entity,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter ReleaseEntity"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter ReleaseEntity")),
-                                };
-
-                                let result = api_impl.update_release(
-                                            param_editgroup_id,
-                                            param_ident,
-                                            param_release_entity,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                UpdateReleaseResponse::UpdatedEntity
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_RELEASE_UPDATED_ENTITY"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateReleaseResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_RELEASE_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateReleaseResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_RELEASE_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateReleaseResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_RELEASE_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateReleaseResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_RELEASE_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateReleaseResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_RELEASE_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter ReleaseEntity: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter ReleaseEntity")),
-                        }
-                }
-
-                // UpdateWebcapture - PUT /editgroup/{editgroup_id}/webcapture/{ident}
-                &hyper::Method::PUT
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_webcapture_entity: Option<models::WebcaptureEntity> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_webcapture_entity) => param_webcapture_entity,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter WebcaptureEntity - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter WebcaptureEntity due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_webcapture_entity = match param_webcapture_entity {
-                                    Some(param_webcapture_entity) => param_webcapture_entity,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter WebcaptureEntity"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter WebcaptureEntity")),
-                                };
-
-                                let result = api_impl.update_webcapture(
-                                            param_editgroup_id,
-                                            param_ident,
-                                            param_webcapture_entity,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                UpdateWebcaptureResponse::UpdatedEntity
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_WEBCAPTURE_UPDATED_ENTITY"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateWebcaptureResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_WEBCAPTURE_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateWebcaptureResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_WEBCAPTURE_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateWebcaptureResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_WEBCAPTURE_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateWebcaptureResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_WEBCAPTURE_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateWebcaptureResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_WEBCAPTURE_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter WebcaptureEntity: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter WebcaptureEntity")),
-                        }
-                }
-
-                // UpdateWork - PUT /editgroup/{editgroup_id}/work/{ident}
-                &hyper::Method::PUT
-                    if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK_IDENT) =>
-                {
-                    {
-                        let authorization = match (&context as &dyn Has<Option<Authorization>>)
-                            .get()
-                        {
-                            &Some(ref authorization) => authorization,
-                            &None => {
-                                return Ok(Response::builder()
-                                    .status(StatusCode::FORBIDDEN)
-                                    .body(Body::from("Unauthenticated"))
-                                    .expect("Unable to create Authentication Forbidden response"))
-                            }
-                        };
-                    }
-
-                    // Path parameters
-                    let path: &str = &uri.path().to_string();
-                    let path_params =
-                    paths::REGEX_EDITGROUP_EDITGROUP_ID_WORK_IDENT
-                    .captures(&path)
-                    .unwrap_or_else(||
-                        panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_WORK_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_WORK_IDENT.as_str())
-                    );
-
-                    let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
-                    Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
-                        Ok(param_editgroup_id) => param_editgroup_id,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
-                    Ok(param_ident) => match param_ident.parse::<String>() {
-                        Ok(param_ident) => param_ident,
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid path parameter")),
-                    },
-                    Err(_) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
-                                        .expect("Unable to create Bad Request response for invalid percent decode"))
-                };
-
-                    // 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.
-                    let result = body.to_raw().await;
-                    match result {
-                            Ok(body) => {
-                                let mut unused_elements = Vec::new();
-                                let param_work_entity: Option<models::WorkEntity> = if !body.is_empty() {
-                                    let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
-                                    match serde_ignored::deserialize(deserializer, |path| {
-                                            warn!("Ignoring unknown field in body: {}", path);
-                                            unused_elements.push(path.to_string());
-                                    }) {
-                                        Ok(param_work_entity) => param_work_entity,
-                                        Err(e) => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from(format!("Couldn't parse body parameter WorkEntity - doesn't match schema: {}", e)))
-                                                        .expect("Unable to create Bad Request response for invalid body parameter WorkEntity due to schema")),
-                                    }
-                                } else {
-                                    None
-                                };
-                                let param_work_entity = match param_work_entity {
-                                    Some(param_work_entity) => param_work_entity,
-                                    None => return Ok(Response::builder()
-                                                        .status(StatusCode::BAD_REQUEST)
-                                                        .body(Body::from("Missing required body parameter WorkEntity"))
-                                                        .expect("Unable to create Bad Request response for missing body parameter WorkEntity")),
-                                };
-
-                                let result = api_impl.update_work(
-                                            param_editgroup_id,
-                                            param_ident,
-                                            param_work_entity,
-                                        &context
-                                    ).await;
-                                let mut response = Response::new(Body::empty());
-                                response.headers_mut().insert(
-                                            HeaderName::from_static("x-span-id"),
-                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
-                                                .expect("Unable to create X-Span-ID header value"));
-
-                                        if !unused_elements.is_empty() {
-                                            response.headers_mut().insert(
-                                                HeaderName::from_static("warning"),
-                                                HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
-                                                    .expect("Unable to create Warning header value"));
-                                        }
-
-                                        match result {
-                                            Ok(rsp) => match rsp {
-                                                UpdateWorkResponse::UpdatedEntity
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_WORK_UPDATED_ENTITY"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateWorkResponse::BadRequest
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_WORK_BAD_REQUEST"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateWorkResponse::NotAuthorized
-                                                    {
-                                                        body,
-                                                        www_authenticate
-                                                    }
-                                                => {
-                                                    if let Some(www_authenticate) = www_authenticate {
-                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
-                                                        Ok(val) => val,
-                                                        Err(e) => {
-                                                            return Ok(Response::builder()
-                                                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                                                    .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
-                                                                    .expect("Unable to create Internal Server Error for invalid response header"))
-                                                        }
-                                                    };
-
-                                                    response.headers_mut().insert(
-                                                        HeaderName::from_static("www_authenticate"),
-                                                        www_authenticate
-                                                    );
-                                                    }
-                                                    *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_WORK_NOT_AUTHORIZED"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateWorkResponse::Forbidden
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_WORK_FORBIDDEN"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateWorkResponse::NotFound
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_WORK_NOT_FOUND"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                                UpdateWorkResponse::GenericError
-                                                    (body)
-                                                => {
-                                                    *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
-                                                    response.headers_mut().insert(
-                                                        CONTENT_TYPE,
-                                                        HeaderValue::from_str("application/json")
-                                                            .expect("Unable to create Content-Type header for UPDATE_WORK_GENERIC_ERROR"));
-                                                    let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
-                                                    *response.body_mut() = Body::from(body);
-                                                },
-                                            },
-                                            Err(_) => {
-                                                // Application code returned an error. This should not happen, as the implementation should
-                                                // return a valid response.
-                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-                                                *response.body_mut() = Body::from("An internal error occurred");
-                                            },
-                                        }
-
-                                        Ok(response)
-                            },
-                            Err(e) => Ok(Response::builder()
-                                                .status(StatusCode::BAD_REQUEST)
-                                                .body(Body::from(format!("Couldn't read body parameter WorkEntity: {}", e)))
-                                                .expect("Unable to create Bad Request response due to unable to read body parameter WorkEntity")),
-                        }
-                }
-
-                _ if path.matched(paths::ID_AUTH_CHECK) => method_not_allowed(),
-                _ if path.matched(paths::ID_AUTH_OIDC) => method_not_allowed(),
-                _ if path.matched(paths::ID_AUTH_TOKEN_EDITOR_ID) => method_not_allowed(),
-                _ if path.matched(paths::ID_CHANGELOG) => method_not_allowed(),
-                _ if path.matched(paths::ID_CHANGELOG_INDEX) => method_not_allowed(),
-                _ if path.matched(paths::ID_CONTAINER_EDIT_EDIT_ID) => method_not_allowed(),
-                _ if path.matched(paths::ID_CONTAINER_LOOKUP) => method_not_allowed(),
-                _ if path.matched(paths::ID_CONTAINER_REV_REV_ID) => method_not_allowed(),
-                _ if path.matched(paths::ID_CONTAINER_IDENT) => method_not_allowed(),
-                _ if path.matched(paths::ID_CONTAINER_IDENT_HISTORY) => method_not_allowed(),
-                _ if path.matched(paths::ID_CONTAINER_IDENT_REDIRECTS) => method_not_allowed(),
-                _ if path.matched(paths::ID_CREATOR_EDIT_EDIT_ID) => method_not_allowed(),
-                _ if path.matched(paths::ID_CREATOR_LOOKUP) => method_not_allowed(),
-                _ if path.matched(paths::ID_CREATOR_REV_REV_ID) => method_not_allowed(),
-                _ if path.matched(paths::ID_CREATOR_IDENT) => method_not_allowed(),
-                _ if path.matched(paths::ID_CREATOR_IDENT_HISTORY) => method_not_allowed(),
-                _ if path.matched(paths::ID_CREATOR_IDENT_REDIRECTS) => method_not_allowed(),
-                _ if path.matched(paths::ID_CREATOR_IDENT_RELEASES) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITGROUP) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITGROUP_AUTO_CONTAINER_BATCH) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITGROUP_AUTO_CREATOR_BATCH) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITGROUP_AUTO_FILE_BATCH) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITGROUP_AUTO_FILESET_BATCH) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITGROUP_AUTO_RELEASE_BATCH) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITGROUP_AUTO_WEBCAPTURE_BATCH) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_AUTO_WORK_BATCH) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITGROUP_REVIEWABLE) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ACCEPT) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ANNOTATION) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ANNOTATIONS) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE_IDENT) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET_IDENT) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK_IDENT) => {
-                    method_not_allowed()
-                }
-                _ if path.matched(paths::ID_EDITOR_EDITOR_ID) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITOR_EDITOR_ID_ANNOTATIONS) => method_not_allowed(),
-                _ if path.matched(paths::ID_EDITOR_EDITOR_ID_EDITGROUPS) => method_not_allowed(),
-                _ if path.matched(paths::ID_FILE_EDIT_EDIT_ID) => method_not_allowed(),
-                _ if path.matched(paths::ID_FILE_LOOKUP) => method_not_allowed(),
-                _ if path.matched(paths::ID_FILE_REV_REV_ID) => method_not_allowed(),
-                _ if path.matched(paths::ID_FILE_IDENT) => method_not_allowed(),
-                _ if path.matched(paths::ID_FILE_IDENT_HISTORY) => method_not_allowed(),
-                _ if path.matched(paths::ID_FILE_IDENT_REDIRECTS) => method_not_allowed(),
-                _ if path.matched(paths::ID_FILESET_EDIT_EDIT_ID) => method_not_allowed(),
-                _ if path.matched(paths::ID_FILESET_REV_REV_ID) => method_not_allowed(),
-                _ if path.matched(paths::ID_FILESET_IDENT) => method_not_allowed(),
-                _ if path.matched(paths::ID_FILESET_IDENT_HISTORY) => method_not_allowed(),
-                _ if path.matched(paths::ID_FILESET_IDENT_REDIRECTS) => method_not_allowed(),
-                _ if path.matched(paths::ID_RELEASE_EDIT_EDIT_ID) => method_not_allowed(),
-                _ if path.matched(paths::ID_RELEASE_LOOKUP) => method_not_allowed(),
-                _ if path.matched(paths::ID_RELEASE_REV_REV_ID) => method_not_allowed(),
-                _ if path.matched(paths::ID_RELEASE_IDENT) => method_not_allowed(),
-                _ if path.matched(paths::ID_RELEASE_IDENT_FILES) => method_not_allowed(),
-                _ if path.matched(paths::ID_RELEASE_IDENT_FILESETS) => method_not_allowed(),
-                _ if path.matched(paths::ID_RELEASE_IDENT_HISTORY) => method_not_allowed(),
-                _ if path.matched(paths::ID_RELEASE_IDENT_REDIRECTS) => method_not_allowed(),
-                _ if path.matched(paths::ID_RELEASE_IDENT_WEBCAPTURES) => method_not_allowed(),
-                _ if path.matched(paths::ID_WEBCAPTURE_EDIT_EDIT_ID) => method_not_allowed(),
-                _ if path.matched(paths::ID_WEBCAPTURE_REV_REV_ID) => method_not_allowed(),
-                _ if path.matched(paths::ID_WEBCAPTURE_IDENT) => method_not_allowed(),
-                _ if path.matched(paths::ID_WEBCAPTURE_IDENT_HISTORY) => method_not_allowed(),
-                _ if path.matched(paths::ID_WEBCAPTURE_IDENT_REDIRECTS) => method_not_allowed(),
-                _ if path.matched(paths::ID_WORK_EDIT_EDIT_ID) => method_not_allowed(),
-                _ if path.matched(paths::ID_WORK_REV_REV_ID) => method_not_allowed(),
-                _ if path.matched(paths::ID_WORK_IDENT) => method_not_allowed(),
-                _ if path.matched(paths::ID_WORK_IDENT_HISTORY) => method_not_allowed(),
-                _ if path.matched(paths::ID_WORK_IDENT_REDIRECTS) => method_not_allowed(),
-                _ if path.matched(paths::ID_WORK_IDENT_RELEASES) => method_not_allowed(),
-                _ => Ok(Response::builder()
-                    .status(StatusCode::NOT_FOUND)
-                    .body(Body::empty())
-                    .expect("Unable to create Not Found response")),
-            }
-        }
-        Box::pin(run(self.api_impl.clone(), req))
-    }
-}
-
-/// Request parser for `Api`.
-pub struct ApiRequestParser;
-impl<T> RequestParser<T> for ApiRequestParser {
-    fn parse_operation_id(request: &Request<T>) -> Result<&'static str, ()> {
-        let path = paths::GLOBAL_REGEX_SET.matches(request.uri().path());
-        match request.method() {
-            // AcceptEditgroup - POST /editgroup/{editgroup_id}/accept
-            &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ACCEPT) => {
-                Ok("AcceptEditgroup")
-            }
-            // AuthCheck - GET /auth/check
-            &hyper::Method::GET if path.matched(paths::ID_AUTH_CHECK) => Ok("AuthCheck"),
-            // AuthOidc - POST /auth/oidc
-            &hyper::Method::POST if path.matched(paths::ID_AUTH_OIDC) => Ok("AuthOidc"),
-            // CreateAuthToken - POST /auth/token/{editor_id}
-            &hyper::Method::POST if path.matched(paths::ID_AUTH_TOKEN_EDITOR_ID) => {
-                Ok("CreateAuthToken")
-            }
-            // CreateContainer - POST /editgroup/{editgroup_id}/container
-            &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER) => {
-                Ok("CreateContainer")
-            }
-            // CreateContainerAutoBatch - POST /editgroup/auto/container/batch
-            &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_CONTAINER_BATCH) => {
-                Ok("CreateContainerAutoBatch")
-            }
-            // CreateCreator - POST /editgroup/{editgroup_id}/creator
-            &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR) => {
-                Ok("CreateCreator")
-            }
-            // CreateCreatorAutoBatch - POST /editgroup/auto/creator/batch
-            &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_CREATOR_BATCH) => {
-                Ok("CreateCreatorAutoBatch")
-            }
-            // CreateEditgroup - POST /editgroup
-            &hyper::Method::POST if path.matched(paths::ID_EDITGROUP) => Ok("CreateEditgroup"),
-            // CreateEditgroupAnnotation - POST /editgroup/{editgroup_id}/annotation
-            &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ANNOTATION) => {
-                Ok("CreateEditgroupAnnotation")
-            }
-            // CreateFile - POST /editgroup/{editgroup_id}/file
-            &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE) => {
-                Ok("CreateFile")
-            }
-            // CreateFileAutoBatch - POST /editgroup/auto/file/batch
-            &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_FILE_BATCH) => {
-                Ok("CreateFileAutoBatch")
-            }
-            // CreateFileset - POST /editgroup/{editgroup_id}/fileset
-            &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET) => {
-                Ok("CreateFileset")
-            }
-            // CreateFilesetAutoBatch - POST /editgroup/auto/fileset/batch
-            &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_FILESET_BATCH) => {
-                Ok("CreateFilesetAutoBatch")
-            }
-            // CreateRelease - POST /editgroup/{editgroup_id}/release
-            &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE) => {
-                Ok("CreateRelease")
-            }
-            // CreateReleaseAutoBatch - POST /editgroup/auto/release/batch
-            &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_RELEASE_BATCH) => {
-                Ok("CreateReleaseAutoBatch")
-            }
-            // CreateWebcapture - POST /editgroup/{editgroup_id}/webcapture
-            &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE) => {
-                Ok("CreateWebcapture")
-            }
-            // CreateWebcaptureAutoBatch - POST /editgroup/auto/webcapture/batch
-            &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_WEBCAPTURE_BATCH) => {
-                Ok("CreateWebcaptureAutoBatch")
-            }
-            // CreateWork - POST /editgroup/{editgroup_id}/work
-            &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK) => {
-                Ok("CreateWork")
-            }
-            // CreateWorkAutoBatch - POST /editgroup/auto/work/batch
-            &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_WORK_BATCH) => {
-                Ok("CreateWorkAutoBatch")
-            }
-            // DeleteContainer - DELETE /editgroup/{editgroup_id}/container/{ident}
-            &hyper::Method::DELETE
-                if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT) =>
-            {
-                Ok("DeleteContainer")
-            }
-            // DeleteContainerEdit - DELETE /editgroup/{editgroup_id}/container/edit/{edit_id}
-            &hyper::Method::DELETE
-                if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID) =>
-            {
-                Ok("DeleteContainerEdit")
-            }
-            // DeleteCreator - DELETE /editgroup/{editgroup_id}/creator/{ident}
-            &hyper::Method::DELETE
-                if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT) =>
-            {
-                Ok("DeleteCreator")
-            }
-            // DeleteCreatorEdit - DELETE /editgroup/{editgroup_id}/creator/edit/{edit_id}
-            &hyper::Method::DELETE
-                if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID) =>
-            {
-                Ok("DeleteCreatorEdit")
-            }
-            // DeleteFile - DELETE /editgroup/{editgroup_id}/file/{ident}
-            &hyper::Method::DELETE if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE_IDENT) => {
-                Ok("DeleteFile")
-            }
-            // DeleteFileEdit - DELETE /editgroup/{editgroup_id}/file/edit/{edit_id}
-            &hyper::Method::DELETE
-                if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID) =>
-            {
-                Ok("DeleteFileEdit")
-            }
-            // DeleteFileset - DELETE /editgroup/{editgroup_id}/fileset/{ident}
-            &hyper::Method::DELETE
-                if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET_IDENT) =>
-            {
-                Ok("DeleteFileset")
-            }
-            // DeleteFilesetEdit - DELETE /editgroup/{editgroup_id}/fileset/edit/{edit_id}
-            &hyper::Method::DELETE
-                if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID) =>
-            {
-                Ok("DeleteFilesetEdit")
-            }
-            // DeleteRelease - DELETE /editgroup/{editgroup_id}/release/{ident}
-            &hyper::Method::DELETE
-                if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT) =>
-            {
-                Ok("DeleteRelease")
-            }
-            // DeleteReleaseEdit - DELETE /editgroup/{editgroup_id}/release/edit/{edit_id}
-            &hyper::Method::DELETE
-                if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID) =>
-            {
-                Ok("DeleteReleaseEdit")
-            }
-            // DeleteWebcapture - DELETE /editgroup/{editgroup_id}/webcapture/{ident}
-            &hyper::Method::DELETE
-                if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT) =>
-            {
-                Ok("DeleteWebcapture")
-            }
-            // DeleteWebcaptureEdit - DELETE /editgroup/{editgroup_id}/webcapture/edit/{edit_id}
-            &hyper::Method::DELETE
-                if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID) =>
-            {
-                Ok("DeleteWebcaptureEdit")
-            }
-            // DeleteWork - DELETE /editgroup/{editgroup_id}/work/{ident}
-            &hyper::Method::DELETE if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK_IDENT) => {
-                Ok("DeleteWork")
-            }
-            // DeleteWorkEdit - DELETE /editgroup/{editgroup_id}/work/edit/{edit_id}
-            &hyper::Method::DELETE
-                if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID) =>
-            {
-                Ok("DeleteWorkEdit")
-            }
-            // GetChangelog - GET /changelog
-            &hyper::Method::GET if path.matched(paths::ID_CHANGELOG) => Ok("GetChangelog"),
-            // GetChangelogEntry - GET /changelog/{index}
-            &hyper::Method::GET if path.matched(paths::ID_CHANGELOG_INDEX) => {
-                Ok("GetChangelogEntry")
-            }
-            // GetContainer - GET /container/{ident}
-            &hyper::Method::GET if path.matched(paths::ID_CONTAINER_IDENT) => Ok("GetContainer"),
-            // GetContainerEdit - GET /container/edit/{edit_id}
-            &hyper::Method::GET if path.matched(paths::ID_CONTAINER_EDIT_EDIT_ID) => {
-                Ok("GetContainerEdit")
-            }
-            // GetContainerHistory - GET /container/{ident}/history
-            &hyper::Method::GET if path.matched(paths::ID_CONTAINER_IDENT_HISTORY) => {
-                Ok("GetContainerHistory")
-            }
-            // GetContainerRedirects - GET /container/{ident}/redirects
-            &hyper::Method::GET if path.matched(paths::ID_CONTAINER_IDENT_REDIRECTS) => {
-                Ok("GetContainerRedirects")
-            }
-            // GetContainerRevision - GET /container/rev/{rev_id}
-            &hyper::Method::GET if path.matched(paths::ID_CONTAINER_REV_REV_ID) => {
-                Ok("GetContainerRevision")
-            }
-            // GetCreator - GET /creator/{ident}
-            &hyper::Method::GET if path.matched(paths::ID_CREATOR_IDENT) => Ok("GetCreator"),
-            // GetCreatorEdit - GET /creator/edit/{edit_id}
-            &hyper::Method::GET if path.matched(paths::ID_CREATOR_EDIT_EDIT_ID) => {
-                Ok("GetCreatorEdit")
-            }
-            // GetCreatorHistory - GET /creator/{ident}/history
-            &hyper::Method::GET if path.matched(paths::ID_CREATOR_IDENT_HISTORY) => {
-                Ok("GetCreatorHistory")
-            }
-            // GetCreatorRedirects - GET /creator/{ident}/redirects
-            &hyper::Method::GET if path.matched(paths::ID_CREATOR_IDENT_REDIRECTS) => {
-                Ok("GetCreatorRedirects")
-            }
-            // GetCreatorReleases - GET /creator/{ident}/releases
-            &hyper::Method::GET if path.matched(paths::ID_CREATOR_IDENT_RELEASES) => {
-                Ok("GetCreatorReleases")
-            }
-            // GetCreatorRevision - GET /creator/rev/{rev_id}
-            &hyper::Method::GET if path.matched(paths::ID_CREATOR_REV_REV_ID) => {
-                Ok("GetCreatorRevision")
-            }
-            // GetEditgroup - GET /editgroup/{editgroup_id}
-            &hyper::Method::GET if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID) => {
-                Ok("GetEditgroup")
-            }
-            // GetEditgroupAnnotations - GET /editgroup/{editgroup_id}/annotations
-            &hyper::Method::GET if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ANNOTATIONS) => {
-                Ok("GetEditgroupAnnotations")
-            }
-            // GetEditgroupsReviewable - GET /editgroup/reviewable
-            &hyper::Method::GET if path.matched(paths::ID_EDITGROUP_REVIEWABLE) => {
-                Ok("GetEditgroupsReviewable")
-            }
-            // GetEditor - GET /editor/{editor_id}
-            &hyper::Method::GET if path.matched(paths::ID_EDITOR_EDITOR_ID) => Ok("GetEditor"),
-            // GetEditorAnnotations - GET /editor/{editor_id}/annotations
-            &hyper::Method::GET if path.matched(paths::ID_EDITOR_EDITOR_ID_ANNOTATIONS) => {
-                Ok("GetEditorAnnotations")
-            }
-            // GetEditorEditgroups - GET /editor/{editor_id}/editgroups
-            &hyper::Method::GET if path.matched(paths::ID_EDITOR_EDITOR_ID_EDITGROUPS) => {
-                Ok("GetEditorEditgroups")
-            }
-            // GetFile - GET /file/{ident}
-            &hyper::Method::GET if path.matched(paths::ID_FILE_IDENT) => Ok("GetFile"),
-            // GetFileEdit - GET /file/edit/{edit_id}
-            &hyper::Method::GET if path.matched(paths::ID_FILE_EDIT_EDIT_ID) => Ok("GetFileEdit"),
-            // GetFileHistory - GET /file/{ident}/history
-            &hyper::Method::GET if path.matched(paths::ID_FILE_IDENT_HISTORY) => {
-                Ok("GetFileHistory")
-            }
-            // GetFileRedirects - GET /file/{ident}/redirects
-            &hyper::Method::GET if path.matched(paths::ID_FILE_IDENT_REDIRECTS) => {
-                Ok("GetFileRedirects")
-            }
-            // GetFileRevision - GET /file/rev/{rev_id}
-            &hyper::Method::GET if path.matched(paths::ID_FILE_REV_REV_ID) => Ok("GetFileRevision"),
-            // GetFileset - GET /fileset/{ident}
-            &hyper::Method::GET if path.matched(paths::ID_FILESET_IDENT) => Ok("GetFileset"),
-            // GetFilesetEdit - GET /fileset/edit/{edit_id}
-            &hyper::Method::GET if path.matched(paths::ID_FILESET_EDIT_EDIT_ID) => {
-                Ok("GetFilesetEdit")
-            }
-            // GetFilesetHistory - GET /fileset/{ident}/history
-            &hyper::Method::GET if path.matched(paths::ID_FILESET_IDENT_HISTORY) => {
-                Ok("GetFilesetHistory")
-            }
-            // GetFilesetRedirects - GET /fileset/{ident}/redirects
-            &hyper::Method::GET if path.matched(paths::ID_FILESET_IDENT_REDIRECTS) => {
-                Ok("GetFilesetRedirects")
-            }
-            // GetFilesetRevision - GET /fileset/rev/{rev_id}
-            &hyper::Method::GET if path.matched(paths::ID_FILESET_REV_REV_ID) => {
-                Ok("GetFilesetRevision")
-            }
-            // GetRelease - GET /release/{ident}
-            &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT) => Ok("GetRelease"),
-            // GetReleaseEdit - GET /release/edit/{edit_id}
-            &hyper::Method::GET if path.matched(paths::ID_RELEASE_EDIT_EDIT_ID) => {
-                Ok("GetReleaseEdit")
-            }
-            // GetReleaseFiles - GET /release/{ident}/files
-            &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_FILES) => {
-                Ok("GetReleaseFiles")
-            }
-            // GetReleaseFilesets - GET /release/{ident}/filesets
-            &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_FILESETS) => {
-                Ok("GetReleaseFilesets")
-            }
-            // GetReleaseHistory - GET /release/{ident}/history
-            &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_HISTORY) => {
-                Ok("GetReleaseHistory")
-            }
-            // GetReleaseRedirects - GET /release/{ident}/redirects
-            &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_REDIRECTS) => {
-                Ok("GetReleaseRedirects")
-            }
-            // GetReleaseRevision - GET /release/rev/{rev_id}
-            &hyper::Method::GET if path.matched(paths::ID_RELEASE_REV_REV_ID) => {
-                Ok("GetReleaseRevision")
-            }
-            // GetReleaseWebcaptures - GET /release/{ident}/webcaptures
-            &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_WEBCAPTURES) => {
-                Ok("GetReleaseWebcaptures")
-            }
-            // GetWebcapture - GET /webcapture/{ident}
-            &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_IDENT) => Ok("GetWebcapture"),
-            // GetWebcaptureEdit - GET /webcapture/edit/{edit_id}
-            &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_EDIT_EDIT_ID) => {
-                Ok("GetWebcaptureEdit")
-            }
-            // GetWebcaptureHistory - GET /webcapture/{ident}/history
-            &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_IDENT_HISTORY) => {
-                Ok("GetWebcaptureHistory")
-            }
-            // GetWebcaptureRedirects - GET /webcapture/{ident}/redirects
-            &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_IDENT_REDIRECTS) => {
-                Ok("GetWebcaptureRedirects")
-            }
-            // GetWebcaptureRevision - GET /webcapture/rev/{rev_id}
-            &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_REV_REV_ID) => {
-                Ok("GetWebcaptureRevision")
-            }
-            // GetWork - GET /work/{ident}
-            &hyper::Method::GET if path.matched(paths::ID_WORK_IDENT) => Ok("GetWork"),
-            // GetWorkEdit - GET /work/edit/{edit_id}
-            &hyper::Method::GET if path.matched(paths::ID_WORK_EDIT_EDIT_ID) => Ok("GetWorkEdit"),
-            // GetWorkHistory - GET /work/{ident}/history
-            &hyper::Method::GET if path.matched(paths::ID_WORK_IDENT_HISTORY) => {
-                Ok("GetWorkHistory")
-            }
-            // GetWorkRedirects - GET /work/{ident}/redirects
-            &hyper::Method::GET if path.matched(paths::ID_WORK_IDENT_REDIRECTS) => {
-                Ok("GetWorkRedirects")
-            }
-            // GetWorkReleases - GET /work/{ident}/releases
-            &hyper::Method::GET if path.matched(paths::ID_WORK_IDENT_RELEASES) => {
-                Ok("GetWorkReleases")
-            }
-            // GetWorkRevision - GET /work/rev/{rev_id}
-            &hyper::Method::GET if path.matched(paths::ID_WORK_REV_REV_ID) => Ok("GetWorkRevision"),
-            // LookupContainer - GET /container/lookup
-            &hyper::Method::GET if path.matched(paths::ID_CONTAINER_LOOKUP) => {
-                Ok("LookupContainer")
-            }
-            // LookupCreator - GET /creator/lookup
-            &hyper::Method::GET if path.matched(paths::ID_CREATOR_LOOKUP) => Ok("LookupCreator"),
-            // LookupFile - GET /file/lookup
-            &hyper::Method::GET if path.matched(paths::ID_FILE_LOOKUP) => Ok("LookupFile"),
-            // LookupRelease - GET /release/lookup
-            &hyper::Method::GET if path.matched(paths::ID_RELEASE_LOOKUP) => Ok("LookupRelease"),
-            // UpdateContainer - PUT /editgroup/{editgroup_id}/container/{ident}
-            &hyper::Method::PUT
-                if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT) =>
-            {
-                Ok("UpdateContainer")
-            }
-            // UpdateCreator - PUT /editgroup/{editgroup_id}/creator/{ident}
-            &hyper::Method::PUT if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT) => {
-                Ok("UpdateCreator")
-            }
-            // UpdateEditgroup - PUT /editgroup/{editgroup_id}
-            &hyper::Method::PUT if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID) => {
-                Ok("UpdateEditgroup")
-            }
-            // UpdateEditor - PUT /editor/{editor_id}
-            &hyper::Method::PUT if path.matched(paths::ID_EDITOR_EDITOR_ID) => Ok("UpdateEditor"),
-            // UpdateFile - PUT /editgroup/{editgroup_id}/file/{ident}
-            &hyper::Method::PUT if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE_IDENT) => {
-                Ok("UpdateFile")
-            }
-            // UpdateFileset - PUT /editgroup/{editgroup_id}/fileset/{ident}
-            &hyper::Method::PUT if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET_IDENT) => {
-                Ok("UpdateFileset")
-            }
-            // UpdateRelease - PUT /editgroup/{editgroup_id}/release/{ident}
-            &hyper::Method::PUT if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT) => {
-                Ok("UpdateRelease")
-            }
-            // UpdateWebcapture - PUT /editgroup/{editgroup_id}/webcapture/{ident}
-            &hyper::Method::PUT
-                if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT) =>
-            {
-                Ok("UpdateWebcapture")
-            }
-            // UpdateWork - PUT /editgroup/{editgroup_id}/work/{ident}
-            &hyper::Method::PUT if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK_IDENT) => {
-                Ok("UpdateWork")
-            }
-            _ => Err(()),
-        }
-    }
-}