copy codegen rust openapi client from fatcat repo

6 files changed, 47005 insertions, 0 deletions

diff --git a/rust/fatcat-openapi/src/client/mod.rs b/rust/fatcat-openapi/src/client/mod.rs
new file mode 100644
index 0000000..06ecf4c
--- /dev/null
+++ b/rust/fatcat-openapi/src/client/mod.rs
@@ -0,0 +1,20348 @@
+use futures;
+use futures::{future, stream, Future, Stream};
+use hyper;
+use hyper::client::HttpConnector;
+use hyper::header::{HeaderName, HeaderValue, CONTENT_TYPE};
+use hyper::{Body, Response, Uri};
+#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
+use hyper_openssl::HttpsConnector;
+use serde_json;
+use std::borrow::Cow;
+use std::convert::TryInto;
+use std::error;
+use std::fmt;
+use std::io::{Error, ErrorKind, Read};
+use std::path::Path;
+use std::str;
+use std::str::FromStr;
+use std::string::ToString;
+use std::sync::Arc;
+use swagger;
+use swagger::{client::Service, ApiError, AuthData, Connector, Has, XSpanIdString};
+use url::form_urlencoded;
+use url::percent_encoding::{utf8_percent_encode, PATH_SEGMENT_ENCODE_SET, QUERY_ENCODE_SET};
+
+use crate::header;
+use crate::models;
+
+url::define_encode_set! {
+    /// 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.
+    pub ID_ENCODE_SET = [PATH_SEGMENT_ENCODE_SET] | {'|'}
+}
+
+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: &str,
+    correct_scheme: Option<&'static str>,
+) -> Result<String, ClientInitError> {
+    // First convert to Uri, since a base path is a subset of Uri.
+    let uri = Uri::from_str(input)?;
+
+    let scheme = uri.scheme_part().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_part()
+        .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<F> {
+    /// Inner service
+    client_service: Arc<Box<dyn Service<ReqBody = Body, Future = F> + Send + Sync>>,
+
+    /// Base path of the API
+    base_path: String,
+}
+
+impl<F> fmt::Debug for Client<F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Client {{ base_path: {} }}", self.base_path)
+    }
+}
+
+impl<F> Clone for Client<F> {
+    fn clone(&self) -> Self {
+        Client {
+            client_service: self.client_service.clone(),
+            base_path: self.base_path.clone(),
+        }
+    }
+}
+
+impl Client<hyper::client::ResponseFuture> {
+    /// 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. "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<C>(
+        base_path: &str,
+        protocol: Option<&'static str>,
+        connector: C,
+    ) -> Result<Self, ClientInitError>
+    where
+        C: hyper::client::connect::Connect + 'static,
+        C::Transport: 'static,
+        C::Future: 'static,
+    {
+        let client_service = Box::new(hyper::client::Client::builder().build(connector));
+
+        Ok(Client {
+            client_service: Arc::new(client_service),
+            base_path: into_base_path(base_path, protocol)?,
+        })
+    }
+
+    /// Create an HTTP client.
+    ///
+    /// # Arguments
+    /// * `base_path` - base path of the client API, i.e. "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)
+    }
+
+    /// Create a client with a TLS connection to the server
+    ///
+    /// # Arguments
+    /// * `base_path` - base path of the client API, i.e. "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. "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. "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<F> Client<F> {
+    /// Constructor for creating a `Client` by passing in a pre-made `swagger::Service`
+    ///
+    /// This allows adding custom wrappers around the underlying transport, for example for logging.
+    pub fn try_new_with_client_service(
+        client_service: Arc<Box<dyn Service<ReqBody = Body, Future = F> + Send + Sync>>,
+        base_path: &str,
+    ) -> Result<Self, ClientInitError> {
+        Ok(Client {
+            client_service: client_service,
+            base_path: into_base_path(base_path, None)?,
+        })
+    }
+}
+
+/// 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::Error for ClientInitError {
+    fn description(&self) -> &str {
+        "Failed to produce a hyper client."
+    }
+}
+
+impl<C, F> Api<C> for Client<F>
+where
+    C: Has<XSpanIdString> + Has<Option<AuthData>>,
+    F: Future<Item = Response<Body>, Error = hyper::Error> + Send + 'static,
+{
+    fn accept_editgroup(
+        &self,
+        param_editgroup_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = AcceptEditgroupResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Success>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AcceptEditgroupResponse::MergedSuccessfully
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AcceptEditgroupResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AcceptEditgroupResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AcceptEditgroupResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AcceptEditgroupResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                409 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AcceptEditgroupResponse::EditConflict
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AcceptEditgroupResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn auth_check(
+        &self,
+        param_role: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = AuthCheckResponse, Error = ApiError> + Send> {
+        let mut uri = format!("{}/v0/auth/check", self.base_path);
+
+        // Query parameters
+        let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        if let Some(param_role) = param_role {
+            query_string.append_pair("role", &param_role.to_string());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Success>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AuthCheckResponse::Success
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AuthCheckResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AuthCheckResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AuthCheckResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AuthCheckResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn auth_oidc(
+        &self,
+        param_auth_oidc: models::AuthOidc,
+        context: &C,
+    ) -> Box<dyn Future<Item = AuthOidcResponse, Error = ApiError> + Send> {
+        let mut uri = format!("{}/v0/auth/oidc", self.base_path);
+
+        // Query parameters
+        let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::AuthOidcResult>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AuthOidcResponse::Found
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                201 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::AuthOidcResult>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AuthOidcResponse::Created
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AuthOidcResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AuthOidcResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AuthOidcResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                409 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AuthOidcResponse::Conflict
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            AuthOidcResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn create_auth_token(
+        &self,
+        param_editor_id: String,
+        param_duration_seconds: Option<i32>,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateAuthTokenResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::AuthTokenResult>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateAuthTokenResponse::Success
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateAuthTokenResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateAuthTokenResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateAuthTokenResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateAuthTokenResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn create_container(
+        &self,
+        param_editgroup_id: String,
+        param_container_entity: models::ContainerEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateContainerResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                201 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateContainerResponse::CreatedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateContainerResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateContainerResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateContainerResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateContainerResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateContainerResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn create_container_auto_batch(
+        &self,
+        param_container_auto_batch: models::ContainerAutoBatch,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateContainerAutoBatchResponse, Error = ApiError> + Send> {
+        let mut uri = format!("{}/v0/editgroup/auto/container/batch", self.base_path);
+
+        // Query parameters
+        let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                201 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Editgroup>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateContainerAutoBatchResponse::CreatedEditgroup
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateContainerAutoBatchResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateContainerAutoBatchResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateContainerAutoBatchResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateContainerAutoBatchResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateContainerAutoBatchResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn create_creator(
+        &self,
+        param_editgroup_id: String,
+        param_creator_entity: models::CreatorEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateCreatorResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                201 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateCreatorResponse::CreatedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateCreatorResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateCreatorResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateCreatorResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateCreatorResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateCreatorResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn create_creator_auto_batch(
+        &self,
+        param_creator_auto_batch: models::CreatorAutoBatch,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateCreatorAutoBatchResponse, Error = ApiError> + Send> {
+        let mut uri = format!("{}/v0/editgroup/auto/creator/batch", self.base_path);
+
+        // Query parameters
+        let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                201 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Editgroup>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateCreatorAutoBatchResponse::CreatedEditgroup
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateCreatorAutoBatchResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateCreatorAutoBatchResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateCreatorAutoBatchResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateCreatorAutoBatchResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateCreatorAutoBatchResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn create_editgroup(
+        &self,
+        param_editgroup: models::Editgroup,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateEditgroupResponse, Error = ApiError> + Send> {
+        let mut uri = format!("{}/v0/editgroup", self.base_path);
+
+        // Query parameters
+        let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                201 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Editgroup>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateEditgroupResponse::SuccessfullyCreated
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateEditgroupResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateEditgroupResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateEditgroupResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateEditgroupResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateEditgroupResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn create_editgroup_annotation(
+        &self,
+        param_editgroup_id: String,
+        param_editgroup_annotation: models::EditgroupAnnotation,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateEditgroupAnnotationResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                201 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EditgroupAnnotation>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateEditgroupAnnotationResponse::Created
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateEditgroupAnnotationResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateEditgroupAnnotationResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateEditgroupAnnotationResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateEditgroupAnnotationResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateEditgroupAnnotationResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn create_file(
+        &self,
+        param_editgroup_id: String,
+        param_file_entity: models::FileEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateFileResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                201 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFileResponse::CreatedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFileResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFileResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFileResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFileResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFileResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn create_file_auto_batch(
+        &self,
+        param_file_auto_batch: models::FileAutoBatch,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateFileAutoBatchResponse, Error = ApiError> + Send> {
+        let mut uri = format!("{}/v0/editgroup/auto/file/batch", self.base_path);
+
+        // Query parameters
+        let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                201 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Editgroup>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFileAutoBatchResponse::CreatedEditgroup
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFileAutoBatchResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFileAutoBatchResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFileAutoBatchResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFileAutoBatchResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFileAutoBatchResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn create_fileset(
+        &self,
+        param_editgroup_id: String,
+        param_fileset_entity: models::FilesetEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateFilesetResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                201 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFilesetResponse::CreatedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFilesetResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFilesetResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFilesetResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFilesetResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFilesetResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn create_fileset_auto_batch(
+        &self,
+        param_fileset_auto_batch: models::FilesetAutoBatch,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateFilesetAutoBatchResponse, Error = ApiError> + Send> {
+        let mut uri = format!("{}/v0/editgroup/auto/fileset/batch", self.base_path);
+
+        // Query parameters
+        let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                201 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Editgroup>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFilesetAutoBatchResponse::CreatedEditgroup
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFilesetAutoBatchResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFilesetAutoBatchResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFilesetAutoBatchResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFilesetAutoBatchResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateFilesetAutoBatchResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn create_release(
+        &self,
+        param_editgroup_id: String,
+        param_release_entity: models::ReleaseEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateReleaseResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                201 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateReleaseResponse::CreatedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateReleaseResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateReleaseResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateReleaseResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateReleaseResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateReleaseResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn create_release_auto_batch(
+        &self,
+        param_release_auto_batch: models::ReleaseAutoBatch,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateReleaseAutoBatchResponse, Error = ApiError> + Send> {
+        let mut uri = format!("{}/v0/editgroup/auto/release/batch", self.base_path);
+
+        // Query parameters
+        let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                201 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Editgroup>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateReleaseAutoBatchResponse::CreatedEditgroup
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateReleaseAutoBatchResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateReleaseAutoBatchResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateReleaseAutoBatchResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateReleaseAutoBatchResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateReleaseAutoBatchResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn create_webcapture(
+        &self,
+        param_editgroup_id: String,
+        param_webcapture_entity: models::WebcaptureEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateWebcaptureResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                201 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWebcaptureResponse::CreatedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWebcaptureResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWebcaptureResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWebcaptureResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWebcaptureResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWebcaptureResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn create_webcapture_auto_batch(
+        &self,
+        param_webcapture_auto_batch: models::WebcaptureAutoBatch,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateWebcaptureAutoBatchResponse, Error = ApiError> + Send> {
+        let mut uri = format!("{}/v0/editgroup/auto/webcapture/batch", self.base_path);
+
+        // Query parameters
+        let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                201 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Editgroup>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWebcaptureAutoBatchResponse::CreatedEditgroup
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWebcaptureAutoBatchResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWebcaptureAutoBatchResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWebcaptureAutoBatchResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWebcaptureAutoBatchResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWebcaptureAutoBatchResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn create_work(
+        &self,
+        param_editgroup_id: String,
+        param_work_entity: models::WorkEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateWorkResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                201 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWorkResponse::CreatedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWorkResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWorkResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWorkResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWorkResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWorkResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn create_work_auto_batch(
+        &self,
+        param_work_auto_batch: models::WorkAutoBatch,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateWorkAutoBatchResponse, Error = ApiError> + Send> {
+        let mut uri = format!("{}/v0/editgroup/auto/work/batch", self.base_path);
+
+        // Query parameters
+        let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("POST")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                201 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Editgroup>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWorkAutoBatchResponse::CreatedEditgroup
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWorkAutoBatchResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWorkAutoBatchResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWorkAutoBatchResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWorkAutoBatchResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            CreateWorkAutoBatchResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn delete_container(
+        &self,
+        param_editgroup_id: String,
+        param_ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteContainerResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("DELETE")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteContainerResponse::DeletedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteContainerResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteContainerResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteContainerResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteContainerResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteContainerResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn delete_container_edit(
+        &self,
+        param_editgroup_id: String,
+        param_edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteContainerEditResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("DELETE")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Success>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteContainerEditResponse::DeletedEdit
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteContainerEditResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteContainerEditResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteContainerEditResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteContainerEditResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteContainerEditResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn delete_creator(
+        &self,
+        param_editgroup_id: String,
+        param_ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteCreatorResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("DELETE")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteCreatorResponse::DeletedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteCreatorResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteCreatorResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteCreatorResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteCreatorResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteCreatorResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn delete_creator_edit(
+        &self,
+        param_editgroup_id: String,
+        param_edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteCreatorEditResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("DELETE")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Success>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteCreatorEditResponse::DeletedEdit
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteCreatorEditResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteCreatorEditResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteCreatorEditResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteCreatorEditResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteCreatorEditResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn delete_file(
+        &self,
+        param_editgroup_id: String,
+        param_ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteFileResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("DELETE")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFileResponse::DeletedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFileResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFileResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFileResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFileResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFileResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn delete_file_edit(
+        &self,
+        param_editgroup_id: String,
+        param_edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteFileEditResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("DELETE")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Success>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFileEditResponse::DeletedEdit
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFileEditResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFileEditResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFileEditResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFileEditResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFileEditResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn delete_fileset(
+        &self,
+        param_editgroup_id: String,
+        param_ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteFilesetResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("DELETE")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFilesetResponse::DeletedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFilesetResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFilesetResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFilesetResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFilesetResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFilesetResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn delete_fileset_edit(
+        &self,
+        param_editgroup_id: String,
+        param_edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteFilesetEditResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("DELETE")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Success>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFilesetEditResponse::DeletedEdit
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFilesetEditResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFilesetEditResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFilesetEditResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFilesetEditResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteFilesetEditResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn delete_release(
+        &self,
+        param_editgroup_id: String,
+        param_ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteReleaseResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("DELETE")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteReleaseResponse::DeletedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteReleaseResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteReleaseResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteReleaseResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteReleaseResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteReleaseResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn delete_release_edit(
+        &self,
+        param_editgroup_id: String,
+        param_edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteReleaseEditResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("DELETE")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Success>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteReleaseEditResponse::DeletedEdit
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteReleaseEditResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteReleaseEditResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteReleaseEditResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteReleaseEditResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteReleaseEditResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn delete_webcapture(
+        &self,
+        param_editgroup_id: String,
+        param_ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteWebcaptureResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("DELETE")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWebcaptureResponse::DeletedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWebcaptureResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWebcaptureResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWebcaptureResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWebcaptureResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWebcaptureResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn delete_webcapture_edit(
+        &self,
+        param_editgroup_id: String,
+        param_edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteWebcaptureEditResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("DELETE")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Success>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWebcaptureEditResponse::DeletedEdit
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWebcaptureEditResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWebcaptureEditResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWebcaptureEditResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWebcaptureEditResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWebcaptureEditResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn delete_work(
+        &self,
+        param_editgroup_id: String,
+        param_ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteWorkResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("DELETE")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWorkResponse::DeletedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWorkResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWorkResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWorkResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWorkResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWorkResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn delete_work_edit(
+        &self,
+        param_editgroup_id: String,
+        param_edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteWorkEditResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("DELETE")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Success>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWorkEditResponse::DeletedEdit
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWorkEditResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWorkEditResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWorkEditResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWorkEditResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            DeleteWorkEditResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn get_changelog(
+        &self,
+        param_limit: Option<i64>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetChangelogResponse, Error = ApiError> + Send> {
+        let mut uri = format!("{}/v0/changelog", self.base_path);
+
+        // Query parameters
+        let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        if let Some(param_limit) = param_limit {
+            query_string.append_pair("limit", &param_limit.to_string());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<models::ChangelogEntry>>(
+                                                body,
+                                            )
+                                            .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetChangelogResponse::Success(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetChangelogResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetChangelogResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_changelog_entry(
+        &self,
+        param_index: i64,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetChangelogEntryResponse, Error = ApiError> + Send> {
+        let mut uri = format!(
+            "{}/v0/changelog/{index}",
+            self.base_path,
+            index = utf8_percent_encode(&param_index.to_string(), ID_ENCODE_SET)
+        );
+
+        // Query parameters
+        let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ChangelogEntry>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetChangelogEntryResponse::FoundChangelogEntry(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetChangelogEntryResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetChangelogEntryResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetChangelogEntryResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_container(
+        &self,
+        param_ident: String,
+        param_expand: Option<String>,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetContainerResponse, Error = ApiError> + Send> {
+        let mut uri = format!(
+            "{}/v0/container/{ident}",
+            self.base_path,
+            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
+        );
+
+        // Query parameters
+        let mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ContainerEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetContainerResponse::FoundEntity(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetContainerResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetContainerResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetContainerResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_container_edit(
+        &self,
+        param_edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetContainerEditResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::EntityEdit>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetContainerEditResponse::FoundEdit(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetContainerEditResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetContainerEditResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetContainerEditResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_container_history(
+        &self,
+        param_ident: String,
+        param_limit: Option<i64>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetContainerHistoryResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        if let Some(param_limit) = param_limit {
+            query_string.append_pair("limit", &param_limit.to_string());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<models::EntityHistoryEntry>>(
+                                                body,
+                                            )
+                                            .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetContainerHistoryResponse::FoundEntityHistory(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetContainerHistoryResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetContainerHistoryResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetContainerHistoryResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_container_redirects(
+        &self,
+        param_ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetContainerRedirectsResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<String>>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetContainerRedirectsResponse::FoundEntityRedirects(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetContainerRedirectsResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetContainerRedirectsResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetContainerRedirectsResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_container_revision(
+        &self,
+        param_rev_id: String,
+        param_expand: Option<String>,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetContainerRevisionResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ContainerEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetContainerRevisionResponse::FoundEntityRevision(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetContainerRevisionResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetContainerRevisionResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetContainerRevisionResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_creator(
+        &self,
+        param_ident: String,
+        param_expand: Option<String>,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetCreatorResponse, Error = ApiError> + Send> {
+        let mut uri = format!(
+            "{}/v0/creator/{ident}",
+            self.base_path,
+            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
+        );
+
+        // Query parameters
+        let mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::CreatorEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorResponse::FoundEntity(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_creator_edit(
+        &self,
+        param_edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetCreatorEditResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::EntityEdit>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorEditResponse::FoundEdit(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorEditResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorEditResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorEditResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_creator_history(
+        &self,
+        param_ident: String,
+        param_limit: Option<i64>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetCreatorHistoryResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        if let Some(param_limit) = param_limit {
+            query_string.append_pair("limit", &param_limit.to_string());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<models::EntityHistoryEntry>>(
+                                                body,
+                                            )
+                                            .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetCreatorHistoryResponse::FoundEntityHistory(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorHistoryResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorHistoryResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorHistoryResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_creator_redirects(
+        &self,
+        param_ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetCreatorRedirectsResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<String>>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetCreatorRedirectsResponse::FoundEntityRedirects(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorRedirectsResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorRedirectsResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorRedirectsResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_creator_releases(
+        &self,
+        param_ident: String,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetCreatorReleasesResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        if let Some(param_hide) = param_hide {
+            query_string.append_pair("hide", &param_hide.to_string());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<models::ReleaseEntity>>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorReleasesResponse::Found(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorReleasesResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorReleasesResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorReleasesResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_creator_revision(
+        &self,
+        param_rev_id: String,
+        param_expand: Option<String>,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetCreatorRevisionResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::CreatorEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetCreatorRevisionResponse::FoundEntityRevision(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorRevisionResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorRevisionResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetCreatorRevisionResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_editgroup(
+        &self,
+        param_editgroup_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetEditgroupResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::Editgroup>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetEditgroupResponse::Found(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetEditgroupResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetEditgroupResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetEditgroupResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_editgroup_annotations(
+        &self,
+        param_editgroup_id: String,
+        param_expand: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetEditgroupAnnotationsResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        if let Some(param_expand) = param_expand {
+            query_string.append_pair("expand", &param_expand.to_string());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<Vec<models::EditgroupAnnotation>>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            GetEditgroupAnnotationsResponse::Success
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            GetEditgroupAnnotationsResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            GetEditgroupAnnotationsResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            GetEditgroupAnnotationsResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            GetEditgroupAnnotationsResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            GetEditgroupAnnotationsResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    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,
+    ) -> Box<dyn Future<Item = GetEditgroupsReviewableResponse, Error = ApiError> + Send> {
+        let mut uri = format!("{}/v0/editgroup/reviewable", self.base_path);
+
+        // Query parameters
+        let mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<models::Editgroup>>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetEditgroupsReviewableResponse::Found(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetEditgroupsReviewableResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetEditgroupsReviewableResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetEditgroupsReviewableResponse::GenericError(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_editor(
+        &self,
+        param_editor_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetEditorResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::Editor>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetEditorResponse::Found(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetEditorResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetEditorResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetEditorResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    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,
+    ) -> Box<dyn Future<Item = GetEditorAnnotationsResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<Vec<models::EditgroupAnnotation>>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            GetEditorAnnotationsResponse::Success
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            GetEditorAnnotationsResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            GetEditorAnnotationsResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            GetEditorAnnotationsResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            GetEditorAnnotationsResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            GetEditorAnnotationsResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    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,
+    ) -> Box<dyn Future<Item = GetEditorEditgroupsResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<models::Editgroup>>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetEditorEditgroupsResponse::Found(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetEditorEditgroupsResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetEditorEditgroupsResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetEditorEditgroupsResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_file(
+        &self,
+        param_ident: String,
+        param_expand: Option<String>,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFileResponse, Error = ApiError> + Send> {
+        let mut uri = format!(
+            "{}/v0/file/{ident}",
+            self.base_path,
+            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
+        );
+
+        // Query parameters
+        let mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::FileEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileResponse::FoundEntity(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_file_edit(
+        &self,
+        param_edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFileEditResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::EntityEdit>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileEditResponse::FoundEdit(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileEditResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileEditResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileEditResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_file_history(
+        &self,
+        param_ident: String,
+        param_limit: Option<i64>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFileHistoryResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        if let Some(param_limit) = param_limit {
+            query_string.append_pair("limit", &param_limit.to_string());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<models::EntityHistoryEntry>>(
+                                                body,
+                                            )
+                                            .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileHistoryResponse::FoundEntityHistory(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileHistoryResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileHistoryResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileHistoryResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_file_redirects(
+        &self,
+        param_ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFileRedirectsResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<String>>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetFileRedirectsResponse::FoundEntityRedirects(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileRedirectsResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileRedirectsResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileRedirectsResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_file_revision(
+        &self,
+        param_rev_id: String,
+        param_expand: Option<String>,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFileRevisionResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::FileEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetFileRevisionResponse::FoundEntityRevision(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileRevisionResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileRevisionResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFileRevisionResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_fileset(
+        &self,
+        param_ident: String,
+        param_expand: Option<String>,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFilesetResponse, Error = ApiError> + Send> {
+        let mut uri = format!(
+            "{}/v0/fileset/{ident}",
+            self.base_path,
+            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
+        );
+
+        // Query parameters
+        let mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::FilesetEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFilesetResponse::FoundEntity(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFilesetResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFilesetResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFilesetResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_fileset_edit(
+        &self,
+        param_edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFilesetEditResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::EntityEdit>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFilesetEditResponse::FoundEdit(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFilesetEditResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFilesetEditResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFilesetEditResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_fileset_history(
+        &self,
+        param_ident: String,
+        param_limit: Option<i64>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFilesetHistoryResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        if let Some(param_limit) = param_limit {
+            query_string.append_pair("limit", &param_limit.to_string());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<models::EntityHistoryEntry>>(
+                                                body,
+                                            )
+                                            .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetFilesetHistoryResponse::FoundEntityHistory(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFilesetHistoryResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFilesetHistoryResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFilesetHistoryResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_fileset_redirects(
+        &self,
+        param_ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFilesetRedirectsResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<String>>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetFilesetRedirectsResponse::FoundEntityRedirects(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFilesetRedirectsResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFilesetRedirectsResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFilesetRedirectsResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_fileset_revision(
+        &self,
+        param_rev_id: String,
+        param_expand: Option<String>,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFilesetRevisionResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::FilesetEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetFilesetRevisionResponse::FoundEntityRevision(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFilesetRevisionResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFilesetRevisionResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetFilesetRevisionResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_release(
+        &self,
+        param_ident: String,
+        param_expand: Option<String>,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetReleaseResponse, Error = ApiError> + Send> {
+        let mut uri = format!(
+            "{}/v0/release/{ident}",
+            self.base_path,
+            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
+        );
+
+        // Query parameters
+        let mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ReleaseEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseResponse::FoundEntity(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_release_edit(
+        &self,
+        param_edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetReleaseEditResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::EntityEdit>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseEditResponse::FoundEdit(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseEditResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseEditResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseEditResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_release_files(
+        &self,
+        param_ident: String,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetReleaseFilesResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        if let Some(param_hide) = param_hide {
+            query_string.append_pair("hide", &param_hide.to_string());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<models::FileEntity>>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseFilesResponse::Found(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseFilesResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseFilesResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseFilesResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_release_filesets(
+        &self,
+        param_ident: String,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetReleaseFilesetsResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        if let Some(param_hide) = param_hide {
+            query_string.append_pair("hide", &param_hide.to_string());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<models::FilesetEntity>>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseFilesetsResponse::Found(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseFilesetsResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseFilesetsResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseFilesetsResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_release_history(
+        &self,
+        param_ident: String,
+        param_limit: Option<i64>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetReleaseHistoryResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        if let Some(param_limit) = param_limit {
+            query_string.append_pair("limit", &param_limit.to_string());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<models::EntityHistoryEntry>>(
+                                                body,
+                                            )
+                                            .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetReleaseHistoryResponse::FoundEntityHistory(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseHistoryResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseHistoryResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseHistoryResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_release_redirects(
+        &self,
+        param_ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetReleaseRedirectsResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<String>>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetReleaseRedirectsResponse::FoundEntityRedirects(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseRedirectsResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseRedirectsResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseRedirectsResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_release_revision(
+        &self,
+        param_rev_id: String,
+        param_expand: Option<String>,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetReleaseRevisionResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ReleaseEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetReleaseRevisionResponse::FoundEntityRevision(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseRevisionResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseRevisionResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseRevisionResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_release_webcaptures(
+        &self,
+        param_ident: String,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetReleaseWebcapturesResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        if let Some(param_hide) = param_hide {
+            query_string.append_pair("hide", &param_hide.to_string());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<models::WebcaptureEntity>>(
+                                                body,
+                                            )
+                                            .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseWebcapturesResponse::Found(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseWebcapturesResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseWebcapturesResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetReleaseWebcapturesResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_webcapture(
+        &self,
+        param_ident: String,
+        param_expand: Option<String>,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWebcaptureResponse, Error = ApiError> + Send> {
+        let mut uri = format!(
+            "{}/v0/webcapture/{ident}",
+            self.base_path,
+            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
+        );
+
+        // Query parameters
+        let mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::WebcaptureEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWebcaptureResponse::FoundEntity(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWebcaptureResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWebcaptureResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWebcaptureResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_webcapture_edit(
+        &self,
+        param_edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWebcaptureEditResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::EntityEdit>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWebcaptureEditResponse::FoundEdit(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWebcaptureEditResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWebcaptureEditResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWebcaptureEditResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_webcapture_history(
+        &self,
+        param_ident: String,
+        param_limit: Option<i64>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWebcaptureHistoryResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        if let Some(param_limit) = param_limit {
+            query_string.append_pair("limit", &param_limit.to_string());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<models::EntityHistoryEntry>>(
+                                                body,
+                                            )
+                                            .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetWebcaptureHistoryResponse::FoundEntityHistory(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWebcaptureHistoryResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWebcaptureHistoryResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWebcaptureHistoryResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_webcapture_redirects(
+        &self,
+        param_ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWebcaptureRedirectsResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<String>>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetWebcaptureRedirectsResponse::FoundEntityRedirects(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWebcaptureRedirectsResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWebcaptureRedirectsResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetWebcaptureRedirectsResponse::GenericError(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_webcapture_revision(
+        &self,
+        param_rev_id: String,
+        param_expand: Option<String>,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWebcaptureRevisionResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::WebcaptureEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetWebcaptureRevisionResponse::FoundEntityRevision(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWebcaptureRevisionResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWebcaptureRevisionResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWebcaptureRevisionResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_work(
+        &self,
+        param_ident: String,
+        param_expand: Option<String>,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWorkResponse, Error = ApiError> + Send> {
+        let mut uri = format!(
+            "{}/v0/work/{ident}",
+            self.base_path,
+            ident = utf8_percent_encode(&param_ident.to_string(), ID_ENCODE_SET)
+        );
+
+        // Query parameters
+        let mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::WorkEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkResponse::FoundEntity(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_work_edit(
+        &self,
+        param_edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWorkEditResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::EntityEdit>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkEditResponse::FoundEdit(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkEditResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkEditResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkEditResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_work_history(
+        &self,
+        param_ident: String,
+        param_limit: Option<i64>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWorkHistoryResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        if let Some(param_limit) = param_limit {
+            query_string.append_pair("limit", &param_limit.to_string());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<models::EntityHistoryEntry>>(
+                                                body,
+                                            )
+                                            .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkHistoryResponse::FoundEntityHistory(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkHistoryResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkHistoryResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkHistoryResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_work_redirects(
+        &self,
+        param_ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWorkRedirectsResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<String>>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetWorkRedirectsResponse::FoundEntityRedirects(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkRedirectsResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkRedirectsResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkRedirectsResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_work_releases(
+        &self,
+        param_ident: String,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWorkReleasesResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        if let Some(param_hide) = param_hide {
+            query_string.append_pair("hide", &param_hide.to_string());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<Vec<models::ReleaseEntity>>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkReleasesResponse::Found(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkReleasesResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkReleasesResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkReleasesResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn get_work_revision(
+        &self,
+        param_rev_id: String,
+        param_expand: Option<String>,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWorkRevisionResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::WorkEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| {
+                                    GetWorkRevisionResponse::FoundEntityRevision(body)
+                                }),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkRevisionResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkRevisionResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| GetWorkRevisionResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn lookup_container(
+        &self,
+        param_issnl: Option<String>,
+        param_wikidata_qid: Option<String>,
+        param_expand: Option<String>,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = LookupContainerResponse, Error = ApiError> + Send> {
+        let mut uri = format!("{}/v0/container/lookup", self.base_path);
+
+        // Query parameters
+        let mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ContainerEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| LookupContainerResponse::FoundEntity(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| LookupContainerResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| LookupContainerResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| LookupContainerResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn lookup_creator(
+        &self,
+        param_orcid: Option<String>,
+        param_wikidata_qid: Option<String>,
+        param_expand: Option<String>,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = LookupCreatorResponse, Error = ApiError> + Send> {
+        let mut uri = format!("{}/v0/creator/lookup", self.base_path);
+
+        // Query parameters
+        let mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::CreatorEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| LookupCreatorResponse::FoundEntity(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| LookupCreatorResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| LookupCreatorResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| LookupCreatorResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    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,
+    ) -> Box<dyn Future<Item = LookupFileResponse, Error = ApiError> + Send> {
+        let mut uri = format!("{}/v0/file/lookup", self.base_path);
+
+        // Query parameters
+        let mut query_string = url::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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::FileEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| LookupFileResponse::FoundEntity(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| LookupFileResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| LookupFileResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| LookupFileResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    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_expand: Option<String>,
+        param_hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = LookupReleaseResponse, Error = ApiError> + Send> {
+        let mut uri = format!("{}/v0/release/lookup", self.base_path);
+
+        // Query parameters
+        let mut query_string = url::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_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());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to create request: {}",
+                    e
+                ))))
+            }
+        };
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        Box::new(
+            self.client_service
+                .request(request)
+                .map_err(|e| ApiError(format!("No response received: {}", e)))
+                .and_then(|mut response| match response.status().as_u16() {
+                    200 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ReleaseEntity>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| LookupReleaseResponse::FoundEntity(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    400 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| LookupReleaseResponse::BadRequest(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    404 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| LookupReleaseResponse::NotFound(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    500 => {
+                        let body = response.into_body();
+                        Box::new(
+                            body.concat2()
+                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                                .and_then(|body| {
+                                    str::from_utf8(&body)
+                                        .map_err(|e| {
+                                            ApiError(format!("Response was not valid UTF8: {}", e))
+                                        })
+                                        .and_then(|body| {
+                                            serde_json::from_str::<models::ErrorResponse>(body)
+                                                .map_err(|e| e.into())
+                                        })
+                                })
+                                .map(move |body| LookupReleaseResponse::GenericError(body)),
+                        ) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                    code => {
+                        let headers = response.headers().clone();
+                        Box::new(response.into_body().take(100).concat2().then(move |body| {
+                            future::err(ApiError(format!(
+                                "Unexpected response code {}:\n{:?}\n\n{}",
+                                code,
+                                headers,
+                                match body {
+                                    Ok(ref body) => match str::from_utf8(body) {
+                                        Ok(body) => Cow::from(body),
+                                        Err(e) =>
+                                            Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                    },
+                                    Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                }
+                            )))
+                        })) as Box<dyn Future<Item = _, Error = _> + Send>
+                    }
+                }),
+        )
+    }
+
+    fn update_container(
+        &self,
+        param_editgroup_id: String,
+        param_ident: String,
+        param_container_entity: models::ContainerEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateContainerResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("PUT")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateContainerResponse::UpdatedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateContainerResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateContainerResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateContainerResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateContainerResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateContainerResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn update_creator(
+        &self,
+        param_editgroup_id: String,
+        param_ident: String,
+        param_creator_entity: models::CreatorEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateCreatorResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("PUT")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateCreatorResponse::UpdatedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateCreatorResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateCreatorResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateCreatorResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateCreatorResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateCreatorResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn update_editgroup(
+        &self,
+        param_editgroup_id: String,
+        param_editgroup: models::Editgroup,
+        param_submit: Option<bool>,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateEditgroupResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        if let Some(param_submit) = param_submit {
+            query_string.append_pair("submit", &param_submit.to_string());
+        }
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("PUT")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Editgroup>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateEditgroupResponse::UpdatedEditgroup
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateEditgroupResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateEditgroupResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateEditgroupResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateEditgroupResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateEditgroupResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn update_editor(
+        &self,
+        param_editor_id: String,
+        param_editor: models::Editor,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateEditorResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("PUT")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::Editor>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateEditorResponse::UpdatedEditor
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateEditorResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateEditorResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateEditorResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateEditorResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateEditorResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn update_file(
+        &self,
+        param_editgroup_id: String,
+        param_ident: String,
+        param_file_entity: models::FileEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateFileResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("PUT")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateFileResponse::UpdatedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateFileResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateFileResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateFileResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateFileResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateFileResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn update_fileset(
+        &self,
+        param_editgroup_id: String,
+        param_ident: String,
+        param_fileset_entity: models::FilesetEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateFilesetResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("PUT")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateFilesetResponse::UpdatedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateFilesetResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateFilesetResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateFilesetResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateFilesetResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateFilesetResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn update_release(
+        &self,
+        param_editgroup_id: String,
+        param_ident: String,
+        param_release_entity: models::ReleaseEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateReleaseResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("PUT")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateReleaseResponse::UpdatedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateReleaseResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateReleaseResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateReleaseResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateReleaseResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateReleaseResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn update_webcapture(
+        &self,
+        param_editgroup_id: String,
+        param_ident: String,
+        param_webcapture_entity: models::WebcaptureEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateWebcaptureResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("PUT")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateWebcaptureResponse::UpdatedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateWebcaptureResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateWebcaptureResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateWebcaptureResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateWebcaptureResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateWebcaptureResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+
+    fn update_work(
+        &self,
+        param_editgroup_id: String,
+        param_ident: String,
+        param_work_entity: models::WorkEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateWorkResponse, Error = ApiError> + Send> {
+        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 mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => {
+                return Box::new(future::err(ApiError(format!(
+                    "Unable to build URI: {}",
+                    err
+                ))))
+            }
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("PUT")
+            .uri(uri)
+            .body(Body::empty())
+        {
+            Ok(req) => req,
+            Err(e) => {
+                return Box::new(future::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 Box::new(future::err(ApiError(format!(
+                        "Unable to create header: {} - {}",
+                        header, e
+                    ))))
+                }
+            },
+        );
+
+        let header = HeaderValue::from_str(
+            (context as &dyn Has<XSpanIdString>)
+                .get()
+                .0
+                .clone()
+                .to_string()
+                .as_str(),
+        );
+        request.headers_mut().insert(
+            HeaderName::from_static("x-span-id"),
+            match header {
+                Ok(h) => h,
+                Err(e) => {
+                    return Box::new(future::err(ApiError(format!(
+                        "Unable to create X-Span ID header value: {}",
+                        e
+                    ))))
+                }
+            },
+        );
+
+        if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().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 Box::new(future::err(ApiError(format!(
+                                "Unable to create Authorization header: {}",
+                                e
+                            ))))
+                        }
+                    };
+                    request
+                        .headers_mut()
+                        .insert(hyper::header::AUTHORIZATION, header);
+                }
+                _ => {}
+            }
+        }
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::EntityEdit>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateWorkResponse::UpdatedEntity
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                400 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateWorkResponse::BadRequest
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                401 => {
+                    let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
+                        Some(response_www_authenticate) => response_www_authenticate.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
+                    let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
+                        Ok(value) => value,
+                        Err(e) => {
+                            return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
+                        },
+                    };
+                    let response_www_authenticate = response_www_authenticate.0;
+
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateWorkResponse::NotAuthorized
+                            {
+                                body: body,
+                                www_authenticate: response_www_authenticate,
+                            }
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                403 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateWorkResponse::Forbidden
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                404 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateWorkResponse::NotFound
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                500 => {
+                    let body = response.into_body();
+                    Box::new(
+                        body
+                        .concat2()
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
+                        .and_then(|body|
+                        str::from_utf8(&body)
+                                             .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
+                                             .and_then(|body|
+                                                 serde_json::from_str::<models::ErrorResponse>(body)
+                                                     .map_err(|e| e.into())
+                                             )
+                                 )
+                        .map(move |body| {
+                            UpdateWorkResponse::GenericError
+                            (body)
+                        })
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+    }
+}
diff --git a/rust/fatcat-openapi/src/context.rs b/rust/fatcat-openapi/src/context.rs
new file mode 100644
index 0000000..57d11be
--- /dev/null
+++ b/rust/fatcat-openapi/src/context.rs
@@ -0,0 +1,135 @@
+use crate::Api;
+use futures::Future;
+use hyper;
+use hyper::header::HeaderName;
+use hyper::{body::Payload, service::Service, Error, Request, Response, StatusCode};
+use std::default::Default;
+use std::io;
+use std::marker::PhantomData;
+use swagger::auth::{AuthData, Authorization, Bearer, Scopes};
+use swagger::context::ContextualPayload;
+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<'a, T, SC, A, B, C, D, E, ME, S, OB, F> hyper::service::MakeService<&'a SC>
+    for MakeAddContext<T, A>
+where
+    A: Default + Push<XSpanIdString, Result = B>,
+    B: Push<Option<AuthData>, Result = C>,
+    C: Push<Option<Authorization>, Result = D>,
+    D: Send + 'static,
+    T: hyper::service::MakeService<
+        &'a SC,
+        Error = E,
+        MakeError = ME,
+        Service = S,
+        ReqBody = ContextualPayload<hyper::Body, D>,
+        ResBody = OB,
+        Future = F,
+    >,
+    S: Service<Error = E, ReqBody = ContextualPayload<hyper::Body, D>, ResBody = OB> + 'static,
+    ME: swagger::ErrorBound,
+    E: swagger::ErrorBound,
+    F: Future<Item = S, Error = ME> + Send + 'static,
+    S::Future: Send,
+    OB: Payload,
+{
+    type ReqBody = hyper::Body;
+    type ResBody = OB;
+    type Error = E;
+    type MakeError = ME;
+    type Service = AddContext<S, A>;
+    type Future = Box<dyn Future<Item = Self::Service, Error = ME> + Send + 'static>;
+
+    fn make_service(&mut self, ctx: &'a SC) -> Self::Future {
+        Box::new(self.inner.make_service(ctx).map(|s| AddContext::new(s)))
+    }
+}
+
+/// Middleware to extract authentication data from request
+pub struct AddContext<T, A> {
+    inner: T,
+    marker: PhantomData<A>,
+}
+
+impl<T, A, B, C, D> AddContext<T, A>
+where
+    A: Default + Push<XSpanIdString, Result = B>,
+    B: Push<Option<AuthData>, Result = C>,
+    C: Push<Option<Authorization>, Result = D>,
+    T: Service,
+{
+    pub fn new(inner: T) -> AddContext<T, A> {
+        AddContext {
+            inner,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<T, A, B, C, D> Service for AddContext<T, A>
+where
+    A: Default + Push<XSpanIdString, Result = B>,
+    B: Push<Option<AuthData>, Result = C>,
+    C: Push<Option<Authorization>, Result = D>,
+    D: Send + 'static,
+    T: Service<ReqBody = ContextualPayload<hyper::Body, D>>,
+    T::Future: Future<Item = Response<T::ResBody>, Error = T::Error> + Send + 'static,
+{
+    type ReqBody = hyper::Body;
+    type ResBody = T::ResBody;
+    type Error = T::Error;
+    type Future = Box<dyn Future<Item = Response<T::ResBody>, Error = T::Error> + Send + 'static>;
+
+    fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future {
+        let context = A::default().push(XSpanIdString::get_or_generate(&req));
+        let (head, body) = req.into_parts();
+        let headers = head.headers.clone();
+
+        {
+            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>);
+
+                let body = ContextualPayload {
+                    inner: body,
+                    context: context,
+                };
+
+                return Box::new(self.inner.call(hyper::Request::from_parts(head, body)));
+            }
+        }
+
+        let context = context.push(None::<AuthData>);
+        let context = context.push(None::<Authorization>);
+        let body = ContextualPayload {
+            inner: body,
+            context: context,
+        };
+
+        Box::new(self.inner.call(hyper::Request::from_parts(head, body)))
+    }
+}
diff --git a/rust/fatcat-openapi/src/header.rs b/rust/fatcat-openapi/src/header.rs
new file mode 100644
index 0000000..7589ab0
--- /dev/null
+++ b/rust/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/rust/fatcat-openapi/src/lib.rs b/rust/fatcat-openapi/src/lib.rs
new file mode 100644
index 0000000..1438bdf
--- /dev/null
+++ b/rust/fatcat-openapi/src/lib.rs
@@ -0,0 +1,3730 @@
+#![allow(
+    missing_docs,
+    trivial_casts,
+    unused_variables,
+    unused_mut,
+    unused_imports,
+    unused_extern_crates,
+    non_camel_case_types
+)]
+
+use futures::Stream;
+use std::io::Error;
+
+#[deprecated(note = "Import futures directly")]
+pub use futures::Future;
+#[deprecated(note = "Import swagger-rs directly")]
+pub use swagger::{ApiError, ContextWrapper};
+
+pub const BASE_PATH: &'static str = "/v0";
+pub const API_VERSION: &'static str = "0.3.1";
+
+#[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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: String,
+    },
+    /// Forbidden
+    Forbidden(models::ErrorResponse),
+    /// Not Found
+    NotFound(models::ErrorResponse),
+    /// Generic Error
+    GenericError(models::ErrorResponse),
+}
+
+/// API
+pub trait Api<C> {
+    fn accept_editgroup(
+        &self,
+        editgroup_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = AcceptEditgroupResponse, Error = ApiError> + Send>;
+
+    fn auth_check(
+        &self,
+        role: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = AuthCheckResponse, Error = ApiError> + Send>;
+
+    fn auth_oidc(
+        &self,
+        auth_oidc: models::AuthOidc,
+        context: &C,
+    ) -> Box<dyn Future<Item = AuthOidcResponse, Error = ApiError> + Send>;
+
+    fn create_auth_token(
+        &self,
+        editor_id: String,
+        duration_seconds: Option<i32>,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateAuthTokenResponse, Error = ApiError> + Send>;
+
+    fn create_container(
+        &self,
+        editgroup_id: String,
+        container_entity: models::ContainerEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateContainerResponse, Error = ApiError> + Send>;
+
+    fn create_container_auto_batch(
+        &self,
+        container_auto_batch: models::ContainerAutoBatch,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateContainerAutoBatchResponse, Error = ApiError> + Send>;
+
+    fn create_creator(
+        &self,
+        editgroup_id: String,
+        creator_entity: models::CreatorEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateCreatorResponse, Error = ApiError> + Send>;
+
+    fn create_creator_auto_batch(
+        &self,
+        creator_auto_batch: models::CreatorAutoBatch,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateCreatorAutoBatchResponse, Error = ApiError> + Send>;
+
+    fn create_editgroup(
+        &self,
+        editgroup: models::Editgroup,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateEditgroupResponse, Error = ApiError> + Send>;
+
+    fn create_editgroup_annotation(
+        &self,
+        editgroup_id: String,
+        editgroup_annotation: models::EditgroupAnnotation,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateEditgroupAnnotationResponse, Error = ApiError> + Send>;
+
+    fn create_file(
+        &self,
+        editgroup_id: String,
+        file_entity: models::FileEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateFileResponse, Error = ApiError> + Send>;
+
+    fn create_file_auto_batch(
+        &self,
+        file_auto_batch: models::FileAutoBatch,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateFileAutoBatchResponse, Error = ApiError> + Send>;
+
+    fn create_fileset(
+        &self,
+        editgroup_id: String,
+        fileset_entity: models::FilesetEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateFilesetResponse, Error = ApiError> + Send>;
+
+    fn create_fileset_auto_batch(
+        &self,
+        fileset_auto_batch: models::FilesetAutoBatch,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateFilesetAutoBatchResponse, Error = ApiError> + Send>;
+
+    fn create_release(
+        &self,
+        editgroup_id: String,
+        release_entity: models::ReleaseEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateReleaseResponse, Error = ApiError> + Send>;
+
+    fn create_release_auto_batch(
+        &self,
+        release_auto_batch: models::ReleaseAutoBatch,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateReleaseAutoBatchResponse, Error = ApiError> + Send>;
+
+    fn create_webcapture(
+        &self,
+        editgroup_id: String,
+        webcapture_entity: models::WebcaptureEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateWebcaptureResponse, Error = ApiError> + Send>;
+
+    fn create_webcapture_auto_batch(
+        &self,
+        webcapture_auto_batch: models::WebcaptureAutoBatch,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateWebcaptureAutoBatchResponse, Error = ApiError> + Send>;
+
+    fn create_work(
+        &self,
+        editgroup_id: String,
+        work_entity: models::WorkEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateWorkResponse, Error = ApiError> + Send>;
+
+    fn create_work_auto_batch(
+        &self,
+        work_auto_batch: models::WorkAutoBatch,
+        context: &C,
+    ) -> Box<dyn Future<Item = CreateWorkAutoBatchResponse, Error = ApiError> + Send>;
+
+    fn delete_container(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteContainerResponse, Error = ApiError> + Send>;
+
+    fn delete_container_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteContainerEditResponse, Error = ApiError> + Send>;
+
+    fn delete_creator(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteCreatorResponse, Error = ApiError> + Send>;
+
+    fn delete_creator_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteCreatorEditResponse, Error = ApiError> + Send>;
+
+    fn delete_file(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteFileResponse, Error = ApiError> + Send>;
+
+    fn delete_file_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteFileEditResponse, Error = ApiError> + Send>;
+
+    fn delete_fileset(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteFilesetResponse, Error = ApiError> + Send>;
+
+    fn delete_fileset_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteFilesetEditResponse, Error = ApiError> + Send>;
+
+    fn delete_release(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteReleaseResponse, Error = ApiError> + Send>;
+
+    fn delete_release_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteReleaseEditResponse, Error = ApiError> + Send>;
+
+    fn delete_webcapture(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteWebcaptureResponse, Error = ApiError> + Send>;
+
+    fn delete_webcapture_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteWebcaptureEditResponse, Error = ApiError> + Send>;
+
+    fn delete_work(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteWorkResponse, Error = ApiError> + Send>;
+
+    fn delete_work_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = DeleteWorkEditResponse, Error = ApiError> + Send>;
+
+    fn get_changelog(
+        &self,
+        limit: Option<i64>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetChangelogResponse, Error = ApiError> + Send>;
+
+    fn get_changelog_entry(
+        &self,
+        index: i64,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetChangelogEntryResponse, Error = ApiError> + Send>;
+
+    fn get_container(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetContainerResponse, Error = ApiError> + Send>;
+
+    fn get_container_edit(
+        &self,
+        edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetContainerEditResponse, Error = ApiError> + Send>;
+
+    fn get_container_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetContainerHistoryResponse, Error = ApiError> + Send>;
+
+    fn get_container_redirects(
+        &self,
+        ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetContainerRedirectsResponse, Error = ApiError> + Send>;
+
+    fn get_container_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetContainerRevisionResponse, Error = ApiError> + Send>;
+
+    fn get_creator(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetCreatorResponse, Error = ApiError> + Send>;
+
+    fn get_creator_edit(
+        &self,
+        edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetCreatorEditResponse, Error = ApiError> + Send>;
+
+    fn get_creator_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetCreatorHistoryResponse, Error = ApiError> + Send>;
+
+    fn get_creator_redirects(
+        &self,
+        ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetCreatorRedirectsResponse, Error = ApiError> + Send>;
+
+    fn get_creator_releases(
+        &self,
+        ident: String,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetCreatorReleasesResponse, Error = ApiError> + Send>;
+
+    fn get_creator_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetCreatorRevisionResponse, Error = ApiError> + Send>;
+
+    fn get_editgroup(
+        &self,
+        editgroup_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetEditgroupResponse, Error = ApiError> + Send>;
+
+    fn get_editgroup_annotations(
+        &self,
+        editgroup_id: String,
+        expand: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetEditgroupAnnotationsResponse, Error = ApiError> + Send>;
+
+    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,
+    ) -> Box<dyn Future<Item = GetEditgroupsReviewableResponse, Error = ApiError> + Send>;
+
+    fn get_editor(
+        &self,
+        editor_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetEditorResponse, Error = ApiError> + Send>;
+
+    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,
+    ) -> Box<dyn Future<Item = GetEditorAnnotationsResponse, Error = ApiError> + Send>;
+
+    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,
+    ) -> Box<dyn Future<Item = GetEditorEditgroupsResponse, Error = ApiError> + Send>;
+
+    fn get_file(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFileResponse, Error = ApiError> + Send>;
+
+    fn get_file_edit(
+        &self,
+        edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFileEditResponse, Error = ApiError> + Send>;
+
+    fn get_file_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFileHistoryResponse, Error = ApiError> + Send>;
+
+    fn get_file_redirects(
+        &self,
+        ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFileRedirectsResponse, Error = ApiError> + Send>;
+
+    fn get_file_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFileRevisionResponse, Error = ApiError> + Send>;
+
+    fn get_fileset(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFilesetResponse, Error = ApiError> + Send>;
+
+    fn get_fileset_edit(
+        &self,
+        edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFilesetEditResponse, Error = ApiError> + Send>;
+
+    fn get_fileset_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFilesetHistoryResponse, Error = ApiError> + Send>;
+
+    fn get_fileset_redirects(
+        &self,
+        ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFilesetRedirectsResponse, Error = ApiError> + Send>;
+
+    fn get_fileset_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetFilesetRevisionResponse, Error = ApiError> + Send>;
+
+    fn get_release(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetReleaseResponse, Error = ApiError> + Send>;
+
+    fn get_release_edit(
+        &self,
+        edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetReleaseEditResponse, Error = ApiError> + Send>;
+
+    fn get_release_files(
+        &self,
+        ident: String,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetReleaseFilesResponse, Error = ApiError> + Send>;
+
+    fn get_release_filesets(
+        &self,
+        ident: String,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetReleaseFilesetsResponse, Error = ApiError> + Send>;
+
+    fn get_release_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetReleaseHistoryResponse, Error = ApiError> + Send>;
+
+    fn get_release_redirects(
+        &self,
+        ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetReleaseRedirectsResponse, Error = ApiError> + Send>;
+
+    fn get_release_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetReleaseRevisionResponse, Error = ApiError> + Send>;
+
+    fn get_release_webcaptures(
+        &self,
+        ident: String,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetReleaseWebcapturesResponse, Error = ApiError> + Send>;
+
+    fn get_webcapture(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWebcaptureResponse, Error = ApiError> + Send>;
+
+    fn get_webcapture_edit(
+        &self,
+        edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWebcaptureEditResponse, Error = ApiError> + Send>;
+
+    fn get_webcapture_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWebcaptureHistoryResponse, Error = ApiError> + Send>;
+
+    fn get_webcapture_redirects(
+        &self,
+        ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWebcaptureRedirectsResponse, Error = ApiError> + Send>;
+
+    fn get_webcapture_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWebcaptureRevisionResponse, Error = ApiError> + Send>;
+
+    fn get_work(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWorkResponse, Error = ApiError> + Send>;
+
+    fn get_work_edit(
+        &self,
+        edit_id: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWorkEditResponse, Error = ApiError> + Send>;
+
+    fn get_work_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWorkHistoryResponse, Error = ApiError> + Send>;
+
+    fn get_work_redirects(
+        &self,
+        ident: String,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWorkRedirectsResponse, Error = ApiError> + Send>;
+
+    fn get_work_releases(
+        &self,
+        ident: String,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWorkReleasesResponse, Error = ApiError> + Send>;
+
+    fn get_work_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = GetWorkRevisionResponse, Error = ApiError> + Send>;
+
+    fn lookup_container(
+        &self,
+        issnl: Option<String>,
+        wikidata_qid: Option<String>,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = LookupContainerResponse, Error = ApiError> + Send>;
+
+    fn lookup_creator(
+        &self,
+        orcid: Option<String>,
+        wikidata_qid: Option<String>,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = LookupCreatorResponse, Error = ApiError> + Send>;
+
+    fn lookup_file(
+        &self,
+        md5: Option<String>,
+        sha1: Option<String>,
+        sha256: Option<String>,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = LookupFileResponse, Error = ApiError> + Send>;
+
+    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>,
+        expand: Option<String>,
+        hide: Option<String>,
+        context: &C,
+    ) -> Box<dyn Future<Item = LookupReleaseResponse, Error = ApiError> + Send>;
+
+    fn update_container(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        container_entity: models::ContainerEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateContainerResponse, Error = ApiError> + Send>;
+
+    fn update_creator(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        creator_entity: models::CreatorEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateCreatorResponse, Error = ApiError> + Send>;
+
+    fn update_editgroup(
+        &self,
+        editgroup_id: String,
+        editgroup: models::Editgroup,
+        submit: Option<bool>,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateEditgroupResponse, Error = ApiError> + Send>;
+
+    fn update_editor(
+        &self,
+        editor_id: String,
+        editor: models::Editor,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateEditorResponse, Error = ApiError> + Send>;
+
+    fn update_file(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        file_entity: models::FileEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateFileResponse, Error = ApiError> + Send>;
+
+    fn update_fileset(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        fileset_entity: models::FilesetEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateFilesetResponse, Error = ApiError> + Send>;
+
+    fn update_release(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        release_entity: models::ReleaseEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateReleaseResponse, Error = ApiError> + Send>;
+
+    fn update_webcapture(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        webcapture_entity: models::WebcaptureEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateWebcaptureResponse, Error = ApiError> + Send>;
+
+    fn update_work(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        work_entity: models::WorkEntity,
+        context: &C,
+    ) -> Box<dyn Future<Item = UpdateWorkResponse, Error = ApiError> + Send>;
+}
+
+/// API without a `Context`
+pub trait ApiNoContext {
+    fn accept_editgroup(
+        &self,
+        editgroup_id: String,
+    ) -> Box<dyn Future<Item = AcceptEditgroupResponse, Error = ApiError> + Send>;
+
+    fn auth_check(
+        &self,
+        role: Option<String>,
+    ) -> Box<dyn Future<Item = AuthCheckResponse, Error = ApiError> + Send>;
+
+    fn auth_oidc(
+        &self,
+        auth_oidc: models::AuthOidc,
+    ) -> Box<dyn Future<Item = AuthOidcResponse, Error = ApiError> + Send>;
+
+    fn create_auth_token(
+        &self,
+        editor_id: String,
+        duration_seconds: Option<i32>,
+    ) -> Box<dyn Future<Item = CreateAuthTokenResponse, Error = ApiError> + Send>;
+
+    fn create_container(
+        &self,
+        editgroup_id: String,
+        container_entity: models::ContainerEntity,
+    ) -> Box<dyn Future<Item = CreateContainerResponse, Error = ApiError> + Send>;
+
+    fn create_container_auto_batch(
+        &self,
+        container_auto_batch: models::ContainerAutoBatch,
+    ) -> Box<dyn Future<Item = CreateContainerAutoBatchResponse, Error = ApiError> + Send>;
+
+    fn create_creator(
+        &self,
+        editgroup_id: String,
+        creator_entity: models::CreatorEntity,
+    ) -> Box<dyn Future<Item = CreateCreatorResponse, Error = ApiError> + Send>;
+
+    fn create_creator_auto_batch(
+        &self,
+        creator_auto_batch: models::CreatorAutoBatch,
+    ) -> Box<dyn Future<Item = CreateCreatorAutoBatchResponse, Error = ApiError> + Send>;
+
+    fn create_editgroup(
+        &self,
+        editgroup: models::Editgroup,
+    ) -> Box<dyn Future<Item = CreateEditgroupResponse, Error = ApiError> + Send>;
+
+    fn create_editgroup_annotation(
+        &self,
+        editgroup_id: String,
+        editgroup_annotation: models::EditgroupAnnotation,
+    ) -> Box<dyn Future<Item = CreateEditgroupAnnotationResponse, Error = ApiError> + Send>;
+
+    fn create_file(
+        &self,
+        editgroup_id: String,
+        file_entity: models::FileEntity,
+    ) -> Box<dyn Future<Item = CreateFileResponse, Error = ApiError> + Send>;
+
+    fn create_file_auto_batch(
+        &self,
+        file_auto_batch: models::FileAutoBatch,
+    ) -> Box<dyn Future<Item = CreateFileAutoBatchResponse, Error = ApiError> + Send>;
+
+    fn create_fileset(
+        &self,
+        editgroup_id: String,
+        fileset_entity: models::FilesetEntity,
+    ) -> Box<dyn Future<Item = CreateFilesetResponse, Error = ApiError> + Send>;
+
+    fn create_fileset_auto_batch(
+        &self,
+        fileset_auto_batch: models::FilesetAutoBatch,
+    ) -> Box<dyn Future<Item = CreateFilesetAutoBatchResponse, Error = ApiError> + Send>;
+
+    fn create_release(
+        &self,
+        editgroup_id: String,
+        release_entity: models::ReleaseEntity,
+    ) -> Box<dyn Future<Item = CreateReleaseResponse, Error = ApiError> + Send>;
+
+    fn create_release_auto_batch(
+        &self,
+        release_auto_batch: models::ReleaseAutoBatch,
+    ) -> Box<dyn Future<Item = CreateReleaseAutoBatchResponse, Error = ApiError> + Send>;
+
+    fn create_webcapture(
+        &self,
+        editgroup_id: String,
+        webcapture_entity: models::WebcaptureEntity,
+    ) -> Box<dyn Future<Item = CreateWebcaptureResponse, Error = ApiError> + Send>;
+
+    fn create_webcapture_auto_batch(
+        &self,
+        webcapture_auto_batch: models::WebcaptureAutoBatch,
+    ) -> Box<dyn Future<Item = CreateWebcaptureAutoBatchResponse, Error = ApiError> + Send>;
+
+    fn create_work(
+        &self,
+        editgroup_id: String,
+        work_entity: models::WorkEntity,
+    ) -> Box<dyn Future<Item = CreateWorkResponse, Error = ApiError> + Send>;
+
+    fn create_work_auto_batch(
+        &self,
+        work_auto_batch: models::WorkAutoBatch,
+    ) -> Box<dyn Future<Item = CreateWorkAutoBatchResponse, Error = ApiError> + Send>;
+
+    fn delete_container(
+        &self,
+        editgroup_id: String,
+        ident: String,
+    ) -> Box<dyn Future<Item = DeleteContainerResponse, Error = ApiError> + Send>;
+
+    fn delete_container_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = DeleteContainerEditResponse, Error = ApiError> + Send>;
+
+    fn delete_creator(
+        &self,
+        editgroup_id: String,
+        ident: String,
+    ) -> Box<dyn Future<Item = DeleteCreatorResponse, Error = ApiError> + Send>;
+
+    fn delete_creator_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = DeleteCreatorEditResponse, Error = ApiError> + Send>;
+
+    fn delete_file(
+        &self,
+        editgroup_id: String,
+        ident: String,
+    ) -> Box<dyn Future<Item = DeleteFileResponse, Error = ApiError> + Send>;
+
+    fn delete_file_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = DeleteFileEditResponse, Error = ApiError> + Send>;
+
+    fn delete_fileset(
+        &self,
+        editgroup_id: String,
+        ident: String,
+    ) -> Box<dyn Future<Item = DeleteFilesetResponse, Error = ApiError> + Send>;
+
+    fn delete_fileset_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = DeleteFilesetEditResponse, Error = ApiError> + Send>;
+
+    fn delete_release(
+        &self,
+        editgroup_id: String,
+        ident: String,
+    ) -> Box<dyn Future<Item = DeleteReleaseResponse, Error = ApiError> + Send>;
+
+    fn delete_release_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = DeleteReleaseEditResponse, Error = ApiError> + Send>;
+
+    fn delete_webcapture(
+        &self,
+        editgroup_id: String,
+        ident: String,
+    ) -> Box<dyn Future<Item = DeleteWebcaptureResponse, Error = ApiError> + Send>;
+
+    fn delete_webcapture_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = DeleteWebcaptureEditResponse, Error = ApiError> + Send>;
+
+    fn delete_work(
+        &self,
+        editgroup_id: String,
+        ident: String,
+    ) -> Box<dyn Future<Item = DeleteWorkResponse, Error = ApiError> + Send>;
+
+    fn delete_work_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = DeleteWorkEditResponse, Error = ApiError> + Send>;
+
+    fn get_changelog(
+        &self,
+        limit: Option<i64>,
+    ) -> Box<dyn Future<Item = GetChangelogResponse, Error = ApiError> + Send>;
+
+    fn get_changelog_entry(
+        &self,
+        index: i64,
+    ) -> Box<dyn Future<Item = GetChangelogEntryResponse, Error = ApiError> + Send>;
+
+    fn get_container(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetContainerResponse, Error = ApiError> + Send>;
+
+    fn get_container_edit(
+        &self,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = GetContainerEditResponse, Error = ApiError> + Send>;
+
+    fn get_container_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+    ) -> Box<dyn Future<Item = GetContainerHistoryResponse, Error = ApiError> + Send>;
+
+    fn get_container_redirects(
+        &self,
+        ident: String,
+    ) -> Box<dyn Future<Item = GetContainerRedirectsResponse, Error = ApiError> + Send>;
+
+    fn get_container_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetContainerRevisionResponse, Error = ApiError> + Send>;
+
+    fn get_creator(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetCreatorResponse, Error = ApiError> + Send>;
+
+    fn get_creator_edit(
+        &self,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = GetCreatorEditResponse, Error = ApiError> + Send>;
+
+    fn get_creator_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+    ) -> Box<dyn Future<Item = GetCreatorHistoryResponse, Error = ApiError> + Send>;
+
+    fn get_creator_redirects(
+        &self,
+        ident: String,
+    ) -> Box<dyn Future<Item = GetCreatorRedirectsResponse, Error = ApiError> + Send>;
+
+    fn get_creator_releases(
+        &self,
+        ident: String,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetCreatorReleasesResponse, Error = ApiError> + Send>;
+
+    fn get_creator_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetCreatorRevisionResponse, Error = ApiError> + Send>;
+
+    fn get_editgroup(
+        &self,
+        editgroup_id: String,
+    ) -> Box<dyn Future<Item = GetEditgroupResponse, Error = ApiError> + Send>;
+
+    fn get_editgroup_annotations(
+        &self,
+        editgroup_id: String,
+        expand: Option<String>,
+    ) -> Box<dyn Future<Item = GetEditgroupAnnotationsResponse, Error = ApiError> + Send>;
+
+    fn get_editgroups_reviewable(
+        &self,
+        expand: Option<String>,
+        limit: Option<i64>,
+        before: Option<chrono::DateTime<chrono::Utc>>,
+        since: Option<chrono::DateTime<chrono::Utc>>,
+    ) -> Box<dyn Future<Item = GetEditgroupsReviewableResponse, Error = ApiError> + Send>;
+
+    fn get_editor(
+        &self,
+        editor_id: String,
+    ) -> Box<dyn Future<Item = GetEditorResponse, Error = ApiError> + Send>;
+
+    fn get_editor_annotations(
+        &self,
+        editor_id: String,
+        limit: Option<i64>,
+        before: Option<chrono::DateTime<chrono::Utc>>,
+        since: Option<chrono::DateTime<chrono::Utc>>,
+    ) -> Box<dyn Future<Item = GetEditorAnnotationsResponse, Error = ApiError> + Send>;
+
+    fn get_editor_editgroups(
+        &self,
+        editor_id: String,
+        limit: Option<i64>,
+        before: Option<chrono::DateTime<chrono::Utc>>,
+        since: Option<chrono::DateTime<chrono::Utc>>,
+    ) -> Box<dyn Future<Item = GetEditorEditgroupsResponse, Error = ApiError> + Send>;
+
+    fn get_file(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetFileResponse, Error = ApiError> + Send>;
+
+    fn get_file_edit(
+        &self,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = GetFileEditResponse, Error = ApiError> + Send>;
+
+    fn get_file_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+    ) -> Box<dyn Future<Item = GetFileHistoryResponse, Error = ApiError> + Send>;
+
+    fn get_file_redirects(
+        &self,
+        ident: String,
+    ) -> Box<dyn Future<Item = GetFileRedirectsResponse, Error = ApiError> + Send>;
+
+    fn get_file_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetFileRevisionResponse, Error = ApiError> + Send>;
+
+    fn get_fileset(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetFilesetResponse, Error = ApiError> + Send>;
+
+    fn get_fileset_edit(
+        &self,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = GetFilesetEditResponse, Error = ApiError> + Send>;
+
+    fn get_fileset_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+    ) -> Box<dyn Future<Item = GetFilesetHistoryResponse, Error = ApiError> + Send>;
+
+    fn get_fileset_redirects(
+        &self,
+        ident: String,
+    ) -> Box<dyn Future<Item = GetFilesetRedirectsResponse, Error = ApiError> + Send>;
+
+    fn get_fileset_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetFilesetRevisionResponse, Error = ApiError> + Send>;
+
+    fn get_release(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetReleaseResponse, Error = ApiError> + Send>;
+
+    fn get_release_edit(
+        &self,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = GetReleaseEditResponse, Error = ApiError> + Send>;
+
+    fn get_release_files(
+        &self,
+        ident: String,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetReleaseFilesResponse, Error = ApiError> + Send>;
+
+    fn get_release_filesets(
+        &self,
+        ident: String,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetReleaseFilesetsResponse, Error = ApiError> + Send>;
+
+    fn get_release_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+    ) -> Box<dyn Future<Item = GetReleaseHistoryResponse, Error = ApiError> + Send>;
+
+    fn get_release_redirects(
+        &self,
+        ident: String,
+    ) -> Box<dyn Future<Item = GetReleaseRedirectsResponse, Error = ApiError> + Send>;
+
+    fn get_release_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetReleaseRevisionResponse, Error = ApiError> + Send>;
+
+    fn get_release_webcaptures(
+        &self,
+        ident: String,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetReleaseWebcapturesResponse, Error = ApiError> + Send>;
+
+    fn get_webcapture(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetWebcaptureResponse, Error = ApiError> + Send>;
+
+    fn get_webcapture_edit(
+        &self,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = GetWebcaptureEditResponse, Error = ApiError> + Send>;
+
+    fn get_webcapture_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+    ) -> Box<dyn Future<Item = GetWebcaptureHistoryResponse, Error = ApiError> + Send>;
+
+    fn get_webcapture_redirects(
+        &self,
+        ident: String,
+    ) -> Box<dyn Future<Item = GetWebcaptureRedirectsResponse, Error = ApiError> + Send>;
+
+    fn get_webcapture_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetWebcaptureRevisionResponse, Error = ApiError> + Send>;
+
+    fn get_work(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetWorkResponse, Error = ApiError> + Send>;
+
+    fn get_work_edit(
+        &self,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = GetWorkEditResponse, Error = ApiError> + Send>;
+
+    fn get_work_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+    ) -> Box<dyn Future<Item = GetWorkHistoryResponse, Error = ApiError> + Send>;
+
+    fn get_work_redirects(
+        &self,
+        ident: String,
+    ) -> Box<dyn Future<Item = GetWorkRedirectsResponse, Error = ApiError> + Send>;
+
+    fn get_work_releases(
+        &self,
+        ident: String,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetWorkReleasesResponse, Error = ApiError> + Send>;
+
+    fn get_work_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetWorkRevisionResponse, Error = ApiError> + Send>;
+
+    fn lookup_container(
+        &self,
+        issnl: Option<String>,
+        wikidata_qid: Option<String>,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = LookupContainerResponse, Error = ApiError> + Send>;
+
+    fn lookup_creator(
+        &self,
+        orcid: Option<String>,
+        wikidata_qid: Option<String>,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = LookupCreatorResponse, Error = ApiError> + Send>;
+
+    fn lookup_file(
+        &self,
+        md5: Option<String>,
+        sha1: Option<String>,
+        sha256: Option<String>,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = LookupFileResponse, Error = ApiError> + Send>;
+
+    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>,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = LookupReleaseResponse, Error = ApiError> + Send>;
+
+    fn update_container(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        container_entity: models::ContainerEntity,
+    ) -> Box<dyn Future<Item = UpdateContainerResponse, Error = ApiError> + Send>;
+
+    fn update_creator(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        creator_entity: models::CreatorEntity,
+    ) -> Box<dyn Future<Item = UpdateCreatorResponse, Error = ApiError> + Send>;
+
+    fn update_editgroup(
+        &self,
+        editgroup_id: String,
+        editgroup: models::Editgroup,
+        submit: Option<bool>,
+    ) -> Box<dyn Future<Item = UpdateEditgroupResponse, Error = ApiError> + Send>;
+
+    fn update_editor(
+        &self,
+        editor_id: String,
+        editor: models::Editor,
+    ) -> Box<dyn Future<Item = UpdateEditorResponse, Error = ApiError> + Send>;
+
+    fn update_file(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        file_entity: models::FileEntity,
+    ) -> Box<dyn Future<Item = UpdateFileResponse, Error = ApiError> + Send>;
+
+    fn update_fileset(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        fileset_entity: models::FilesetEntity,
+    ) -> Box<dyn Future<Item = UpdateFilesetResponse, Error = ApiError> + Send>;
+
+    fn update_release(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        release_entity: models::ReleaseEntity,
+    ) -> Box<dyn Future<Item = UpdateReleaseResponse, Error = ApiError> + Send>;
+
+    fn update_webcapture(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        webcapture_entity: models::WebcaptureEntity,
+    ) -> Box<dyn Future<Item = UpdateWebcaptureResponse, Error = ApiError> + Send>;
+
+    fn update_work(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        work_entity: models::WorkEntity,
+    ) -> Box<dyn Future<Item = UpdateWorkResponse, Error = ApiError> + Send>;
+}
+
+/// Trait to extend an API to make it easy to bind it to a context.
+pub trait ContextWrapperExt<'a, C>
+where
+    Self: Sized,
+{
+    /// Binds this API to a context.
+    fn with_context(self: &'a Self, context: C) -> ContextWrapper<'a, Self, C>;
+}
+
+impl<'a, T: Api<C> + Sized, C> ContextWrapperExt<'a, C> for T {
+    fn with_context(self: &'a T, context: C) -> ContextWrapper<'a, T, C> {
+        ContextWrapper::<T, C>::new(self, context)
+    }
+}
+
+impl<'a, T: Api<C>, C> ApiNoContext for ContextWrapper<'a, T, C> {
+    fn accept_editgroup(
+        &self,
+        editgroup_id: String,
+    ) -> Box<dyn Future<Item = AcceptEditgroupResponse, Error = ApiError> + Send> {
+        self.api().accept_editgroup(editgroup_id, &self.context())
+    }
+
+    fn auth_check(
+        &self,
+        role: Option<String>,
+    ) -> Box<dyn Future<Item = AuthCheckResponse, Error = ApiError> + Send> {
+        self.api().auth_check(role, &self.context())
+    }
+
+    fn auth_oidc(
+        &self,
+        auth_oidc: models::AuthOidc,
+    ) -> Box<dyn Future<Item = AuthOidcResponse, Error = ApiError> + Send> {
+        self.api().auth_oidc(auth_oidc, &self.context())
+    }
+
+    fn create_auth_token(
+        &self,
+        editor_id: String,
+        duration_seconds: Option<i32>,
+    ) -> Box<dyn Future<Item = CreateAuthTokenResponse, Error = ApiError> + Send> {
+        self.api()
+            .create_auth_token(editor_id, duration_seconds, &self.context())
+    }
+
+    fn create_container(
+        &self,
+        editgroup_id: String,
+        container_entity: models::ContainerEntity,
+    ) -> Box<dyn Future<Item = CreateContainerResponse, Error = ApiError> + Send> {
+        self.api()
+            .create_container(editgroup_id, container_entity, &self.context())
+    }
+
+    fn create_container_auto_batch(
+        &self,
+        container_auto_batch: models::ContainerAutoBatch,
+    ) -> Box<dyn Future<Item = CreateContainerAutoBatchResponse, Error = ApiError> + Send> {
+        self.api()
+            .create_container_auto_batch(container_auto_batch, &self.context())
+    }
+
+    fn create_creator(
+        &self,
+        editgroup_id: String,
+        creator_entity: models::CreatorEntity,
+    ) -> Box<dyn Future<Item = CreateCreatorResponse, Error = ApiError> + Send> {
+        self.api()
+            .create_creator(editgroup_id, creator_entity, &self.context())
+    }
+
+    fn create_creator_auto_batch(
+        &self,
+        creator_auto_batch: models::CreatorAutoBatch,
+    ) -> Box<dyn Future<Item = CreateCreatorAutoBatchResponse, Error = ApiError> + Send> {
+        self.api()
+            .create_creator_auto_batch(creator_auto_batch, &self.context())
+    }
+
+    fn create_editgroup(
+        &self,
+        editgroup: models::Editgroup,
+    ) -> Box<dyn Future<Item = CreateEditgroupResponse, Error = ApiError> + Send> {
+        self.api().create_editgroup(editgroup, &self.context())
+    }
+
+    fn create_editgroup_annotation(
+        &self,
+        editgroup_id: String,
+        editgroup_annotation: models::EditgroupAnnotation,
+    ) -> Box<dyn Future<Item = CreateEditgroupAnnotationResponse, Error = ApiError> + Send> {
+        self.api()
+            .create_editgroup_annotation(editgroup_id, editgroup_annotation, &self.context())
+    }
+
+    fn create_file(
+        &self,
+        editgroup_id: String,
+        file_entity: models::FileEntity,
+    ) -> Box<dyn Future<Item = CreateFileResponse, Error = ApiError> + Send> {
+        self.api()
+            .create_file(editgroup_id, file_entity, &self.context())
+    }
+
+    fn create_file_auto_batch(
+        &self,
+        file_auto_batch: models::FileAutoBatch,
+    ) -> Box<dyn Future<Item = CreateFileAutoBatchResponse, Error = ApiError> + Send> {
+        self.api()
+            .create_file_auto_batch(file_auto_batch, &self.context())
+    }
+
+    fn create_fileset(
+        &self,
+        editgroup_id: String,
+        fileset_entity: models::FilesetEntity,
+    ) -> Box<dyn Future<Item = CreateFilesetResponse, Error = ApiError> + Send> {
+        self.api()
+            .create_fileset(editgroup_id, fileset_entity, &self.context())
+    }
+
+    fn create_fileset_auto_batch(
+        &self,
+        fileset_auto_batch: models::FilesetAutoBatch,
+    ) -> Box<dyn Future<Item = CreateFilesetAutoBatchResponse, Error = ApiError> + Send> {
+        self.api()
+            .create_fileset_auto_batch(fileset_auto_batch, &self.context())
+    }
+
+    fn create_release(
+        &self,
+        editgroup_id: String,
+        release_entity: models::ReleaseEntity,
+    ) -> Box<dyn Future<Item = CreateReleaseResponse, Error = ApiError> + Send> {
+        self.api()
+            .create_release(editgroup_id, release_entity, &self.context())
+    }
+
+    fn create_release_auto_batch(
+        &self,
+        release_auto_batch: models::ReleaseAutoBatch,
+    ) -> Box<dyn Future<Item = CreateReleaseAutoBatchResponse, Error = ApiError> + Send> {
+        self.api()
+            .create_release_auto_batch(release_auto_batch, &self.context())
+    }
+
+    fn create_webcapture(
+        &self,
+        editgroup_id: String,
+        webcapture_entity: models::WebcaptureEntity,
+    ) -> Box<dyn Future<Item = CreateWebcaptureResponse, Error = ApiError> + Send> {
+        self.api()
+            .create_webcapture(editgroup_id, webcapture_entity, &self.context())
+    }
+
+    fn create_webcapture_auto_batch(
+        &self,
+        webcapture_auto_batch: models::WebcaptureAutoBatch,
+    ) -> Box<dyn Future<Item = CreateWebcaptureAutoBatchResponse, Error = ApiError> + Send> {
+        self.api()
+            .create_webcapture_auto_batch(webcapture_auto_batch, &self.context())
+    }
+
+    fn create_work(
+        &self,
+        editgroup_id: String,
+        work_entity: models::WorkEntity,
+    ) -> Box<dyn Future<Item = CreateWorkResponse, Error = ApiError> + Send> {
+        self.api()
+            .create_work(editgroup_id, work_entity, &self.context())
+    }
+
+    fn create_work_auto_batch(
+        &self,
+        work_auto_batch: models::WorkAutoBatch,
+    ) -> Box<dyn Future<Item = CreateWorkAutoBatchResponse, Error = ApiError> + Send> {
+        self.api()
+            .create_work_auto_batch(work_auto_batch, &self.context())
+    }
+
+    fn delete_container(
+        &self,
+        editgroup_id: String,
+        ident: String,
+    ) -> Box<dyn Future<Item = DeleteContainerResponse, Error = ApiError> + Send> {
+        self.api()
+            .delete_container(editgroup_id, ident, &self.context())
+    }
+
+    fn delete_container_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = DeleteContainerEditResponse, Error = ApiError> + Send> {
+        self.api()
+            .delete_container_edit(editgroup_id, edit_id, &self.context())
+    }
+
+    fn delete_creator(
+        &self,
+        editgroup_id: String,
+        ident: String,
+    ) -> Box<dyn Future<Item = DeleteCreatorResponse, Error = ApiError> + Send> {
+        self.api()
+            .delete_creator(editgroup_id, ident, &self.context())
+    }
+
+    fn delete_creator_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = DeleteCreatorEditResponse, Error = ApiError> + Send> {
+        self.api()
+            .delete_creator_edit(editgroup_id, edit_id, &self.context())
+    }
+
+    fn delete_file(
+        &self,
+        editgroup_id: String,
+        ident: String,
+    ) -> Box<dyn Future<Item = DeleteFileResponse, Error = ApiError> + Send> {
+        self.api().delete_file(editgroup_id, ident, &self.context())
+    }
+
+    fn delete_file_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = DeleteFileEditResponse, Error = ApiError> + Send> {
+        self.api()
+            .delete_file_edit(editgroup_id, edit_id, &self.context())
+    }
+
+    fn delete_fileset(
+        &self,
+        editgroup_id: String,
+        ident: String,
+    ) -> Box<dyn Future<Item = DeleteFilesetResponse, Error = ApiError> + Send> {
+        self.api()
+            .delete_fileset(editgroup_id, ident, &self.context())
+    }
+
+    fn delete_fileset_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = DeleteFilesetEditResponse, Error = ApiError> + Send> {
+        self.api()
+            .delete_fileset_edit(editgroup_id, edit_id, &self.context())
+    }
+
+    fn delete_release(
+        &self,
+        editgroup_id: String,
+        ident: String,
+    ) -> Box<dyn Future<Item = DeleteReleaseResponse, Error = ApiError> + Send> {
+        self.api()
+            .delete_release(editgroup_id, ident, &self.context())
+    }
+
+    fn delete_release_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = DeleteReleaseEditResponse, Error = ApiError> + Send> {
+        self.api()
+            .delete_release_edit(editgroup_id, edit_id, &self.context())
+    }
+
+    fn delete_webcapture(
+        &self,
+        editgroup_id: String,
+        ident: String,
+    ) -> Box<dyn Future<Item = DeleteWebcaptureResponse, Error = ApiError> + Send> {
+        self.api()
+            .delete_webcapture(editgroup_id, ident, &self.context())
+    }
+
+    fn delete_webcapture_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = DeleteWebcaptureEditResponse, Error = ApiError> + Send> {
+        self.api()
+            .delete_webcapture_edit(editgroup_id, edit_id, &self.context())
+    }
+
+    fn delete_work(
+        &self,
+        editgroup_id: String,
+        ident: String,
+    ) -> Box<dyn Future<Item = DeleteWorkResponse, Error = ApiError> + Send> {
+        self.api().delete_work(editgroup_id, ident, &self.context())
+    }
+
+    fn delete_work_edit(
+        &self,
+        editgroup_id: String,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = DeleteWorkEditResponse, Error = ApiError> + Send> {
+        self.api()
+            .delete_work_edit(editgroup_id, edit_id, &self.context())
+    }
+
+    fn get_changelog(
+        &self,
+        limit: Option<i64>,
+    ) -> Box<dyn Future<Item = GetChangelogResponse, Error = ApiError> + Send> {
+        self.api().get_changelog(limit, &self.context())
+    }
+
+    fn get_changelog_entry(
+        &self,
+        index: i64,
+    ) -> Box<dyn Future<Item = GetChangelogEntryResponse, Error = ApiError> + Send> {
+        self.api().get_changelog_entry(index, &self.context())
+    }
+
+    fn get_container(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetContainerResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_container(ident, expand, hide, &self.context())
+    }
+
+    fn get_container_edit(
+        &self,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = GetContainerEditResponse, Error = ApiError> + Send> {
+        self.api().get_container_edit(edit_id, &self.context())
+    }
+
+    fn get_container_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+    ) -> Box<dyn Future<Item = GetContainerHistoryResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_container_history(ident, limit, &self.context())
+    }
+
+    fn get_container_redirects(
+        &self,
+        ident: String,
+    ) -> Box<dyn Future<Item = GetContainerRedirectsResponse, Error = ApiError> + Send> {
+        self.api().get_container_redirects(ident, &self.context())
+    }
+
+    fn get_container_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetContainerRevisionResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_container_revision(rev_id, expand, hide, &self.context())
+    }
+
+    fn get_creator(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetCreatorResponse, Error = ApiError> + Send> {
+        self.api().get_creator(ident, expand, hide, &self.context())
+    }
+
+    fn get_creator_edit(
+        &self,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = GetCreatorEditResponse, Error = ApiError> + Send> {
+        self.api().get_creator_edit(edit_id, &self.context())
+    }
+
+    fn get_creator_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+    ) -> Box<dyn Future<Item = GetCreatorHistoryResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_creator_history(ident, limit, &self.context())
+    }
+
+    fn get_creator_redirects(
+        &self,
+        ident: String,
+    ) -> Box<dyn Future<Item = GetCreatorRedirectsResponse, Error = ApiError> + Send> {
+        self.api().get_creator_redirects(ident, &self.context())
+    }
+
+    fn get_creator_releases(
+        &self,
+        ident: String,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetCreatorReleasesResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_creator_releases(ident, hide, &self.context())
+    }
+
+    fn get_creator_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetCreatorRevisionResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_creator_revision(rev_id, expand, hide, &self.context())
+    }
+
+    fn get_editgroup(
+        &self,
+        editgroup_id: String,
+    ) -> Box<dyn Future<Item = GetEditgroupResponse, Error = ApiError> + Send> {
+        self.api().get_editgroup(editgroup_id, &self.context())
+    }
+
+    fn get_editgroup_annotations(
+        &self,
+        editgroup_id: String,
+        expand: Option<String>,
+    ) -> Box<dyn Future<Item = GetEditgroupAnnotationsResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_editgroup_annotations(editgroup_id, expand, &self.context())
+    }
+
+    fn get_editgroups_reviewable(
+        &self,
+        expand: Option<String>,
+        limit: Option<i64>,
+        before: Option<chrono::DateTime<chrono::Utc>>,
+        since: Option<chrono::DateTime<chrono::Utc>>,
+    ) -> Box<dyn Future<Item = GetEditgroupsReviewableResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_editgroups_reviewable(expand, limit, before, since, &self.context())
+    }
+
+    fn get_editor(
+        &self,
+        editor_id: String,
+    ) -> Box<dyn Future<Item = GetEditorResponse, Error = ApiError> + Send> {
+        self.api().get_editor(editor_id, &self.context())
+    }
+
+    fn get_editor_annotations(
+        &self,
+        editor_id: String,
+        limit: Option<i64>,
+        before: Option<chrono::DateTime<chrono::Utc>>,
+        since: Option<chrono::DateTime<chrono::Utc>>,
+    ) -> Box<dyn Future<Item = GetEditorAnnotationsResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_editor_annotations(editor_id, limit, before, since, &self.context())
+    }
+
+    fn get_editor_editgroups(
+        &self,
+        editor_id: String,
+        limit: Option<i64>,
+        before: Option<chrono::DateTime<chrono::Utc>>,
+        since: Option<chrono::DateTime<chrono::Utc>>,
+    ) -> Box<dyn Future<Item = GetEditorEditgroupsResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_editor_editgroups(editor_id, limit, before, since, &self.context())
+    }
+
+    fn get_file(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetFileResponse, Error = ApiError> + Send> {
+        self.api().get_file(ident, expand, hide, &self.context())
+    }
+
+    fn get_file_edit(
+        &self,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = GetFileEditResponse, Error = ApiError> + Send> {
+        self.api().get_file_edit(edit_id, &self.context())
+    }
+
+    fn get_file_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+    ) -> Box<dyn Future<Item = GetFileHistoryResponse, Error = ApiError> + Send> {
+        self.api().get_file_history(ident, limit, &self.context())
+    }
+
+    fn get_file_redirects(
+        &self,
+        ident: String,
+    ) -> Box<dyn Future<Item = GetFileRedirectsResponse, Error = ApiError> + Send> {
+        self.api().get_file_redirects(ident, &self.context())
+    }
+
+    fn get_file_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetFileRevisionResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_file_revision(rev_id, expand, hide, &self.context())
+    }
+
+    fn get_fileset(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetFilesetResponse, Error = ApiError> + Send> {
+        self.api().get_fileset(ident, expand, hide, &self.context())
+    }
+
+    fn get_fileset_edit(
+        &self,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = GetFilesetEditResponse, Error = ApiError> + Send> {
+        self.api().get_fileset_edit(edit_id, &self.context())
+    }
+
+    fn get_fileset_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+    ) -> Box<dyn Future<Item = GetFilesetHistoryResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_fileset_history(ident, limit, &self.context())
+    }
+
+    fn get_fileset_redirects(
+        &self,
+        ident: String,
+    ) -> Box<dyn Future<Item = GetFilesetRedirectsResponse, Error = ApiError> + Send> {
+        self.api().get_fileset_redirects(ident, &self.context())
+    }
+
+    fn get_fileset_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetFilesetRevisionResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_fileset_revision(rev_id, expand, hide, &self.context())
+    }
+
+    fn get_release(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetReleaseResponse, Error = ApiError> + Send> {
+        self.api().get_release(ident, expand, hide, &self.context())
+    }
+
+    fn get_release_edit(
+        &self,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = GetReleaseEditResponse, Error = ApiError> + Send> {
+        self.api().get_release_edit(edit_id, &self.context())
+    }
+
+    fn get_release_files(
+        &self,
+        ident: String,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetReleaseFilesResponse, Error = ApiError> + Send> {
+        self.api().get_release_files(ident, hide, &self.context())
+    }
+
+    fn get_release_filesets(
+        &self,
+        ident: String,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetReleaseFilesetsResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_release_filesets(ident, hide, &self.context())
+    }
+
+    fn get_release_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+    ) -> Box<dyn Future<Item = GetReleaseHistoryResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_release_history(ident, limit, &self.context())
+    }
+
+    fn get_release_redirects(
+        &self,
+        ident: String,
+    ) -> Box<dyn Future<Item = GetReleaseRedirectsResponse, Error = ApiError> + Send> {
+        self.api().get_release_redirects(ident, &self.context())
+    }
+
+    fn get_release_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetReleaseRevisionResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_release_revision(rev_id, expand, hide, &self.context())
+    }
+
+    fn get_release_webcaptures(
+        &self,
+        ident: String,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetReleaseWebcapturesResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_release_webcaptures(ident, hide, &self.context())
+    }
+
+    fn get_webcapture(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetWebcaptureResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_webcapture(ident, expand, hide, &self.context())
+    }
+
+    fn get_webcapture_edit(
+        &self,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = GetWebcaptureEditResponse, Error = ApiError> + Send> {
+        self.api().get_webcapture_edit(edit_id, &self.context())
+    }
+
+    fn get_webcapture_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+    ) -> Box<dyn Future<Item = GetWebcaptureHistoryResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_webcapture_history(ident, limit, &self.context())
+    }
+
+    fn get_webcapture_redirects(
+        &self,
+        ident: String,
+    ) -> Box<dyn Future<Item = GetWebcaptureRedirectsResponse, Error = ApiError> + Send> {
+        self.api().get_webcapture_redirects(ident, &self.context())
+    }
+
+    fn get_webcapture_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetWebcaptureRevisionResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_webcapture_revision(rev_id, expand, hide, &self.context())
+    }
+
+    fn get_work(
+        &self,
+        ident: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetWorkResponse, Error = ApiError> + Send> {
+        self.api().get_work(ident, expand, hide, &self.context())
+    }
+
+    fn get_work_edit(
+        &self,
+        edit_id: String,
+    ) -> Box<dyn Future<Item = GetWorkEditResponse, Error = ApiError> + Send> {
+        self.api().get_work_edit(edit_id, &self.context())
+    }
+
+    fn get_work_history(
+        &self,
+        ident: String,
+        limit: Option<i64>,
+    ) -> Box<dyn Future<Item = GetWorkHistoryResponse, Error = ApiError> + Send> {
+        self.api().get_work_history(ident, limit, &self.context())
+    }
+
+    fn get_work_redirects(
+        &self,
+        ident: String,
+    ) -> Box<dyn Future<Item = GetWorkRedirectsResponse, Error = ApiError> + Send> {
+        self.api().get_work_redirects(ident, &self.context())
+    }
+
+    fn get_work_releases(
+        &self,
+        ident: String,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetWorkReleasesResponse, Error = ApiError> + Send> {
+        self.api().get_work_releases(ident, hide, &self.context())
+    }
+
+    fn get_work_revision(
+        &self,
+        rev_id: String,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = GetWorkRevisionResponse, Error = ApiError> + Send> {
+        self.api()
+            .get_work_revision(rev_id, expand, hide, &self.context())
+    }
+
+    fn lookup_container(
+        &self,
+        issnl: Option<String>,
+        wikidata_qid: Option<String>,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = LookupContainerResponse, Error = ApiError> + Send> {
+        self.api()
+            .lookup_container(issnl, wikidata_qid, expand, hide, &self.context())
+    }
+
+    fn lookup_creator(
+        &self,
+        orcid: Option<String>,
+        wikidata_qid: Option<String>,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = LookupCreatorResponse, Error = ApiError> + Send> {
+        self.api()
+            .lookup_creator(orcid, wikidata_qid, expand, hide, &self.context())
+    }
+
+    fn lookup_file(
+        &self,
+        md5: Option<String>,
+        sha1: Option<String>,
+        sha256: Option<String>,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = LookupFileResponse, Error = ApiError> + Send> {
+        self.api()
+            .lookup_file(md5, sha1, sha256, expand, hide, &self.context())
+    }
+
+    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>,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Box<dyn Future<Item = LookupReleaseResponse, Error = ApiError> + Send> {
+        self.api().lookup_release(
+            doi,
+            wikidata_qid,
+            isbn13,
+            pmid,
+            pmcid,
+            core,
+            arxiv,
+            jstor,
+            ark,
+            mag,
+            expand,
+            hide,
+            &self.context(),
+        )
+    }
+
+    fn update_container(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        container_entity: models::ContainerEntity,
+    ) -> Box<dyn Future<Item = UpdateContainerResponse, Error = ApiError> + Send> {
+        self.api()
+            .update_container(editgroup_id, ident, container_entity, &self.context())
+    }
+
+    fn update_creator(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        creator_entity: models::CreatorEntity,
+    ) -> Box<dyn Future<Item = UpdateCreatorResponse, Error = ApiError> + Send> {
+        self.api()
+            .update_creator(editgroup_id, ident, creator_entity, &self.context())
+    }
+
+    fn update_editgroup(
+        &self,
+        editgroup_id: String,
+        editgroup: models::Editgroup,
+        submit: Option<bool>,
+    ) -> Box<dyn Future<Item = UpdateEditgroupResponse, Error = ApiError> + Send> {
+        self.api()
+            .update_editgroup(editgroup_id, editgroup, submit, &self.context())
+    }
+
+    fn update_editor(
+        &self,
+        editor_id: String,
+        editor: models::Editor,
+    ) -> Box<dyn Future<Item = UpdateEditorResponse, Error = ApiError> + Send> {
+        self.api().update_editor(editor_id, editor, &self.context())
+    }
+
+    fn update_file(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        file_entity: models::FileEntity,
+    ) -> Box<dyn Future<Item = UpdateFileResponse, Error = ApiError> + Send> {
+        self.api()
+            .update_file(editgroup_id, ident, file_entity, &self.context())
+    }
+
+    fn update_fileset(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        fileset_entity: models::FilesetEntity,
+    ) -> Box<dyn Future<Item = UpdateFilesetResponse, Error = ApiError> + Send> {
+        self.api()
+            .update_fileset(editgroup_id, ident, fileset_entity, &self.context())
+    }
+
+    fn update_release(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        release_entity: models::ReleaseEntity,
+    ) -> Box<dyn Future<Item = UpdateReleaseResponse, Error = ApiError> + Send> {
+        self.api()
+            .update_release(editgroup_id, ident, release_entity, &self.context())
+    }
+
+    fn update_webcapture(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        webcapture_entity: models::WebcaptureEntity,
+    ) -> Box<dyn Future<Item = UpdateWebcaptureResponse, Error = ApiError> + Send> {
+        self.api()
+            .update_webcapture(editgroup_id, ident, webcapture_entity, &self.context())
+    }
+
+    fn update_work(
+        &self,
+        editgroup_id: String,
+        ident: String,
+        work_entity: models::WorkEntity,
+    ) -> Box<dyn Future<Item = UpdateWorkResponse, Error = ApiError> + Send> {
+        self.api()
+            .update_work(editgroup_id, ident, work_entity, &self.context())
+    }
+}
+
+#[cfg(feature = "client")]
+pub mod client;
+
+// Re-export Client as a top-level name
+#[cfg(feature = "client")]
+pub use client::Client;
+
+#[cfg(feature = "server")]
+pub mod server;
+
+// Re-export router() as a top-level name
+#[cfg(feature = "server")]
+pub use self::server::Service;
+
+#[cfg(feature = "server")]
+pub mod context;
+
+pub mod models;
+
+#[cfg(any(feature = "client", feature = "server"))]
+pub(crate) mod header;
diff --git a/rust/fatcat-openapi/src/models.rs b/rust/fatcat-openapi/src/models.rs
new file mode 100644
index 0000000..b0a802c
--- /dev/null
+++ b/rust/fatcat-openapi/src/models.rs
@@ -0,0 +1,7573 @@
+#![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>,
+}
+
+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,
+        }
+    }
+}
+
+/// 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());
+        }
+
+        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>,
+        }
+
+        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))?),
+                    _ => {
+                        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(),
+        })
+    }
+}
+
+// Methods for converting between header::IntoHeaderValue<ReleaseRef> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseRef>> for hyper::header::HeaderValue {
+    type Error = String;
+
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<ReleaseRef>,
+    ) -> std::result::Result<Self, Self::Error> {
+        let hdr_value = hdr_value.to_string();
+        match hyper::header::HeaderValue::from_str(&hdr_value) {
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Invalid header value for ReleaseRef - value: {} is invalid {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseRef> {
+    type Error = String;
+
+    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+        match hdr_value.to_str() {
+            std::result::Result::Ok(value) => {
+                match <ReleaseRef as std::str::FromStr>::from_str(value) {
+                    std::result::Result::Ok(value) => {
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
+                    }
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
+                        "Unable to convert header value '{}' into ReleaseRef - {}",
+                        value, err
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct ReleaseRef {
+    /// Zero-indexed sequence number of this reference in the list of references. Assigned automatically and used internally; don't confuse with `key`.
+    #[serde(rename = "index")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub index: Option<i64>,
+
+    /// Optional, fatcat identifier of release entity that this reference is citing.
+    #[serde(rename = "target_release_id")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub target_release_id: Option<String>,
+
+    /// Additional free-form JSON metadata about this citation. Generally follows Citation Style Language (CSL) JSON schema. See guide for details.
+    #[serde(rename = "extra")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+    /// Short string used to indicate this reference from within the release text; or numbering of references as typeset in the release itself. Optional; don't confuse with `index` field.
+    #[serde(rename = "key")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub key: Option<String>,
+
+    /// Year that the cited work was published in.
+    #[serde(rename = "year")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub year: Option<i64>,
+
+    /// Name of the container (eg, journal) that the citation work was published as part of. May be an acronym or full name.
+    #[serde(rename = "container_name")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub container_name: Option<String>,
+
+    /// Name of the work being cited.
+    #[serde(rename = "title")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+
+    /// Page number or other indicator of the specific subset of a work being cited. Not to be confused with the first page (or page range) of an entire paper or chapter being cited.
+    #[serde(rename = "locator")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub locator: Option<String>,
+}
+
+impl ReleaseRef {
+    pub fn new() -> ReleaseRef {
+        ReleaseRef {
+            index: None,
+            target_release_id: None,
+            extra: None,
+            key: None,
+            year: None,
+            container_name: None,
+            title: None,
+            locator: None,
+        }
+    }
+}
+
+/// Converts the ReleaseRef value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for ReleaseRef {
+    fn to_string(&self) -> String {
+        let mut params: Vec<String> = vec![];
+
+        if let Some(ref index) = self.index {
+            params.push("index".to_string());
+            params.push(index.to_string());
+        }
+
+        if let Some(ref target_release_id) = self.target_release_id {
+            params.push("target_release_id".to_string());
+            params.push(target_release_id.to_string());
+        }
+
+        // Skipping extra in query parameter serialization
+        // Skipping extra in query parameter serialization
+
+        if let Some(ref key) = self.key {
+            params.push("key".to_string());
+            params.push(key.to_string());
+        }
+
+        if let Some(ref year) = self.year {
+            params.push("year".to_string());
+            params.push(year.to_string());
+        }
+
+        if let Some(ref container_name) = self.container_name {
+            params.push("container_name".to_string());
+            params.push(container_name.to_string());
+        }
+
+        if let Some(ref title) = self.title {
+            params.push("title".to_string());
+            params.push(title.to_string());
+        }
+
+        if let Some(ref locator) = self.locator {
+            params.push("locator".to_string());
+            params.push(locator.to_string());
+        }
+
+        params.join(",").to_string()
+    }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseRef value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for ReleaseRef {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        #[derive(Default)]
+        // An intermediate representation of the struct to use for parsing.
+        struct IntermediateRep {
+            pub index: Vec<i64>,
+            pub target_release_id: Vec<String>,
+            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+            pub key: Vec<String>,
+            pub year: Vec<i64>,
+            pub container_name: Vec<String>,
+            pub title: Vec<String>,
+            pub locator: Vec<String>,
+        }
+
+        let mut intermediate_rep = IntermediateRep::default();
+
+        // Parse into intermediate representation
+        let mut string_iter = s.split(',').into_iter();
+        let mut key_result = string_iter.next();
+
+        while key_result.is_some() {
+            let val = match string_iter.next() {
+                Some(x) => x,
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing ReleaseRef".to_string(),
+                    )
+                }
+            };
+
+            if let Some(key) = key_result {
+                match key {
+                    "index" => intermediate_rep
+                        .index
+                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+                    "target_release_id" => intermediate_rep
+                        .target_release_id
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "extra" => {
+                        return std::result::Result::Err(
+                            "Parsing a container in this style is not supported in ReleaseRef"
+                                .to_string(),
+                        )
+                    }
+                    "key" => intermediate_rep
+                        .key
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "year" => intermediate_rep
+                        .year
+                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+                    "container_name" => intermediate_rep
+                        .container_name
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "title" => intermediate_rep
+                        .title
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "locator" => intermediate_rep
+                        .locator
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing ReleaseRef".to_string(),
+                        )
+                    }
+                }
+            }
+
+            // Get the next key
+            key_result = string_iter.next();
+        }
+
+        // Use the intermediate representation to return the struct
+        std::result::Result::Ok(ReleaseRef {
+            index: intermediate_rep.index.into_iter().next(),
+            target_release_id: intermediate_rep.target_release_id.into_iter().next(),
+            extra: intermediate_rep.extra.into_iter().next(),
+            key: intermediate_rep.key.into_iter().next(),
+            year: intermediate_rep.year.into_iter().next(),
+            container_name: intermediate_rep.container_name.into_iter().next(),
+            title: intermediate_rep.title.into_iter().next(),
+            locator: intermediate_rep.locator.into_iter().next(),
+        })
+    }
+}
+
+// Methods for converting between header::IntoHeaderValue<Success> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<Success>> for hyper::header::HeaderValue {
+    type Error = String;
+
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<Success>,
+    ) -> std::result::Result<Self, Self::Error> {
+        let hdr_value = hdr_value.to_string();
+        match hyper::header::HeaderValue::from_str(&hdr_value) {
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Invalid header value for Success - value: {} is invalid {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Success> {
+    type Error = String;
+
+    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+        match hdr_value.to_str() {
+            std::result::Result::Ok(value) => {
+                match <Success as std::str::FromStr>::from_str(value) {
+                    std::result::Result::Ok(value) => {
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
+                    }
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
+                        "Unable to convert header value '{}' into Success - {}",
+                        value, err
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct Success {
+    #[serde(rename = "success")]
+    pub success: bool,
+
+    #[serde(rename = "message")]
+    pub message: String,
+}
+
+impl Success {
+    pub fn new(success: bool, message: String) -> Success {
+        Success {
+            success: success,
+            message: message,
+        }
+    }
+}
+
+/// Converts the Success value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for Success {
+    fn to_string(&self) -> String {
+        let mut params: Vec<String> = vec![];
+
+        params.push("success".to_string());
+        params.push(self.success.to_string());
+
+        params.push("message".to_string());
+        params.push(self.message.to_string());
+
+        params.join(",").to_string()
+    }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a Success value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for Success {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        #[derive(Default)]
+        // An intermediate representation of the struct to use for parsing.
+        struct IntermediateRep {
+            pub success: Vec<bool>,
+            pub message: Vec<String>,
+        }
+
+        let mut intermediate_rep = IntermediateRep::default();
+
+        // Parse into intermediate representation
+        let mut string_iter = s.split(',').into_iter();
+        let mut key_result = string_iter.next();
+
+        while key_result.is_some() {
+            let val = match string_iter.next() {
+                Some(x) => x,
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing Success".to_string(),
+                    )
+                }
+            };
+
+            if let Some(key) = key_result {
+                match key {
+                    "success" => intermediate_rep
+                        .success
+                        .push(bool::from_str(val).map_err(|x| format!("{}", x))?),
+                    "message" => intermediate_rep
+                        .message
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing Success".to_string(),
+                        )
+                    }
+                }
+            }
+
+            // Get the next key
+            key_result = string_iter.next();
+        }
+
+        // Use the intermediate representation to return the struct
+        std::result::Result::Ok(Success {
+            success: intermediate_rep
+                .success
+                .into_iter()
+                .next()
+                .ok_or("success missing in Success".to_string())?,
+            message: intermediate_rep
+                .message
+                .into_iter()
+                .next()
+                .ok_or("message missing in Success".to_string())?,
+        })
+    }
+}
+
+// Methods for converting between header::IntoHeaderValue<WebcaptureAutoBatch> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureAutoBatch>>
+    for hyper::header::HeaderValue
+{
+    type Error = String;
+
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<WebcaptureAutoBatch>,
+    ) -> std::result::Result<Self, Self::Error> {
+        let hdr_value = hdr_value.to_string();
+        match hyper::header::HeaderValue::from_str(&hdr_value) {
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Invalid header value for WebcaptureAutoBatch - value: {} is invalid {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+    for header::IntoHeaderValue<WebcaptureAutoBatch>
+{
+    type Error = String;
+
+    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+        match hdr_value.to_str() {
+            std::result::Result::Ok(value) => {
+                match <WebcaptureAutoBatch as std::str::FromStr>::from_str(value) {
+                    std::result::Result::Ok(value) => {
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
+                    }
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
+                        "Unable to convert header value '{}' into WebcaptureAutoBatch - {}",
+                        value, err
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WebcaptureAutoBatch {
+    #[serde(rename = "editgroup")]
+    pub editgroup: models::Editgroup,
+
+    #[serde(rename = "entity_list")]
+    pub entity_list: Vec<models::WebcaptureEntity>,
+}
+
+impl WebcaptureAutoBatch {
+    pub fn new(
+        editgroup: models::Editgroup,
+        entity_list: Vec<models::WebcaptureEntity>,
+    ) -> WebcaptureAutoBatch {
+        WebcaptureAutoBatch {
+            editgroup: editgroup,
+            entity_list: entity_list,
+        }
+    }
+}
+
+/// Converts the WebcaptureAutoBatch value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WebcaptureAutoBatch {
+    fn to_string(&self) -> String {
+        let mut params: Vec<String> = vec![];
+        // Skipping editgroup in query parameter serialization
+
+        // Skipping entity_list in query parameter serialization
+
+        params.join(",").to_string()
+    }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureAutoBatch value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WebcaptureAutoBatch {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        #[derive(Default)]
+        // An intermediate representation of the struct to use for parsing.
+        struct IntermediateRep {
+            pub editgroup: Vec<models::Editgroup>,
+            pub entity_list: Vec<Vec<models::WebcaptureEntity>>,
+        }
+
+        let mut intermediate_rep = IntermediateRep::default();
+
+        // Parse into intermediate representation
+        let mut string_iter = s.split(',').into_iter();
+        let mut key_result = string_iter.next();
+
+        while key_result.is_some() {
+            let val = match string_iter.next() {
+                Some(x) => x,
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing WebcaptureAutoBatch".to_string(),
+                    )
+                }
+            };
+
+            if let Some(key) = key_result {
+                match key {
+                    "editgroup" => intermediate_rep
+                        .editgroup
+                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
+                    "entity_list" => return std::result::Result::Err(
+                        "Parsing a container in this style is not supported in WebcaptureAutoBatch"
+                            .to_string(),
+                    ),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing WebcaptureAutoBatch".to_string(),
+                        )
+                    }
+                }
+            }
+
+            // Get the next key
+            key_result = string_iter.next();
+        }
+
+        // Use the intermediate representation to return the struct
+        std::result::Result::Ok(WebcaptureAutoBatch {
+            editgroup: intermediate_rep
+                .editgroup
+                .into_iter()
+                .next()
+                .ok_or("editgroup missing in WebcaptureAutoBatch".to_string())?,
+            entity_list: intermediate_rep
+                .entity_list
+                .into_iter()
+                .next()
+                .ok_or("entity_list missing in WebcaptureAutoBatch".to_string())?,
+        })
+    }
+}
+
+// Methods for converting between header::IntoHeaderValue<WebcaptureCdxLine> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureCdxLine>>
+    for hyper::header::HeaderValue
+{
+    type Error = String;
+
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<WebcaptureCdxLine>,
+    ) -> std::result::Result<Self, Self::Error> {
+        let hdr_value = hdr_value.to_string();
+        match hyper::header::HeaderValue::from_str(&hdr_value) {
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Invalid header value for WebcaptureCdxLine - value: {} is invalid {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+    for header::IntoHeaderValue<WebcaptureCdxLine>
+{
+    type Error = String;
+
+    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+        match hdr_value.to_str() {
+            std::result::Result::Ok(value) => {
+                match <WebcaptureCdxLine as std::str::FromStr>::from_str(value) {
+                    std::result::Result::Ok(value) => {
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
+                    }
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
+                        "Unable to convert header value '{}' into WebcaptureCdxLine - {}",
+                        value, err
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WebcaptureCdxLine {
+    /// \"Sortable URL\" format. See guide for details.
+    #[serde(rename = "surt")]
+    pub surt: String,
+
+    /// Date and time of capture, in ISO format. UTC, 'Z'-terminated, second (or better) precision.
+    #[serde(rename = "timestamp")]
+    pub timestamp: chrono::DateTime<chrono::Utc>,
+
+    /// Full URL/URI of resource captured.
+    #[serde(rename = "url")]
+    pub url: String,
+
+    /// Mimetype of the resource at this URL. May be the Content-Type header, or the actually sniffed file type.
+    #[serde(rename = "mimetype")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mimetype: Option<String>,
+
+    /// HTTP status code. Should generally be 200, especially for the primary resource, but may be 3xx (redirect) or even error codes if embedded resources can not be fetched successfully.
+    #[serde(rename = "status_code")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub status_code: Option<i64>,
+
+    /// Resource (file) size in bytes
+    #[serde(rename = "size")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub size: Option<i64>,
+
+    /// SHA-1 hash of data, in hex encoding
+    #[serde(rename = "sha1")]
+    pub sha1: String,
+
+    /// SHA-256 hash of data, in hex encoding
+    #[serde(rename = "sha256")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sha256: Option<String>,
+}
+
+impl WebcaptureCdxLine {
+    pub fn new(
+        surt: String,
+        timestamp: chrono::DateTime<chrono::Utc>,
+        url: String,
+        sha1: String,
+    ) -> WebcaptureCdxLine {
+        WebcaptureCdxLine {
+            surt: surt,
+            timestamp: timestamp,
+            url: url,
+            mimetype: None,
+            status_code: None,
+            size: None,
+            sha1: sha1,
+            sha256: None,
+        }
+    }
+}
+
+/// Converts the WebcaptureCdxLine value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WebcaptureCdxLine {
+    fn to_string(&self) -> String {
+        let mut params: Vec<String> = vec![];
+
+        params.push("surt".to_string());
+        params.push(self.surt.to_string());
+
+        // Skipping timestamp in query parameter serialization
+
+        params.push("url".to_string());
+        params.push(self.url.to_string());
+
+        if let Some(ref mimetype) = self.mimetype {
+            params.push("mimetype".to_string());
+            params.push(mimetype.to_string());
+        }
+
+        if let Some(ref status_code) = self.status_code {
+            params.push("status_code".to_string());
+            params.push(status_code.to_string());
+        }
+
+        if let Some(ref size) = self.size {
+            params.push("size".to_string());
+            params.push(size.to_string());
+        }
+
+        params.push("sha1".to_string());
+        params.push(self.sha1.to_string());
+
+        if let Some(ref sha256) = self.sha256 {
+            params.push("sha256".to_string());
+            params.push(sha256.to_string());
+        }
+
+        params.join(",").to_string()
+    }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureCdxLine value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WebcaptureCdxLine {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        #[derive(Default)]
+        // An intermediate representation of the struct to use for parsing.
+        struct IntermediateRep {
+            pub surt: Vec<String>,
+            pub timestamp: Vec<chrono::DateTime<chrono::Utc>>,
+            pub url: Vec<String>,
+            pub mimetype: Vec<String>,
+            pub status_code: Vec<i64>,
+            pub size: Vec<i64>,
+            pub sha1: Vec<String>,
+            pub sha256: Vec<String>,
+        }
+
+        let mut intermediate_rep = IntermediateRep::default();
+
+        // Parse into intermediate representation
+        let mut string_iter = s.split(',').into_iter();
+        let mut key_result = string_iter.next();
+
+        while key_result.is_some() {
+            let val = match string_iter.next() {
+                Some(x) => x,
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing WebcaptureCdxLine".to_string(),
+                    )
+                }
+            };
+
+            if let Some(key) = key_result {
+                match key {
+                    "surt" => intermediate_rep
+                        .surt
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "timestamp" => intermediate_rep.timestamp.push(
+                        chrono::DateTime::<chrono::Utc>::from_str(val)
+                            .map_err(|x| format!("{}", x))?,
+                    ),
+                    "url" => intermediate_rep
+                        .url
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "mimetype" => intermediate_rep
+                        .mimetype
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "status_code" => intermediate_rep
+                        .status_code
+                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+                    "size" => intermediate_rep
+                        .size
+                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+                    "sha1" => intermediate_rep
+                        .sha1
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "sha256" => intermediate_rep
+                        .sha256
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing WebcaptureCdxLine".to_string(),
+                        )
+                    }
+                }
+            }
+
+            // Get the next key
+            key_result = string_iter.next();
+        }
+
+        // Use the intermediate representation to return the struct
+        std::result::Result::Ok(WebcaptureCdxLine {
+            surt: intermediate_rep
+                .surt
+                .into_iter()
+                .next()
+                .ok_or("surt missing in WebcaptureCdxLine".to_string())?,
+            timestamp: intermediate_rep
+                .timestamp
+                .into_iter()
+                .next()
+                .ok_or("timestamp missing in WebcaptureCdxLine".to_string())?,
+            url: intermediate_rep
+                .url
+                .into_iter()
+                .next()
+                .ok_or("url missing in WebcaptureCdxLine".to_string())?,
+            mimetype: intermediate_rep.mimetype.into_iter().next(),
+            status_code: intermediate_rep.status_code.into_iter().next(),
+            size: intermediate_rep.size.into_iter().next(),
+            sha1: intermediate_rep
+                .sha1
+                .into_iter()
+                .next()
+                .ok_or("sha1 missing in WebcaptureCdxLine".to_string())?,
+            sha256: intermediate_rep.sha256.into_iter().next(),
+        })
+    }
+}
+
+// Methods for converting between header::IntoHeaderValue<WebcaptureEntity> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureEntity>>
+    for hyper::header::HeaderValue
+{
+    type Error = String;
+
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<WebcaptureEntity>,
+    ) -> std::result::Result<Self, Self::Error> {
+        let hdr_value = hdr_value.to_string();
+        match hyper::header::HeaderValue::from_str(&hdr_value) {
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Invalid header value for WebcaptureEntity - value: {} is invalid {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+    for header::IntoHeaderValue<WebcaptureEntity>
+{
+    type Error = String;
+
+    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+        match hdr_value.to_str() {
+            std::result::Result::Ok(value) => {
+                match <WebcaptureEntity as std::str::FromStr>::from_str(value) {
+                    std::result::Result::Ok(value) => {
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
+                    }
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
+                        "Unable to convert header value '{}' into WebcaptureEntity - {}",
+                        value, err
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WebcaptureEntity {
+    // Note: inline enums are not fully supported by openapi-generator
+    #[serde(rename = "state")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub state: Option<String>,
+
+    /// base32-encoded unique identifier
+    #[serde(rename = "ident")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ident: Option<String>,
+
+    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
+    #[serde(rename = "revision")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub revision: Option<String>,
+
+    /// base32-encoded unique identifier
+    #[serde(rename = "redirect")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub redirect: Option<String>,
+
+    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
+    #[serde(rename = "extra")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
+    #[serde(rename = "edit_extra")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+    #[serde(rename = "cdx")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cdx: Option<Vec<models::WebcaptureCdxLine>>,
+
+    #[serde(rename = "archive_urls")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub archive_urls: Option<Vec<models::WebcaptureUrl>>,
+
+    /// Base URL of the primary resource this is a capture of
+    #[serde(rename = "original_url")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub original_url: Option<String>,
+
+    /// Same format as CDX line timestamp (UTC, etc). Corresponds to the overall capture timestamp. Should generally be the timestamp of capture of the primary resource URL.
+    #[serde(rename = "timestamp")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<chrono::DateTime<chrono::Utc>>,
+
+    /// Set of identifier of release entities this fileset represents a full manifestation of. Usually a single release.
+    #[serde(rename = "release_ids")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub release_ids: Option<Vec<String>>,
+
+    /// Full release entities, included in GET responses when `releases` included in `expand` parameter. Ignored if included in PUT or POST requests.
+    #[serde(rename = "releases")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub releases: Option<Vec<models::ReleaseEntity>>,
+}
+
+impl WebcaptureEntity {
+    pub fn new() -> WebcaptureEntity {
+        WebcaptureEntity {
+            state: None,
+            ident: None,
+            revision: None,
+            redirect: None,
+            extra: None,
+            edit_extra: None,
+            cdx: None,
+            archive_urls: None,
+            original_url: None,
+            timestamp: None,
+            release_ids: None,
+            releases: None,
+        }
+    }
+}
+
+/// Converts the WebcaptureEntity value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WebcaptureEntity {
+    fn to_string(&self) -> String {
+        let mut params: Vec<String> = vec![];
+
+        if let Some(ref state) = self.state {
+            params.push("state".to_string());
+            params.push(state.to_string());
+        }
+
+        if let Some(ref ident) = self.ident {
+            params.push("ident".to_string());
+            params.push(ident.to_string());
+        }
+
+        if let Some(ref revision) = self.revision {
+            params.push("revision".to_string());
+            params.push(revision.to_string());
+        }
+
+        if let Some(ref redirect) = self.redirect {
+            params.push("redirect".to_string());
+            params.push(redirect.to_string());
+        }
+
+        // Skipping extra in query parameter serialization
+        // Skipping extra in query parameter serialization
+
+        // Skipping edit_extra in query parameter serialization
+        // Skipping edit_extra in query parameter serialization
+
+        // Skipping cdx in query parameter serialization
+
+        // Skipping archive_urls in query parameter serialization
+
+        if let Some(ref original_url) = self.original_url {
+            params.push("original_url".to_string());
+            params.push(original_url.to_string());
+        }
+
+        // Skipping timestamp in query parameter serialization
+
+        if let Some(ref release_ids) = self.release_ids {
+            params.push("release_ids".to_string());
+            params.push(
+                release_ids
+                    .iter()
+                    .map(|x| x.to_string())
+                    .collect::<Vec<_>>()
+                    .join(",")
+                    .to_string(),
+            );
+        }
+
+        // Skipping releases in query parameter serialization
+
+        params.join(",").to_string()
+    }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureEntity value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WebcaptureEntity {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        #[derive(Default)]
+        // An intermediate representation of the struct to use for parsing.
+        struct IntermediateRep {
+            pub state: Vec<String>,
+            pub ident: Vec<String>,
+            pub revision: Vec<String>,
+            pub redirect: Vec<String>,
+            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+            pub cdx: Vec<Vec<models::WebcaptureCdxLine>>,
+            pub archive_urls: Vec<Vec<models::WebcaptureUrl>>,
+            pub original_url: Vec<String>,
+            pub timestamp: Vec<chrono::DateTime<chrono::Utc>>,
+            pub release_ids: Vec<Vec<String>>,
+            pub releases: Vec<Vec<models::ReleaseEntity>>,
+        }
+
+        let mut intermediate_rep = IntermediateRep::default();
+
+        // Parse into intermediate representation
+        let mut string_iter = s.split(',').into_iter();
+        let mut key_result = string_iter.next();
+
+        while key_result.is_some() {
+            let val = match string_iter.next() {
+                Some(x) => x,
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing WebcaptureEntity".to_string(),
+                    )
+                }
+            };
+
+            if let Some(key) = key_result {
+                match key {
+                    "state" => intermediate_rep
+                        .state
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "ident" => intermediate_rep
+                        .ident
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "revision" => intermediate_rep
+                        .revision
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "redirect" => intermediate_rep
+                        .redirect
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "extra" => return std::result::Result::Err(
+                        "Parsing a container in this style is not supported in WebcaptureEntity"
+                            .to_string(),
+                    ),
+                    "edit_extra" => return std::result::Result::Err(
+                        "Parsing a container in this style is not supported in WebcaptureEntity"
+                            .to_string(),
+                    ),
+                    "cdx" => return std::result::Result::Err(
+                        "Parsing a container in this style is not supported in WebcaptureEntity"
+                            .to_string(),
+                    ),
+                    "archive_urls" => return std::result::Result::Err(
+                        "Parsing a container in this style is not supported in WebcaptureEntity"
+                            .to_string(),
+                    ),
+                    "original_url" => intermediate_rep
+                        .original_url
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "timestamp" => intermediate_rep.timestamp.push(
+                        chrono::DateTime::<chrono::Utc>::from_str(val)
+                            .map_err(|x| format!("{}", x))?,
+                    ),
+                    "release_ids" => return std::result::Result::Err(
+                        "Parsing a container in this style is not supported in WebcaptureEntity"
+                            .to_string(),
+                    ),
+                    "releases" => return std::result::Result::Err(
+                        "Parsing a container in this style is not supported in WebcaptureEntity"
+                            .to_string(),
+                    ),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing WebcaptureEntity".to_string(),
+                        )
+                    }
+                }
+            }
+
+            // Get the next key
+            key_result = string_iter.next();
+        }
+
+        // Use the intermediate representation to return the struct
+        std::result::Result::Ok(WebcaptureEntity {
+            state: intermediate_rep.state.into_iter().next(),
+            ident: intermediate_rep.ident.into_iter().next(),
+            revision: intermediate_rep.revision.into_iter().next(),
+            redirect: intermediate_rep.redirect.into_iter().next(),
+            extra: intermediate_rep.extra.into_iter().next(),
+            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
+            cdx: intermediate_rep.cdx.into_iter().next(),
+            archive_urls: intermediate_rep.archive_urls.into_iter().next(),
+            original_url: intermediate_rep.original_url.into_iter().next(),
+            timestamp: intermediate_rep.timestamp.into_iter().next(),
+            release_ids: intermediate_rep.release_ids.into_iter().next(),
+            releases: intermediate_rep.releases.into_iter().next(),
+        })
+    }
+}
+
+// Methods for converting between header::IntoHeaderValue<WebcaptureUrl> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureUrl>> for hyper::header::HeaderValue {
+    type Error = String;
+
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<WebcaptureUrl>,
+    ) -> std::result::Result<Self, Self::Error> {
+        let hdr_value = hdr_value.to_string();
+        match hyper::header::HeaderValue::from_str(&hdr_value) {
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Invalid header value for WebcaptureUrl - value: {} is invalid {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WebcaptureUrl> {
+    type Error = String;
+
+    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+        match hdr_value.to_str() {
+            std::result::Result::Ok(value) => {
+                match <WebcaptureUrl as std::str::FromStr>::from_str(value) {
+                    std::result::Result::Ok(value) => {
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
+                    }
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
+                        "Unable to convert header value '{}' into WebcaptureUrl - {}",
+                        value, err
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WebcaptureUrl {
+    /// URL/URI pointing to archive of this web resource.
+    #[serde(rename = "url")]
+    pub url: String,
+
+    /// Type of archive endpoint. Usually `wayback` (WBM replay of primary resource), or `warc` (direct URL to a WARC file containing all resources of the capture). See guide for full list.
+    #[serde(rename = "rel")]
+    pub rel: String,
+}
+
+impl WebcaptureUrl {
+    pub fn new(url: String, rel: String) -> WebcaptureUrl {
+        WebcaptureUrl { url: url, rel: rel }
+    }
+}
+
+/// Converts the WebcaptureUrl value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WebcaptureUrl {
+    fn to_string(&self) -> String {
+        let mut params: Vec<String> = vec![];
+
+        params.push("url".to_string());
+        params.push(self.url.to_string());
+
+        params.push("rel".to_string());
+        params.push(self.rel.to_string());
+
+        params.join(",").to_string()
+    }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureUrl value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WebcaptureUrl {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        #[derive(Default)]
+        // An intermediate representation of the struct to use for parsing.
+        struct IntermediateRep {
+            pub url: Vec<String>,
+            pub rel: Vec<String>,
+        }
+
+        let mut intermediate_rep = IntermediateRep::default();
+
+        // Parse into intermediate representation
+        let mut string_iter = s.split(',').into_iter();
+        let mut key_result = string_iter.next();
+
+        while key_result.is_some() {
+            let val = match string_iter.next() {
+                Some(x) => x,
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing WebcaptureUrl".to_string(),
+                    )
+                }
+            };
+
+            if let Some(key) = key_result {
+                match key {
+                    "url" => intermediate_rep
+                        .url
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "rel" => intermediate_rep
+                        .rel
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing WebcaptureUrl".to_string(),
+                        )
+                    }
+                }
+            }
+
+            // Get the next key
+            key_result = string_iter.next();
+        }
+
+        // Use the intermediate representation to return the struct
+        std::result::Result::Ok(WebcaptureUrl {
+            url: intermediate_rep
+                .url
+                .into_iter()
+                .next()
+                .ok_or("url missing in WebcaptureUrl".to_string())?,
+            rel: intermediate_rep
+                .rel
+                .into_iter()
+                .next()
+                .ok_or("rel missing in WebcaptureUrl".to_string())?,
+        })
+    }
+}
+
+// Methods for converting between header::IntoHeaderValue<WorkAutoBatch> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WorkAutoBatch>> for hyper::header::HeaderValue {
+    type Error = String;
+
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<WorkAutoBatch>,
+    ) -> std::result::Result<Self, Self::Error> {
+        let hdr_value = hdr_value.to_string();
+        match hyper::header::HeaderValue::from_str(&hdr_value) {
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Invalid header value for WorkAutoBatch - value: {} is invalid {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WorkAutoBatch> {
+    type Error = String;
+
+    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+        match hdr_value.to_str() {
+            std::result::Result::Ok(value) => {
+                match <WorkAutoBatch as std::str::FromStr>::from_str(value) {
+                    std::result::Result::Ok(value) => {
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
+                    }
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
+                        "Unable to convert header value '{}' into WorkAutoBatch - {}",
+                        value, err
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WorkAutoBatch {
+    #[serde(rename = "editgroup")]
+    pub editgroup: models::Editgroup,
+
+    #[serde(rename = "entity_list")]
+    pub entity_list: Vec<models::WorkEntity>,
+}
+
+impl WorkAutoBatch {
+    pub fn new(
+        editgroup: models::Editgroup,
+        entity_list: Vec<models::WorkEntity>,
+    ) -> WorkAutoBatch {
+        WorkAutoBatch {
+            editgroup: editgroup,
+            entity_list: entity_list,
+        }
+    }
+}
+
+/// Converts the WorkAutoBatch value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WorkAutoBatch {
+    fn to_string(&self) -> String {
+        let mut params: Vec<String> = vec![];
+        // Skipping editgroup in query parameter serialization
+
+        // Skipping entity_list in query parameter serialization
+
+        params.join(",").to_string()
+    }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WorkAutoBatch value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WorkAutoBatch {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        #[derive(Default)]
+        // An intermediate representation of the struct to use for parsing.
+        struct IntermediateRep {
+            pub editgroup: Vec<models::Editgroup>,
+            pub entity_list: Vec<Vec<models::WorkEntity>>,
+        }
+
+        let mut intermediate_rep = IntermediateRep::default();
+
+        // Parse into intermediate representation
+        let mut string_iter = s.split(',').into_iter();
+        let mut key_result = string_iter.next();
+
+        while key_result.is_some() {
+            let val = match string_iter.next() {
+                Some(x) => x,
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing WorkAutoBatch".to_string(),
+                    )
+                }
+            };
+
+            if let Some(key) = key_result {
+                match key {
+                    "editgroup" => intermediate_rep
+                        .editgroup
+                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
+                    "entity_list" => {
+                        return std::result::Result::Err(
+                            "Parsing a container in this style is not supported in WorkAutoBatch"
+                                .to_string(),
+                        )
+                    }
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing WorkAutoBatch".to_string(),
+                        )
+                    }
+                }
+            }
+
+            // Get the next key
+            key_result = string_iter.next();
+        }
+
+        // Use the intermediate representation to return the struct
+        std::result::Result::Ok(WorkAutoBatch {
+            editgroup: intermediate_rep
+                .editgroup
+                .into_iter()
+                .next()
+                .ok_or("editgroup missing in WorkAutoBatch".to_string())?,
+            entity_list: intermediate_rep
+                .entity_list
+                .into_iter()
+                .next()
+                .ok_or("entity_list missing in WorkAutoBatch".to_string())?,
+        })
+    }
+}
+
+// Methods for converting between header::IntoHeaderValue<WorkEntity> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WorkEntity>> for hyper::header::HeaderValue {
+    type Error = String;
+
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<WorkEntity>,
+    ) -> std::result::Result<Self, Self::Error> {
+        let hdr_value = hdr_value.to_string();
+        match hyper::header::HeaderValue::from_str(&hdr_value) {
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Invalid header value for WorkEntity - value: {} is invalid {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WorkEntity> {
+    type Error = String;
+
+    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+        match hdr_value.to_str() {
+            std::result::Result::Ok(value) => {
+                match <WorkEntity as std::str::FromStr>::from_str(value) {
+                    std::result::Result::Ok(value) => {
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
+                    }
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
+                        "Unable to convert header value '{}' into WorkEntity - {}",
+                        value, err
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WorkEntity {
+    // Note: inline enums are not fully supported by openapi-generator
+    #[serde(rename = "state")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub state: Option<String>,
+
+    /// base32-encoded unique identifier
+    #[serde(rename = "ident")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ident: Option<String>,
+
+    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
+    #[serde(rename = "revision")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub revision: Option<String>,
+
+    /// base32-encoded unique identifier
+    #[serde(rename = "redirect")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub redirect: Option<String>,
+
+    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
+    #[serde(rename = "extra")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
+    #[serde(rename = "edit_extra")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+}
+
+impl WorkEntity {
+    pub fn new() -> WorkEntity {
+        WorkEntity {
+            state: None,
+            ident: None,
+            revision: None,
+            redirect: None,
+            extra: None,
+            edit_extra: None,
+        }
+    }
+}
+
+/// Converts the WorkEntity value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WorkEntity {
+    fn to_string(&self) -> String {
+        let mut params: Vec<String> = vec![];
+
+        if let Some(ref state) = self.state {
+            params.push("state".to_string());
+            params.push(state.to_string());
+        }
+
+        if let Some(ref ident) = self.ident {
+            params.push("ident".to_string());
+            params.push(ident.to_string());
+        }
+
+        if let Some(ref revision) = self.revision {
+            params.push("revision".to_string());
+            params.push(revision.to_string());
+        }
+
+        if let Some(ref redirect) = self.redirect {
+            params.push("redirect".to_string());
+            params.push(redirect.to_string());
+        }
+
+        // Skipping extra in query parameter serialization
+        // Skipping extra in query parameter serialization
+
+        // Skipping edit_extra in query parameter serialization
+        // Skipping edit_extra in query parameter serialization
+
+        params.join(",").to_string()
+    }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WorkEntity value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WorkEntity {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        #[derive(Default)]
+        // An intermediate representation of the struct to use for parsing.
+        struct IntermediateRep {
+            pub state: Vec<String>,
+            pub ident: Vec<String>,
+            pub revision: Vec<String>,
+            pub redirect: Vec<String>,
+            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+        }
+
+        let mut intermediate_rep = IntermediateRep::default();
+
+        // Parse into intermediate representation
+        let mut string_iter = s.split(',').into_iter();
+        let mut key_result = string_iter.next();
+
+        while key_result.is_some() {
+            let val = match string_iter.next() {
+                Some(x) => x,
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing WorkEntity".to_string(),
+                    )
+                }
+            };
+
+            if let Some(key) = key_result {
+                match key {
+                    "state" => intermediate_rep
+                        .state
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "ident" => intermediate_rep
+                        .ident
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "revision" => intermediate_rep
+                        .revision
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "redirect" => intermediate_rep
+                        .redirect
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "extra" => {
+                        return std::result::Result::Err(
+                            "Parsing a container in this style is not supported in WorkEntity"
+                                .to_string(),
+                        )
+                    }
+                    "edit_extra" => {
+                        return std::result::Result::Err(
+                            "Parsing a container in this style is not supported in WorkEntity"
+                                .to_string(),
+                        )
+                    }
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing WorkEntity".to_string(),
+                        )
+                    }
+                }
+            }
+
+            // Get the next key
+            key_result = string_iter.next();
+        }
+
+        // Use the intermediate representation to return the struct
+        std::result::Result::Ok(WorkEntity {
+            state: intermediate_rep.state.into_iter().next(),
+            ident: intermediate_rep.ident.into_iter().next(),
+            revision: intermediate_rep.revision.into_iter().next(),
+            redirect: intermediate_rep.redirect.into_iter().next(),
+            extra: intermediate_rep.extra.into_iter().next(),
+            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
+        })
+    }
+}
diff --git a/rust/fatcat-openapi/src/server/mod.rs b/rust/fatcat-openapi/src/server/mod.rs
new file mode 100644
index 0000000..96ed29a
--- /dev/null
+++ b/rust/fatcat-openapi/src/server/mod.rs
@@ -0,0 +1,15022 @@
+use futures::{future, stream, Future, Stream};
+use hyper;
+use hyper::header::{HeaderName, HeaderValue, CONTENT_TYPE};
+use hyper::{Body, Error, HeaderMap, Request, Response, StatusCode};
+use log::warn;
+use serde_json;
+#[allow(unused_imports)]
+use std::convert::{TryFrom, TryInto};
+use std::io;
+use std::marker::PhantomData;
+#[allow(unused_imports)]
+use swagger;
+pub use swagger::auth::Authorization;
+use swagger::auth::Scopes;
+use swagger::context::ContextualPayload;
+use swagger::{ApiError, Has, RequestParser, XSpanIdString};
+use url::form_urlencoded;
+
+use crate::header;
+#[allow(unused_imports)]
+use crate::models;
+
+pub use crate::context;
+
+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, RC> {
+    api_impl: T,
+    marker: PhantomData<RC>,
+}
+
+impl<T, RC> MakeService<T, RC>
+where
+    T: Api<RC> + Clone + Send + 'static,
+    RC: Has<XSpanIdString> + Has<Option<Authorization>> + 'static,
+{
+    pub fn new(api_impl: T) -> Self {
+        MakeService {
+            api_impl,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<'a, T, SC, RC> hyper::service::MakeService<&'a SC> for MakeService<T, RC>
+where
+    T: Api<RC> + Clone + Send + 'static,
+    RC: Has<XSpanIdString> + Has<Option<Authorization>> + 'static + Send,
+{
+    type ReqBody = ContextualPayload<Body, RC>;
+    type ResBody = Body;
+    type Error = Error;
+    type Service = Service<T, RC>;
+    type Future = future::FutureResult<Self::Service, Self::MakeError>;
+    type MakeError = Error;
+
+    fn make_service(&mut self, _ctx: &'a SC) -> Self::Future {
+        future::FutureResult::from(Ok(Service::new(self.api_impl.clone())))
+    }
+}
+
+type ServiceFuture = Box<dyn Future<Item = Response<Body>, Error = Error> + Send>;
+
+fn method_not_allowed() -> ServiceFuture {
+    Box::new(future::ok(
+        Response::builder()
+            .status(StatusCode::METHOD_NOT_ALLOWED)
+            .body(Body::empty())
+            .expect("Unable to create Method Not Allowed response"),
+    ))
+}
+
+pub struct Service<T, RC> {
+    api_impl: T,
+    marker: PhantomData<RC>,
+}
+
+impl<T, RC> Service<T, RC>
+where
+    T: Api<RC> + Clone + Send + 'static,
+    RC: Has<XSpanIdString> + Has<Option<Authorization>> + 'static,
+{
+    pub fn new(api_impl: T) -> Self {
+        Service {
+            api_impl: api_impl,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<T, C> hyper::service::Service for Service<T, C>
+where
+    T: Api<C> + Clone + Send + 'static,
+    C: Has<XSpanIdString> + Has<Option<Authorization>> + 'static + Send,
+{
+    type ReqBody = ContextualPayload<Body, C>;
+    type ResBody = Body;
+    type Error = Error;
+    type Future = ServiceFuture;
+
+    fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future {
+        let api_impl = self.api_impl.clone();
+        let (parts, body) = req.into_parts();
+        let (method, uri, headers) = (parts.method, parts.uri, parts.headers);
+        let path = paths::GLOBAL_REGEX_SET.matches(uri.path());
+        let mut context = body.context;
+        let body = body.inner;
+
+        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 Box::new(future::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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.accept_editgroup(
+                                            param_editgroup_id,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 = param_role.and_then(|param_role| param_role.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.auth_check(
+                                            param_role,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.auth_oidc(
+                                            param_auth_oidc,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 = param_duration_seconds
+                    .and_then(|param_duration_seconds| param_duration_seconds.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.create_auth_token(
+                                            param_editor_id,
+                                            param_duration_seconds,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.create_container(
+                                            param_editgroup_id,
+                                            param_container_entity,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.create_container_auto_batch(
+                                            param_container_auto_batch,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.create_creator(
+                                            param_editgroup_id,
+                                            param_creator_entity,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.create_creator_auto_batch(
+                                            param_creator_auto_batch,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.create_editgroup(
+                                            param_editgroup,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.create_editgroup_annotation(
+                                            param_editgroup_id,
+                                            param_editgroup_annotation,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.create_file(
+                                            param_editgroup_id,
+                                            param_file_entity,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.create_file_auto_batch(
+                                            param_file_auto_batch,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.create_fileset(
+                                            param_editgroup_id,
+                                            param_fileset_entity,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.create_fileset_auto_batch(
+                                            param_fileset_auto_batch,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.create_release(
+                                            param_editgroup_id,
+                                            param_release_entity,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.create_release_auto_batch(
+                                            param_release_auto_batch,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.create_webcapture(
+                                            param_editgroup_id,
+                                            param_webcapture_entity,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.create_webcapture_auto_batch(
+                                            param_webcapture_auto_batch,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.create_work(
+                                            param_editgroup_id,
+                                            param_work_entity,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.create_work_auto_batch(
+                                            param_work_auto_batch,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.delete_container(
+                                            param_editgroup_id,
+                                            param_ident,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.delete_container_edit(
+                                            param_editgroup_id,
+                                            param_edit_id,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.delete_creator(
+                                            param_editgroup_id,
+                                            param_ident,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.delete_creator_edit(
+                                            param_editgroup_id,
+                                            param_edit_id,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.delete_file(
+                                            param_editgroup_id,
+                                            param_ident,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.delete_file_edit(
+                                            param_editgroup_id,
+                                            param_edit_id,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.delete_fileset(
+                                            param_editgroup_id,
+                                            param_ident,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.delete_fileset_edit(
+                                            param_editgroup_id,
+                                            param_edit_id,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.delete_release(
+                                            param_editgroup_id,
+                                            param_ident,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.delete_release_edit(
+                                            param_editgroup_id,
+                                            param_edit_id,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.delete_webcapture(
+                                            param_editgroup_id,
+                                            param_ident,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.delete_webcapture_edit(
+                                            param_editgroup_id,
+                                            param_edit_id,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.delete_work(
+                                            param_editgroup_id,
+                                            param_ident,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.delete_work_edit(
+                                            param_editgroup_id,
+                                            param_edit_id,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 = param_limit.and_then(|param_limit| param_limit.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_changelog(
+                                            param_limit,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_changelog_entry(
+                                            param_index,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_container(
+                                            param_ident,
+                                            param_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_container_edit(
+                                            param_edit_id,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_limit.and_then(|param_limit| param_limit.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_container_history(
+                                            param_ident,
+                                            param_limit,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_container_redirects(
+                                            param_ident,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_container_revision(
+                                            param_rev_id,
+                                            param_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_creator(
+                                            param_ident,
+                                            param_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_creator_edit(
+                                            param_edit_id,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_limit.and_then(|param_limit| param_limit.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_creator_history(
+                                            param_ident,
+                                            param_limit,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_creator_redirects(
+                                            param_ident,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_creator_releases(
+                                            param_ident,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_creator_revision(
+                                            param_rev_id,
+                                            param_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_editgroup(
+                                            param_editgroup_id,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_expand.and_then(|param_expand| param_expand.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_editgroup_annotations(
+                                            param_editgroup_id,
+                                            param_expand,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_limit = query_params
+                    .iter()
+                    .filter(|e| e.0 == "limit")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_limit = param_limit.and_then(|param_limit| param_limit.parse().ok());
+                let param_before = query_params
+                    .iter()
+                    .filter(|e| e.0 == "before")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_before = param_before.and_then(|param_before| param_before.parse().ok());
+                let param_since = query_params
+                    .iter()
+                    .filter(|e| e.0 == "since")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_since = param_since.and_then(|param_since| param_since.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_editgroups_reviewable(
+                                            param_expand,
+                                            param_limit,
+                                            param_before,
+                                            param_since,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_editor(
+                                            param_editor_id,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_limit.and_then(|param_limit| param_limit.parse().ok());
+                let param_before = query_params
+                    .iter()
+                    .filter(|e| e.0 == "before")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_before = param_before.and_then(|param_before| param_before.parse().ok());
+                let param_since = query_params
+                    .iter()
+                    .filter(|e| e.0 == "since")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_since = param_since.and_then(|param_since| param_since.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_editor_annotations(
+                                            param_editor_id,
+                                            param_limit,
+                                            param_before,
+                                            param_since,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_limit.and_then(|param_limit| param_limit.parse().ok());
+                let param_before = query_params
+                    .iter()
+                    .filter(|e| e.0 == "before")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_before = param_before.and_then(|param_before| param_before.parse().ok());
+                let param_since = query_params
+                    .iter()
+                    .filter(|e| e.0 == "since")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_since = param_since.and_then(|param_since| param_since.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_editor_editgroups(
+                                            param_editor_id,
+                                            param_limit,
+                                            param_before,
+                                            param_since,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_file(
+                                            param_ident,
+                                            param_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_file_edit(
+                                            param_edit_id,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_limit.and_then(|param_limit| param_limit.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_file_history(
+                                            param_ident,
+                                            param_limit,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_file_redirects(
+                                            param_ident,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_file_revision(
+                                            param_rev_id,
+                                            param_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_fileset(
+                                            param_ident,
+                                            param_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_fileset_edit(
+                                            param_edit_id,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_limit.and_then(|param_limit| param_limit.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_fileset_history(
+                                            param_ident,
+                                            param_limit,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_fileset_redirects(
+                                            param_ident,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_fileset_revision(
+                                            param_rev_id,
+                                            param_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_release(
+                                            param_ident,
+                                            param_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_release_edit(
+                                            param_edit_id,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_release_files(
+                                            param_ident,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_release_filesets(
+                                            param_ident,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_limit.and_then(|param_limit| param_limit.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_release_history(
+                                            param_ident,
+                                            param_limit,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_release_redirects(
+                                            param_ident,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_release_revision(
+                                            param_rev_id,
+                                            param_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_release_webcaptures(
+                                            param_ident,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_webcapture(
+                                            param_ident,
+                                            param_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_webcapture_edit(
+                                            param_edit_id,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_limit.and_then(|param_limit| param_limit.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_webcapture_history(
+                                            param_ident,
+                                            param_limit,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_webcapture_redirects(
+                                            param_ident,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_webcapture_revision(
+                                            param_rev_id,
+                                            param_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_work(
+                                            param_ident,
+                                            param_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_work_edit(
+                                            param_edit_id,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_limit.and_then(|param_limit| param_limit.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_work_history(
+                                            param_ident,
+                                            param_limit,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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")))
+                };
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_work_redirects(
+                                            param_ident,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_work_releases(
+                                            param_ident,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.get_work_revision(
+                                            param_rev_id,
+                                            param_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 = param_issnl.and_then(|param_issnl| param_issnl.parse().ok());
+                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 = param_wikidata_qid
+                    .and_then(|param_wikidata_qid| param_wikidata_qid.parse().ok());
+                let param_expand = query_params
+                    .iter()
+                    .filter(|e| e.0 == "expand")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_expand = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.lookup_container(
+                                            param_issnl,
+                                            param_wikidata_qid,
+                                            param_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 = param_orcid.and_then(|param_orcid| param_orcid.parse().ok());
+                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 = param_wikidata_qid
+                    .and_then(|param_wikidata_qid| param_wikidata_qid.parse().ok());
+                let param_expand = query_params
+                    .iter()
+                    .filter(|e| e.0 == "expand")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_expand = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.lookup_creator(
+                                            param_orcid,
+                                            param_wikidata_qid,
+                                            param_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 = param_md5.and_then(|param_md5| param_md5.parse().ok());
+                let param_sha1 = query_params
+                    .iter()
+                    .filter(|e| e.0 == "sha1")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_sha1 = param_sha1.and_then(|param_sha1| param_sha1.parse().ok());
+                let param_sha256 = query_params
+                    .iter()
+                    .filter(|e| e.0 == "sha256")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_sha256 = param_sha256.and_then(|param_sha256| param_sha256.parse().ok());
+                let param_expand = query_params
+                    .iter()
+                    .filter(|e| e.0 == "expand")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_expand = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    api_impl.lookup_file(
+                                            param_md5,
+                                            param_sha1,
+                                            param_sha256,
+                                            param_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 = param_doi.and_then(|param_doi| param_doi.parse().ok());
+                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 = param_wikidata_qid
+                    .and_then(|param_wikidata_qid| param_wikidata_qid.parse().ok());
+                let param_isbn13 = query_params
+                    .iter()
+                    .filter(|e| e.0 == "isbn13")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_isbn13 = param_isbn13.and_then(|param_isbn13| param_isbn13.parse().ok());
+                let param_pmid = query_params
+                    .iter()
+                    .filter(|e| e.0 == "pmid")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_pmid = param_pmid.and_then(|param_pmid| param_pmid.parse().ok());
+                let param_pmcid = query_params
+                    .iter()
+                    .filter(|e| e.0 == "pmcid")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_pmcid = param_pmcid.and_then(|param_pmcid| param_pmcid.parse().ok());
+                let param_core = query_params
+                    .iter()
+                    .filter(|e| e.0 == "core")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_core = param_core.and_then(|param_core| param_core.parse().ok());
+                let param_arxiv = query_params
+                    .iter()
+                    .filter(|e| e.0 == "arxiv")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_arxiv = param_arxiv.and_then(|param_arxiv| param_arxiv.parse().ok());
+                let param_jstor = query_params
+                    .iter()
+                    .filter(|e| e.0 == "jstor")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_jstor = param_jstor.and_then(|param_jstor| param_jstor.parse().ok());
+                let param_ark = query_params
+                    .iter()
+                    .filter(|e| e.0 == "ark")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_ark = param_ark.and_then(|param_ark| param_ark.parse().ok());
+                let param_mag = query_params
+                    .iter()
+                    .filter(|e| e.0 == "mag")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_mag = param_mag.and_then(|param_mag| param_mag.parse().ok());
+                let param_expand = query_params
+                    .iter()
+                    .filter(|e| e.0 == "expand")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_expand = param_expand.and_then(|param_expand| param_expand.parse().ok());
+                let param_hide = query_params
+                    .iter()
+                    .filter(|e| e.0 == "hide")
+                    .map(|e| e.1.to_owned())
+                    .nth(0);
+                let param_hide = param_hide.and_then(|param_hide| param_hide.parse().ok());
+
+                Box::new({
+                    {
+                        {
+                            Box::new(
+                                    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_expand,
+                                            param_hide,
+                                        &context
+                                    ).then(move |result| {
+                                        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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }
+                    }
+                }) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.update_container(
+                                            param_editgroup_id,
+                                            param_ident,
+                                            param_container_entity,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.update_creator(
+                                            param_editgroup_id,
+                                            param_ident,
+                                            param_creator_entity,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 = param_submit.and_then(|param_submit| param_submit.parse().ok());
+
+                // 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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.update_editgroup(
+                                            param_editgroup_id,
+                                            param_editgroup,
+                                            param_submit,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.update_editor(
+                                            param_editor_id,
+                                            param_editor,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.update_file(
+                                            param_editgroup_id,
+                                            param_ident,
+                                            param_file_entity,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.update_fileset(
+                                            param_editgroup_id,
+                                            param_ident,
+                                            param_fileset_entity,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.update_release(
+                                            param_editgroup_id,
+                                            param_ident,
+                                            param_release_entity,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.update_webcapture(
+                                            param_editgroup_id,
+                                            param_ident,
+                                            param_webcapture_entity,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            // 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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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 Box::new(future::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.
+                Box::new(body.concat2()
+                    .then(move |result| -> Self::Future {
+                        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 Box::new(future::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 Box::new(future::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"))),
+                                };
+
+                                Box::new(
+                                    api_impl.update_work(
+                                            param_editgroup_id,
+                                            param_ident,
+                                            param_work_entity,
+                                        &context
+                                    ).then(move |result| {
+                                        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
+                                                    }
+                                                => {
+                                                    let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+                                                        Ok(val) => val,
+                                                        Err(e) => {
+                                                            return future::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.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("www_authenticate"),
+                                                        www_authenticate
+                                                    );
+                                                    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");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                            },
+                            Err(e) => Box::new(future::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"))),
+                        }
+                    })
+                ) as Self::Future
+            }
+
+            _ 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(),
+            _ => Box::new(future::ok(
+                Response::builder()
+                    .status(StatusCode::NOT_FOUND)
+                    .body(Body::empty())
+                    .expect("Unable to create Not Found response"),
+            )) as Self::Future,
+        }
+    }
+}
+
+impl<T, C> Clone for Service<T, C>
+where
+    T: Clone,
+{
+    fn clone(&self) -> Self {
+        Service {
+            api_impl: self.api_impl.clone(),
+            marker: self.marker.clone(),
+        }
+    }
+}
+
+/// 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(()),
+        }
+    }
+}