move source code to top-level directory

6 files changed, 43745 insertions, 0 deletions

diff --git a/fatcat-openapi/src/client/mod.rs b/fatcat-openapi/src/client/mod.rs
new file mode 100644
index 0000000..bb1cee8
--- /dev/null
+++ b/fatcat-openapi/src/client/mod.rs
@@ -0,0 +1,16107 @@
+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/fatcat-openapi/src/context.rs b/fatcat-openapi/src/context.rs
new file mode 100644
index 0000000..d782855
--- /dev/null
+++ b/fatcat-openapi/src/context.rs
@@ -0,0 +1,120 @@
+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/fatcat-openapi/src/header.rs b/fatcat-openapi/src/header.rs
new file mode 100644
index 0000000..7589ab0
--- /dev/null
+++ b/fatcat-openapi/src/header.rs
@@ -0,0 +1,197 @@
+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/fatcat-openapi/src/lib.rs b/fatcat-openapi/src/lib.rs
new file mode 100644
index 0000000..ba49f27
--- /dev/null
+++ b/fatcat-openapi/src/lib.rs
@@ -0,0 +1,3844 @@
+#![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/fatcat-openapi/src/models.rs b/fatcat-openapi/src/models.rs
new file mode 100644
index 0000000..d642c62
--- /dev/null
+++ b/fatcat-openapi/src/models.rs
@@ -0,0 +1,7621 @@
+#![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/fatcat-openapi/src/server/mod.rs b/fatcat-openapi/src/server/mod.rs
new file mode 100644
index 0000000..ac07c6e
--- /dev/null
+++ b/fatcat-openapi/src/server/mod.rs
@@ -0,0 +1,15856 @@
+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(()),
+        }
+    }
+}