revert to v2.3.1 codegen

This reverts back to something compatible with Iron and simple
(blocking) parallelism, instead of the new async hyper 0.11 stuff.

1 files changed, 0 insertions, 2573 deletions

diff --git a/rust/fatcat-api/src/client/mod.rs b/rust/fatcat-api/src/client/mod.rs
deleted file mode 100644
index 361fd390..00000000
--- a/rust/fatcat-api/src/client/mod.rs
+++ /dev/null
@@ -1,2573 +0,0 @@
-#![allow(unused_extern_crates)]
-extern crate chrono;
-extern crate hyper_tls;
-extern crate mime;
-extern crate native_tls;
-extern crate openssl;
-extern crate tokio_core;
-extern crate url;
-
-use self::tokio_core::reactor::Handle;
-use self::url::percent_encoding::{utf8_percent_encode, PATH_SEGMENT_ENCODE_SET, QUERY_ENCODE_SET};
-use futures;
-use futures::{Future, Stream};
-use futures::{future, stream};
-use hyper;
-use hyper::Uri;
-use hyper::header::{ContentType, Headers};
-use std::borrow::Cow;
-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::sync::Arc;
-
-use mimetypes;
-
-use serde_json;
-
-#[allow(unused_imports)]
-use std::collections::{BTreeMap, HashMap};
-#[allow(unused_imports)]
-use swagger;
-
-use swagger::{ApiError, Context, XSpanId};
-
-use models;
-use {Api, ContainerIdGetResponse, ContainerLookupGetResponse, ContainerPostResponse,
-     CreatorIdGetResponse, CreatorLookupGetResponse, CreatorPostResponse,
-     EditgroupIdAcceptPostResponse, EditgroupIdGetResponse, EditgroupPostResponse,
-     EditorUsernameChangelogGetResponse, EditorUsernameGetResponse, FileIdGetResponse,
-     FileLookupGetResponse, FilePostResponse, ReleaseIdGetResponse, ReleaseLookupGetResponse,
-     ReleasePostResponse, WorkIdGetResponse, WorkPostResponse};
-
-/// 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().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().map(|x| format!(":{}", x)).unwrap_or_default();
-    Ok(format!("{}://{}{}", scheme, host, port))
-}
-
-/// A client that implements the API by making HTTP calls out to a server.
-#[derive(Clone)]
-pub struct Client {
-    hyper_client: Arc<
-        Fn(
-                &Handle
-            ) -> Box<
-                hyper::client::Service<
-                    Request = hyper::Request<hyper::Body>,
-                    Response = hyper::Response,
-                    Error = hyper::Error,
-                    Future = hyper::client::FutureResponse,
-                >,
-            >
-            + Sync
-            + Send,
-    >,
-    handle: Arc<Handle>,
-    base_path: String,
-}
-
-impl fmt::Debug for Client {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Client {{ base_path: {} }}", self.base_path)
-    }
-}
-
-impl Client {
-    /// Create an HTTP client.
-    ///
-    /// # Arguments
-    /// * `handle` - tokio reactor handle to use for execution
-    /// * `base_path` - base path of the client API, i.e. "www.my-api-implementation.com"
-    pub fn try_new_http(handle: Handle, base_path: &str) -> Result<Client, ClientInitError> {
-        let http_connector = swagger::http_connector();
-        Self::try_new_with_connector::<hyper::client::HttpConnector>(
-            handle,
-            base_path,
-            Some("http"),
-            http_connector,
-        )
-    }
-
-    /// Create a client with a TLS connection to the server.
-    ///
-    /// # Arguments
-    /// * `handle` - tokio reactor handle to use for execution
-    /// * `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
-    pub fn try_new_https<CA>(
-        handle: Handle,
-        base_path: &str,
-        ca_certificate: CA,
-    ) -> Result<Client, ClientInitError>
-    where
-        CA: AsRef<Path>,
-    {
-        let https_connector = swagger::https_connector(ca_certificate);
-        Self::try_new_with_connector::<hyper_tls::HttpsConnector<hyper::client::HttpConnector>>(
-            handle,
-            base_path,
-            Some("https"),
-            https_connector,
-        )
-    }
-
-    /// Create a client with a mutually authenticated TLS connection to the server.
-    ///
-    /// # Arguments
-    /// * `handle` - tokio reactor handle to use for execution
-    /// * `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
-    pub fn try_new_https_mutual<CA, K, C, T>(
-        handle: Handle,
-        base_path: &str,
-        ca_certificate: CA,
-        client_key: K,
-        client_certificate: C,
-    ) -> Result<Client, ClientInitError>
-    where
-        CA: AsRef<Path>,
-        K: AsRef<Path>,
-        C: AsRef<Path>,
-    {
-        let https_connector =
-            swagger::https_mutual_connector(ca_certificate, client_key, client_certificate);
-        Self::try_new_with_connector::<hyper_tls::HttpsConnector<hyper::client::HttpConnector>>(
-            handle,
-            base_path,
-            Some("https"),
-            https_connector,
-        )
-    }
-
-    /// 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::{http_connector, https_connector, https_mutual_connector}`.
-    ///
-    /// 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
-    ///
-    /// * `handle` - tokio reactor handle to use for execution
-    /// * `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_fn` - Function which returns an implementation of `hyper::client::Connect`
-    pub fn try_new_with_connector<C>(
-        handle: Handle,
-        base_path: &str,
-        protocol: Option<&'static str>,
-        connector_fn: Box<Fn(&Handle) -> C + Send + Sync>,
-    ) -> Result<Client, ClientInitError>
-    where
-        C: hyper::client::Connect + hyper::client::Service,
-    {
-        let hyper_client = {
-            move |handle: &Handle| -> Box<
-                hyper::client::Service<
-                    Request = hyper::Request<hyper::Body>,
-                    Response = hyper::Response,
-                    Error = hyper::Error,
-                    Future = hyper::client::FutureResponse,
-                >,
-            > {
-                let connector = connector_fn(handle);
-                Box::new(
-                    hyper::Client::configure()
-                        .connector(connector)
-                        .build(handle),
-                )
-            }
-        };
-
-        Ok(Client {
-            hyper_client: Arc::new(hyper_client),
-            handle: Arc::new(handle),
-            base_path: into_base_path(base_path, protocol)?,
-        })
-    }
-
-    /// Constructor for creating a `Client` by passing in a pre-made `hyper` client.
-    ///
-    /// One should avoid relying on this function if possible, since it adds a dependency on the underlying transport
-    /// implementation, which it would be better to abstract away. Therefore, using this function may lead to a loss of
-    /// code generality, which may make it harder to move the application to a serverless environment, for example.
-    ///
-    /// The reason for this function's existence is to support legacy test code, which did mocking at the hyper layer.
-    /// This is not a recommended way to write new tests. If other reasons are found for using this function, they
-    /// should be mentioned here.
-    pub fn try_new_with_hyper_client(
-        hyper_client: Arc<
-            Fn(
-                    &Handle
-                ) -> Box<
-                    hyper::client::Service<
-                        Request = hyper::Request<hyper::Body>,
-                        Response = hyper::Response,
-                        Error = hyper::Error,
-                        Future = hyper::client::FutureResponse,
-                    >,
-                >
-                + Sync
-                + Send,
-        >,
-        handle: Handle,
-        base_path: &str,
-    ) -> Result<Client, ClientInitError> {
-        Ok(Client {
-            hyper_client: hyper_client,
-            handle: Arc::new(handle),
-            base_path: into_base_path(base_path, None)?,
-        })
-    }
-}
-
-impl Api for Client {
-    fn container_id_get(
-        &self,
-        param_id: String,
-        context: &Context,
-    ) -> Box<Future<Item = ContainerIdGetResponse, Error = ApiError>> {
-        let uri = format!(
-            "{}/v0/container/{id}",
-            self.base_path,
-            id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
-        );
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    200 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| {
-                                    ContainerIdGetResponse::FetchASingleContainerById(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    400 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| ContainerIdGetResponse::BadRequest(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| {
-                                    ContainerIdGetResponse::GenericErrorResponse(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn container_lookup_get(
-        &self,
-        param_issn: String,
-        context: &Context,
-    ) -> Box<Future<Item = ContainerLookupGetResponse, Error = ApiError>> {
-        // Query parameters
-        let query_issn = format!("issn={issn}&", issn = param_issn.to_string());
-
-        let uri = format!(
-            "{}/v0/container/lookup?{issn}",
-            self.base_path,
-            issn = utf8_percent_encode(&query_issn, QUERY_ENCODE_SET)
-        );
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    200 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| {
-                                    ContainerLookupGetResponse::FindASingleContainerByExternalIdentifer(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    400 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| ContainerLookupGetResponse::BadRequest(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    404 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| ContainerLookupGetResponse::NoSuchContainer(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| {
-                                    ContainerLookupGetResponse::GenericErrorResponse(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn container_post(
-        &self,
-        param_body: Option<models::ContainerEntity>,
-        context: &Context,
-    ) -> Box<Future<Item = ContainerPostResponse, Error = ApiError>> {
-        let uri = format!("{}/v0/container", self.base_path);
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Post, uri);
-
-        let body = param_body
-            .map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
-
-        if let Some(body) = body {
-            request.set_body(body.into_bytes());
-        }
-
-        request
-            .headers_mut()
-            .set(ContentType(mimetypes::requests::CONTAINER_POST.clone()));
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    201 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| ContainerPostResponse::Created(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    400 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| ContainerPostResponse::BadRequest(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| ContainerPostResponse::GenericErrorResponse(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn creator_id_get(
-        &self,
-        param_id: String,
-        context: &Context,
-    ) -> Box<Future<Item = CreatorIdGetResponse, Error = ApiError>> {
-        let uri = format!(
-            "{}/v0/creator/{id}",
-            self.base_path,
-            id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
-        );
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    200 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| {
-                                    CreatorIdGetResponse::FetchASingleCreatorById(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    400 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| CreatorIdGetResponse::BadRequest(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| CreatorIdGetResponse::GenericErrorResponse(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn creator_lookup_get(
-        &self,
-        param_orcid: String,
-        context: &Context,
-    ) -> Box<Future<Item = CreatorLookupGetResponse, Error = ApiError>> {
-        // Query parameters
-        let query_orcid = format!("orcid={orcid}&", orcid = param_orcid.to_string());
-
-        let uri = format!(
-            "{}/v0/creator/lookup?{orcid}",
-            self.base_path,
-            orcid = utf8_percent_encode(&query_orcid, QUERY_ENCODE_SET)
-        );
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    200 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| {
-                                    CreatorLookupGetResponse::FindASingleCreatorByExternalIdentifer(
-                                        body,
-                                    )
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    400 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| CreatorLookupGetResponse::BadRequest(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    404 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| CreatorLookupGetResponse::NoSuchCreator(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| {
-                                    CreatorLookupGetResponse::GenericErrorResponse(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn creator_post(
-        &self,
-        param_body: Option<models::CreatorEntity>,
-        context: &Context,
-    ) -> Box<Future<Item = CreatorPostResponse, Error = ApiError>> {
-        let uri = format!("{}/v0/creator", self.base_path);
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Post, uri);
-
-        let body = param_body
-            .map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
-
-        if let Some(body) = body {
-            request.set_body(body.into_bytes());
-        }
-
-        request
-            .headers_mut()
-            .set(ContentType(mimetypes::requests::CREATOR_POST.clone()));
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    201 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| CreatorPostResponse::Created(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    400 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| CreatorPostResponse::BadRequest(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| CreatorPostResponse::GenericErrorResponse(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn editgroup_id_accept_post(
-        &self,
-        param_id: i32,
-        context: &Context,
-    ) -> Box<Future<Item = EditgroupIdAcceptPostResponse, Error = ApiError>> {
-        let uri = format!(
-            "{}/v0/editgroup/{id}/accept",
-            self.base_path,
-            id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
-        );
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Post, uri);
-
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    200 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| {
-                                    EditgroupIdAcceptPostResponse::MergedEditgroupSuccessfully_(
-                                        body,
-                                    )
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    400 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| {
-                                    EditgroupIdAcceptPostResponse::EditgroupIsInAnUnmergableState(
-                                        body,
-                                    )
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    404 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| {
-                                    EditgroupIdAcceptPostResponse::NoSuchEditgroup(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| {
-                                    EditgroupIdAcceptPostResponse::GenericErrorResponse(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn editgroup_id_get(
-        &self,
-        param_id: i32,
-        context: &Context,
-    ) -> Box<Future<Item = EditgroupIdGetResponse, Error = ApiError>> {
-        let uri = format!(
-            "{}/v0/editgroup/{id}",
-            self.base_path,
-            id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
-        );
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    200 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| {
-                                    EditgroupIdGetResponse::FetchEditgroupByIdentifier(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    404 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| EditgroupIdGetResponse::NoSuchEditgroup(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| {
-                                    EditgroupIdGetResponse::GenericErrorResponse(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn editgroup_post(
-        &self,
-        context: &Context,
-    ) -> Box<Future<Item = EditgroupPostResponse, Error = ApiError>> {
-        let uri = format!("{}/v0/editgroup", self.base_path);
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Post, uri);
-
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    201 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| EditgroupPostResponse::SuccessfullyCreated(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    400 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| {
-                                    EditgroupPostResponse::InvalidRequestParameters(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| EditgroupPostResponse::GenericErrorResponse(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn editor_username_changelog_get(
-        &self,
-        param_username: String,
-        context: &Context,
-    ) -> Box<Future<Item = EditorUsernameChangelogGetResponse, Error = ApiError>> {
-        let uri = format!(
-            "{}/v0/editor/{username}/changelog",
-            self.base_path,
-            username = utf8_percent_encode(&param_username.to_string(), PATH_SEGMENT_ENCODE_SET)
-        );
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    200 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| {
-                                    EditorUsernameChangelogGetResponse::FindChanges_(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    404 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| {
-                                    EditorUsernameChangelogGetResponse::UsernameNotFound(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| {
-                                    EditorUsernameChangelogGetResponse::GenericErrorResponse(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn editor_username_get(
-        &self,
-        param_username: String,
-        context: &Context,
-    ) -> Box<Future<Item = EditorUsernameGetResponse, Error = ApiError>> {
-        let uri = format!(
-            "{}/v0/editor/{username}",
-            self.base_path,
-            username = utf8_percent_encode(&param_username.to_string(), PATH_SEGMENT_ENCODE_SET)
-        );
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    200 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| {
-                                    EditorUsernameGetResponse::FetchGenericInformationAboutAnEditor(
-                                        body,
-                                    )
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    404 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| EditorUsernameGetResponse::UsernameNotFound(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| {
-                                    EditorUsernameGetResponse::GenericErrorResponse(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn file_id_get(
-        &self,
-        param_id: String,
-        context: &Context,
-    ) -> Box<Future<Item = FileIdGetResponse, Error = ApiError>> {
-        let uri = format!(
-            "{}/v0/file/{id}",
-            self.base_path,
-            id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
-        );
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    200 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| FileIdGetResponse::FetchASingleFileById(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    400 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| FileIdGetResponse::BadRequest(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| FileIdGetResponse::GenericErrorResponse(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn file_lookup_get(
-        &self,
-        param_sha1: String,
-        context: &Context,
-    ) -> Box<Future<Item = FileLookupGetResponse, Error = ApiError>> {
-        // Query parameters
-        let query_sha1 = format!("sha1={sha1}&", sha1 = param_sha1.to_string());
-
-        let uri = format!(
-            "{}/v0/file/lookup?{sha1}",
-            self.base_path,
-            sha1 = utf8_percent_encode(&query_sha1, QUERY_ENCODE_SET)
-        );
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    200 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| {
-                                    FileLookupGetResponse::FindASingleFileByExternalIdentifer(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    400 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| FileLookupGetResponse::BadRequest(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    404 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| FileLookupGetResponse::NoSuchFile(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| FileLookupGetResponse::GenericErrorResponse(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn file_post(
-        &self,
-        param_body: Option<models::FileEntity>,
-        context: &Context,
-    ) -> Box<Future<Item = FilePostResponse, Error = ApiError>> {
-        let uri = format!("{}/v0/file", self.base_path);
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Post, uri);
-
-        let body = param_body
-            .map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
-
-        if let Some(body) = body {
-            request.set_body(body.into_bytes());
-        }
-
-        request
-            .headers_mut()
-            .set(ContentType(mimetypes::requests::FILE_POST.clone()));
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    201 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| FilePostResponse::Created(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    400 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| FilePostResponse::BadRequest(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| FilePostResponse::GenericErrorResponse(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn release_id_get(
-        &self,
-        param_id: String,
-        context: &Context,
-    ) -> Box<Future<Item = ReleaseIdGetResponse, Error = ApiError>> {
-        let uri = format!(
-            "{}/v0/release/{id}",
-            self.base_path,
-            id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
-        );
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    200 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| {
-                                    ReleaseIdGetResponse::FetchASingleReleaseById(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    400 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| ReleaseIdGetResponse::BadRequest(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| ReleaseIdGetResponse::GenericErrorResponse(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn release_lookup_get(
-        &self,
-        param_doi: String,
-        context: &Context,
-    ) -> Box<Future<Item = ReleaseLookupGetResponse, Error = ApiError>> {
-        // Query parameters
-        let query_doi = format!("doi={doi}&", doi = param_doi.to_string());
-
-        let uri = format!(
-            "{}/v0/release/lookup?{doi}",
-            self.base_path,
-            doi = utf8_percent_encode(&query_doi, QUERY_ENCODE_SET)
-        );
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    200 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| {
-                                    ReleaseLookupGetResponse::FindASingleReleaseByExternalIdentifer(
-                                        body,
-                                    )
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    400 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| ReleaseLookupGetResponse::BadRequest(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    404 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| ReleaseLookupGetResponse::NoSuchRelease(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| {
-                                    ReleaseLookupGetResponse::GenericErrorResponse(body)
-                                }),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn release_post(
-        &self,
-        param_body: Option<models::ReleaseEntity>,
-        context: &Context,
-    ) -> Box<Future<Item = ReleasePostResponse, Error = ApiError>> {
-        let uri = format!("{}/v0/release", self.base_path);
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Post, uri);
-
-        let body = param_body
-            .map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
-
-        if let Some(body) = body {
-            request.set_body(body.into_bytes());
-        }
-
-        request
-            .headers_mut()
-            .set(ContentType(mimetypes::requests::RELEASE_POST.clone()));
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    201 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| ReleasePostResponse::Created(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    400 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| ReleasePostResponse::BadRequest(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| ReleasePostResponse::GenericErrorResponse(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn work_id_get(
-        &self,
-        param_id: String,
-        context: &Context,
-    ) -> Box<Future<Item = WorkIdGetResponse, Error = ApiError>> {
-        let uri = format!(
-            "{}/v0/work/{id}",
-            self.base_path,
-            id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
-        );
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    200 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| WorkIdGetResponse::FetchASingleWorkById(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    400 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| WorkIdGetResponse::BadRequest(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| WorkIdGetResponse::GenericErrorResponse(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-
-    fn work_post(
-        &self,
-        param_body: Option<models::WorkEntity>,
-        context: &Context,
-    ) -> Box<Future<Item = WorkPostResponse, Error = ApiError>> {
-        let uri = format!("{}/v0/work", self.base_path);
-
-        let uri = match Uri::from_str(&uri) {
-            Ok(uri) => uri,
-            Err(err) => {
-                return Box::new(futures::done(Err(ApiError(format!(
-                    "Unable to build URI: {}",
-                    err
-                )))))
-            }
-        };
-
-        let mut request = hyper::Request::new(hyper::Method::Post, uri);
-
-        let body = param_body
-            .map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
-
-        if let Some(body) = body {
-            request.set_body(body.into_bytes());
-        }
-
-        request
-            .headers_mut()
-            .set(ContentType(mimetypes::requests::WORK_POST.clone()));
-        context
-            .x_span_id
-            .as_ref()
-            .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
-        let hyper_client = (self.hyper_client)(&*self.handle);
-        Box::new(
-            hyper_client
-                .call(request)
-                .map_err(|e| ApiError(format!("No response received: {}", e)))
-                .and_then(|mut response| match response.status().as_u16() {
-                    201 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|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| WorkPostResponse::Created(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    400 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| WorkPostResponse::BadRequest(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    0 => {
-                        let body = response.body();
-                        Box::new(
-                            body.concat2()
-                                .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
-                                .and_then(|body| {
-                                    str::from_utf8(&body)
-                                        .map_err(|e| {
-                                            ApiError(format!("Response was not valid UTF8: {}", e))
-                                        })
-                                        .and_then(|body| {
-                                            serde_json::from_str::<models::Error>(body)
-                                                .map_err(|e| e.into())
-                                        })
-                                })
-                                .map(move |body| WorkPostResponse::GenericErrorResponse(body)),
-                        ) as Box<Future<Item = _, Error = _>>
-                    }
-                    code => {
-                        let headers = response.headers().clone();
-                        Box::new(response.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<Future<Item = _, Error = _>>
-                    }
-                }),
-        )
-    }
-}
-
-#[derive(Debug)]
-pub enum ClientInitError {
-    InvalidScheme,
-    InvalidUri(hyper::error::UriError),
-    MissingHost,
-    SslError(openssl::error::ErrorStack),
-}
-
-impl From<hyper::error::UriError> for ClientInitError {
-    fn from(err: hyper::error::UriError) -> ClientInitError {
-        ClientInitError::InvalidUri(err)
-    }
-}
-
-impl From<openssl::error::ErrorStack> for ClientInitError {
-    fn from(err: openssl::error::ErrorStack) -> ClientInitError {
-        ClientInitError::SslError(err)
-    }
-}
-
-impl fmt::Display for ClientInitError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        (self as &fmt::Debug).fmt(f)
-    }
-}
-
-impl error::Error for ClientInitError {
-    fn description(&self) -> &str {
-        "Failed to produce a hyper client."
-    }
-}