core/http/src/handling/mod.rs

+pub mod file_handlers;
+pub mod methods;
+pub mod request;
+pub mod response;
+pub mod routes;

core/http/src/handling/request/cookies.rs

+use std::collections::HashMap;
+
+use super::Request;
+
+impl Request {
+    /// Extracts the cookies from a Vector and gives back an optional HashMap of Strings
+    ///
+    /// Returns none if there are no cookies or there is a problem with the cookies, for example
+    /// missing a value.
+    ///
+    /// Removes the `Cookie: ` Header from the Vector of headers
+    ///
+    /// # Examples
+    /// ```
+    /// use http::handling::request::Request;
+    ///
+    ///
+    /// let mut request_vec = vec![
+    ///     "GET / HTTP/1.1".to_string(),
+    ///     "Accept: sdf".to_string(),
+    ///     "Cookie: io=23; f=as".to_string(),
+    ///     "Format: gzip".to_string(),
+    /// ];
+    /// let right_finished_vec = vec![
+    ///     "GET / HTTP/1.1".to_string(),
+    ///     "Accept: sdf".to_string(),
+    ///     "Format: gzip".to_string(),
+    /// ];
+    ///
+    /// let mut wrong = vec!["GET / HTTP/1.1".to_string()];
+    ///
+    /// assert_eq!(None, Request::extract_cookies_from_vec(&mut wrong));
+    /// let cookies = Request::extract_cookies_from_vec(&mut request_vec);
+    /// assert_eq!(right_finished_vec, request_vec);
+    /// assert_eq!("23", cookies.clone().unwrap().get("io").unwrap());
+    /// assert_eq!("as", cookies.unwrap().get("f").unwrap());
+    /// ```
+    ///
+    /// # Panics
+    /// No Panics
+    pub fn extract_cookies_from_vec(headers: &mut Vec<String>) -> Option<HashMap<String, String>> {
+        let mut cookies: HashMap<String, String> = HashMap::new();
+        let mut cookies_string = if let Some(index) = headers
+            .iter()
+            .position(|header| header.starts_with("Cookie: "))
+        {
+            headers.remove(index)
+        } else {
+            return None;
+        };
+        cookies_string = cookies_string
+            .strip_prefix("Cookie: ")
+            .unwrap()
+            .trim()
+            .trim_matches('"')
+            .to_string();
+        for cookie in cookies_string.split(';') {
+            let Some((name, cookie)) = cookie.split_once('=') else {
+                return None;
+            };
+            cookies
+                .entry(name.trim().to_string())
+                .or_insert(cookie.trim().to_string());
+        }
+        Some(cookies)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::handling::request::Request;
+
+    #[test]
+    fn test_cookies() {
+        let mut request_vec = vec![
+            "GET / HTTP/1.1".to_string(),
+            "Accept: sdf".to_string(),
+            "Cookie: io=23; f=as".to_string(),
+            "Format: gzip".to_string(),
+        ];
+        let right_finished_vec = vec![
+            "GET / HTTP/1.1".to_string(),
+            "Accept: sdf".to_string(),
+            "Format: gzip".to_string(),
+        ];
+
+        let mut wrong = vec!["GET / HTTP/1.1".to_string()];
+
+        assert_eq!(None, Request::extract_cookies_from_vec(&mut wrong));
+        let cookies = Request::extract_cookies_from_vec(&mut request_vec);
+        assert_eq!(right_finished_vec, request_vec);
+        assert_eq!("23", cookies.clone().unwrap().get("io").unwrap());
+        assert_eq!("as", cookies.unwrap().get("f").unwrap());
+    }
+}

core/http/src/handling/request/datatypes.rs

+use std::{collections::HashMap, error::Error, fmt::Display};
+
+use crate::{
+    handling::methods::Method,
+    utils::{mime::Mime, url_utils::Uri},
+};
+
+type HeaderMap = Vec<String>;
+
+/// A struct to handle Requests
+///
+#[derive(Clone)]
+pub struct Request {
+    /// The requested Uri
+    pub uri: Uri,
+    /// All headers of the request that haven't been parsed
+    pub headers: HeaderMap,
+    /// The methods Request represented with the [Method]
+    pub method: Method,
+    /// An optional HashMap representation of all Cookies of the request
+    pub cookies: Option<HashMap<String, String>>,
+    /// If the has a body it represents the [Mime]-type of the body
+    pub mime_type: Option<(Mime, String)>,
+    // pub connection: ConnectionMeta,
+}
+
+// struct ConnectionMeta {
+//     remote: Option<SocketAddr>,
+//     // certificates
+// }
+
+#[derive(Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord)]
+/// Media Types in which a Route can be requested to ansewr, optional for routes
+pub enum MediaType {
+    /// Json Data
+    Json,
+    /// Plain Text
+    Plain,
+    /// HTML Text
+    Html,
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum ParseErrors {
+    NoData,
+    BadData,
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+/// Errors that Occur when a Form can't be parsed
+pub struct ParseFormError {
+    pub error: ParseErrors,
+}
+
+impl Display for ParseFormError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.error)
+    }
+}
+
+impl Display for ParseErrors {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ParseErrors::NoData => write!(f, "No Data at key"),
+            ParseErrors::BadData => write!(f, "Bad Data at key"),
+        }
+    }
+}
+
+impl Error for ParseFormError {}

core/http/src/handling/request/form_utils.rs

+use std::collections::HashMap;
+
+use crate::{
+    handling::routes::Data,
+    utils::{mime::Mime, urlencoded::DeCodable},
+};
+
+use super::{datatypes::ParseErrors, ParseFormError, Request};
+static TWO_NEWLINES: u8 = 3;
+
+impl Request {
+    /// # Gets data from a get_form as a HashMap
+    ///
+    /// # Errors
+    /// Gives back a [ParseFormError], top level, if there is lacking data
+    ///
+    /// If everything is fine on the top level it gives back a HashMap of keys and Results, that
+    /// indicate wether the key exists with the [ParseFormError] with an error of
+    /// [ParseErrors::NoData] or wether the key is corrupt with the [ParseErrors::BadData]-Variant
+    ///
+    /// # Examples
+    /// ```
+    /// use http::handling::{request::{Request, ParseFormError, ParseErrors}, methods::Method};
+    /// use http::utils::urlencoded::UrlEncodeData;
+    ///
+    ///
+    /// let request = Request {
+    ///     uri: UrlEncodeData::from_encoded("/form?name=Name&age=Age").unwrap(),
+    ///     headers: vec![],
+    ///     method: Method::Get,
+    ///     cookies: None,
+    ///     mime_type: None,
+    /// };
+    /// let right = request.get_get_form_keys(&["name", "age"]).unwrap();
+    /// assert_eq!(&"Name", right.get("name").unwrap().as_ref().unwrap());
+    /// assert_eq!(&"Age", right.get("age").unwrap().as_ref().unwrap());
+    ///
+    /// let wrong_request = Request {
+    ///     uri: UrlEncodeData::from_encoded("/form").unwrap(),
+    ///     ..request.clone()
+    /// };
+    /// assert_eq!(
+    ///     Err(ParseFormError {
+    ///         error: ParseErrors::NoData
+    ///     }),
+    ///     wrong_request.get_get_form_keys(&["name", "age"])
+    /// );
+    ///
+    /// let bad_data = Request {
+    ///     uri: UrlEncodeData::from_encoded("/form?age=").unwrap(),
+    ///     ..request.clone()
+    /// };
+    /// let wrong = bad_data.get_get_form_keys(&["name", "age"]).unwrap();
+    /// assert_eq!(
+    ///     &Err(ParseFormError {
+    ///         error: ParseErrors::NoData
+    ///     }),
+    ///     wrong.get("name").unwrap()
+    /// );
+    /// assert_eq!(&Ok(""), wrong.get("age").unwrap());
+    /// ```
+    ///
+    /// # Panics
+    /// No Panics
+    pub fn get_get_form_keys<'a>(
+        &'a self,
+        keys: &'a [&str],
+    ) -> Result<HashMap<&str, Result<&str, ParseFormError>>, ParseFormError> {
+        let data = if let Some(val) = self
+            .uri
+            .parts()
+            .last()
+            .unwrap()
+            .raw_string()
+            .unwrap()
+            .split_once('?')
+        {
+            val
+        } else {
+            return Err(ParseFormError {
+                error: ParseErrors::NoData,
+            });
+        };
+        let data = data
+            .1
+            .split('&')
+            .map(|kvp| kvp.split_once('='))
+            .collect::<Vec<Option<(&str, &str)>>>();
+
+        let mut values: HashMap<&str, &str> = HashMap::new();
+        for kvp in data {
+            let kvp = if let Some(kvp) = kvp {
+                kvp
+            } else {
+                continue;
+            };
+            values.insert(kvp.0, kvp.1);
+        }
+        let mut response = HashMap::new();
+        for key in keys {
+            let entry = if let Some(val) = values.get(key) {
+                Ok(*val)
+            } else {
+                Err(ParseFormError {
+                    error: ParseErrors::NoData,
+                })
+            };
+            response.insert(*key, entry);
+        }
+        Ok(response)
+    }
+    pub fn get_post_data<'a>(
+        &'a self,
+        keys: &[&'a str],
+        data: &Data,
+    ) -> Result<HashMap<String, Result<Vec<u8>, ParseFormError>>, ParseFormError> {
+        let data = data.buffer.as_slice();
+        let mut keymap: HashMap<String, Result<Vec<u8>, ParseFormError>> =
+            HashMap::with_capacity(keys.len());
+
+        for key in keys {
+            keymap.entry(key.to_string()).or_insert(Err(ParseFormError {
+                error: ParseErrors::NoData,
+            }));
+        }
+        let Some(ref mime_type) = self.mime_type else {
+            return Err(ParseFormError { error: ParseErrors::BadData });
+        };
+
+        match mime_type.0 {
+            Mime::ApplicationXWwwFormUrlencoded => {
+                let Ok(data) = String::from_utf8(data.to_vec()) else {
+                    return Err(ParseFormError { error: ParseErrors::BadData });
+                };
+                for kvp in data.split('&') {
+                    let Some(kvp) = kvp.split_once('=') else {
+                        return Err(ParseFormError { error: ParseErrors::BadData });
+                    };
+                    let Ok(key) = kvp.0.decode() else {
+                        return Err(ParseFormError { error: ParseErrors::BadData });
+                    };
+                    let Ok(key) = String::from_utf8(key) else {
+                        return Err(ParseFormError { error: ParseErrors::BadData });
+                    };
+                    let Ok(value) = kvp.1.trim_end_matches('\0').decode() else {
+                        return Err(ParseFormError { error: ParseErrors::BadData });
+                    };
+                    let Some(thing) = keymap.get_mut(&key) else {
+                        continue;
+                    };
+                    *thing = Ok(value);
+                }
+            }
+            Mime::MultipartFormData => {
+                let Some(mut boundary) = mime_type.1.split(';').find(|element| element.trim().starts_with("boundary=")) else {
+                    return Err(ParseFormError { error: ParseErrors::BadData });
+                };
+                boundary = boundary
+                    .trim()
+                    .strip_prefix("boundary=")
+                    .unwrap()
+                    .trim_matches('"');
+                let mut temp_bound = "--".to_string();
+                temp_bound.push_str(boundary);
+                let end_boundary: Vec<u8> = format!("{temp_bound}--\r").into();
+                temp_bound.push('\r');
+                let boundary = temp_bound.as_bytes();
+                Self::get_multipart_data(data, boundary, &end_boundary, &mut keymap);
+            }
+            _ => {
+                return Err(ParseFormError {
+                    error: ParseErrors::BadData,
+                })
+            }
+        };
+        Ok(keymap)
+    }
+    fn get_multipart_data(
+        data: &[u8],
+        boundary: &[u8],
+        end_boundary: &[u8],
+        map: &mut HashMap<String, Result<Vec<u8>, ParseFormError>>,
+    ) {
+        let mut current_part: Vec<&[u8]> = vec![];
+        let mut current_key: Option<String> = None;
+        let mut ignore_line = 0;
+        for part in data.split(|byte| byte == &b'\n') {
+            if part == [b'\r'] {
+                if current_key.is_some() {
+                    if ignore_line >= TWO_NEWLINES {
+                        current_part.push(&[b'\n']);
+                        continue;
+                    }
+                    ignore_line += 1;
+                }
+                continue;
+            }
+            if part == end_boundary {
+                if let Some(key) = &current_key {
+                    let mut part = current_part.join(&b'\n');
+                    if part.ends_with(&[b'\r']) {
+                        part.pop();
+                    }
+                    map.insert(key.to_string(), Ok(part));
+                }
+                break;
+            }
+            if part == boundary {
+                if let Some(key) = &current_key {
+                    let mut part = current_part.join(&b'\n');
+                    if part.ends_with(&[b'\r']) {
+                        part.pop();
+                    }
+                    map.insert(key.to_string(), Ok(part));
+                }
+                current_part = vec![];
+                current_key = None;
+                ignore_line = 0;
+                continue;
+            }
+            if part.starts_with(b"Content-Disposition: form-data; name=") {
+                let headers = part
+                    .split(|byte| byte == &b';')
+                    .filter(|header| !header.is_empty())
+                    .collect::<Vec<_>>();
+                if headers.len() < 2 {
+                    continue;
+                }
+                let name = headers[1].split(|byte| byte == &b'=').collect::<Vec<_>>();
+                if name.len() != 2 {
+                    continue;
+                }
+                let mkey = String::from_utf8_lossy(name[1])
+                    .as_ref()
+                    .trim_end()
+                    .trim_matches('"')
+                    .to_owned();
+
+                if map.contains_key::<str>(&mkey) {
+                    current_key = Some(mkey.to_owned());
+                }
+                continue;
+            } else if current_key.is_some() {
+                current_part.push(part);
+            }
+        }
+    }
+}
+#[cfg(test)]
+mod test {
+    use crate::{
+        handling::{
+            methods::Method,
+            request::{datatypes::ParseErrors, ParseFormError},
+            routes::Data,
+        },
+        utils::mime::Mime::{ApplicationXWwwFormUrlencoded, MultipartFormData},
+    };
+
+    use super::Request;
+    #[test]
+    fn try_get_test() {
+        let request = Request {
+            uri: "/form?name=Name&age=Age".try_into().unwrap(),
+            headers: vec![],
+            method: Method::Get,
+            cookies: None,
+            mime_type: None,
+        };
+        let right = request.get_get_form_keys(&["name", "age"]).unwrap();
+        assert_eq!(&"Name", right.get("name").unwrap().as_ref().unwrap());
+        assert_eq!(&"Age", right.get("age").unwrap().as_ref().unwrap());
+
+        let wrong_request = Request {
+            uri: "/form".try_into().unwrap(),
+            ..request.clone()
+        };
+        assert_eq!(
+            Err(ParseFormError {
+                error: ParseErrors::NoData
+            }),
+            wrong_request.get_get_form_keys(&["name", "age"])
+        );
+
+        let bad_data = Request {
+            uri: "/form?age=".try_into().unwrap(),
+            ..request.clone()
+        };
+        let wrong = bad_data.get_get_form_keys(&["name", "age"]).unwrap();
+        assert_eq!(
+            &Err(ParseFormError {
+                error: ParseErrors::NoData
+            }),
+            wrong.get("name").unwrap()
+        );
+        assert_eq!(&Ok(""), wrong.get("age").unwrap());
+    }
+
+    #[test]
+    fn try_post_text() {
+        let req = Request {
+            uri: "".try_into().unwrap(),
+            headers: vec!["Content-Type: application/x-www-form-urlencoded".to_string()],
+            method: Method::Post,
+            cookies: None,
+            mime_type: Some((ApplicationXWwwFormUrlencoded, "".into())),
+        };
+        let data = Data {
+            buffer: b"message=23&message1=24".to_vec(),
+            is_complete: true,
+        };
+        let map = req.get_post_data(&["message", "message1"], &data).unwrap();
+        assert_eq!(
+            &b"23".to_vec(),
+            map.get("message").unwrap().as_ref().unwrap()
+        );
+        assert_eq!(
+            &b"24".to_vec(),
+            map.get("message1").unwrap().as_ref().unwrap()
+        );
+        let req = Request {
+            uri: "".try_into().unwrap(),
+            headers: vec!["Content-Type: multipart/form-data; boundary=\"boundary\"".to_string()],
+            method: Method::Post,
+            cookies: None,
+            mime_type: Some((
+                MultipartFormData,
+                "charset=UTF-8; boundary=\"boundary\"".into(),
+            )),
+        };
+        let data = Data {
+            buffer: b"--boundary\r
+Content-Disposition: form-data; name=\"field1\"\r
+\r
+value1\r
+--boundary\r
+Content-Disposition: form-data; name=\"field2\"; filename=\"example.txt\"\r
+\r
+va\nlue2\r
+--boundary--\r
+"
+            .to_vec(),
+            is_complete: true,
+        };
+        let map = req.get_post_data(&["field1", "field2"], &data).unwrap();
+
+        assert_eq!(
+            &b"value1".to_vec(),
+            map.get("field1").unwrap().as_ref().unwrap()
+        );
+        assert_eq!(
+            &b"va\nlue2".to_vec(),
+            map.get("field2").unwrap().as_ref().unwrap()
+        );
+    }
+}

core/http/src/handling/request/mod.rs

+mod cookies;
+mod datatypes;
+mod form_utils;
+mod request_impl;
+mod request_mime;
+pub use datatypes::{MediaType, ParseErrors, ParseFormError, Request};

core/http/src/handling/request/request_impl.rs

+use crate::handling::methods::Method;
+
+use super::Request;
+
+impl Request {
+    /// Checks if the request can have a body
+    pub fn can_have_body(&self) -> bool {
+        matches!(
+            self.method,
+            Method::Post | Method::Put | Method::Patch | Method::Delete
+        )
+    }
+    /// Checks if a body is mandatory for the Request
+    pub fn mandatory_body(&self) -> bool {
+        matches!(self.method, Method::Post | Method::Put | Method::Patch)
+    }
+}

core/http/src/handling/request/request_mime.rs

+use super::datatypes::Request;
+
+impl Request {
+    /// Sets the `mime_type` of this [`Request`] from the headers.
+    ///
+    /// The mime_type can remain none if there isn't a `Content-Type: ` header
+    ///
+    /// # Example
+    /// ```
+    /// use http::{
+    ///     handling::{methods::Method, request::Request},
+    ///     utils::{mime::Mime, urlencoded::UrlEncodeData},
+    /// };
+    ///
+    /// let mut request = Request {
+    ///     uri: UrlEncodeData::from_encoded("thing").unwrap(),
+    ///     headers: vec![
+    ///         "GET / 23".to_string(),
+    ///         "SDF:LKJSD:F".to_string(),
+    ///         "Content-Type: text/plain; charset=UTF-8".to_string(),
+    ///         "SDF".to_string(),
+    ///     ],
+    ///     method: Method::Get,
+    ///     cookies: None,
+    ///     mime_type: None,
+    /// };
+    /// let mut wrong = Request {
+    ///     uri: UrlEncodeData::from_encoded("thing").unwrap(),
+    ///     headers: vec![
+    ///         "GET / 23".to_string(),
+    ///         "SDF:LKJSD:F".to_string(),
+    ///         "SDF".to_string(),
+    ///     ],
+    ///     method: Method::Get,
+    ///     cookies: None,
+    ///     mime_type: None,
+    /// };
+    /// request.mime_from_headers();
+    /// wrong.mime_from_headers();
+    /// assert_eq!(None, wrong.mime_type);
+    /// assert_eq!((Mime::TextPlain, " charset=UTF-8".to_string()), request.mime_type.unwrap());
+    /// ```
+    /// # Panics
+    /// No Panics
+    pub fn mime_from_headers(&mut self) {
+        let Some(content_type_header) = self.headers
+            .iter()
+            .find(|header| header.starts_with("Content-Type: ")) else {
+            return;
+        };
+        let content_type_string: &str = content_type_header
+            .strip_prefix("Content-Type: ")
+            .unwrap()
+            .trim();
+
+        self.mime_type = if let Some(content_type) = content_type_string.split_once(';') {
+            let Ok(mime) = content_type.0.trim().parse() else {
+                return;
+            };
+            Some((mime, content_type.1.to_owned()))
+        } else {
+            let Ok(mime) = content_type_string.parse() else {
+                    return;
+                };
+            Some((mime, "".to_owned()))
+        };
+    }
+}
+
+#[cfg(test)]
+mod test {
+
+    use crate::{
+        handling::{methods::Method, request::Request},
+        utils::mime::Mime,
+    };
+
+    #[test]
+    pub fn test_mime_parse_from_header_vec() {
+        let mut request = Request {
+            uri: "thing".try_into().unwrap(),
+            headers: vec![
+                "GET / 23".to_string(),
+                "SDF:LKJSD:F".to_string(),
+                "Content-Type: text/plain".to_string(),
+                "SDF".to_string(),
+            ],
+            method: Method::Get,
+            cookies: None,
+            mime_type: None,
+        };
+
+        let mut wrong = Request {
+            uri: "thing".try_into().unwrap(),
+            headers: vec![
+                "GET / 23".to_string(),
+                "SDF:LKJSD:F".to_string(),
+                "SDF".to_string(),
+            ],
+            method: Method::Get,
+            cookies: None,
+            mime_type: None,
+        };
+        request.mime_from_headers();
+        wrong.mime_from_headers();
+        assert_eq!(None, wrong.mime_type);
+        assert_eq!((Mime::TextPlain, "".to_owned()), request.mime_type.unwrap());
+    }
+}

core/http/src/handling/response/build_and_write.rs

+use std::io::Result;
+
+use tokio::io::{AsyncWriteExt, AsyncRead, AsyncWrite};
+
+use crate::handling::{methods::Method, request::Request, response::Status};
+
+use super::Response;
+
+impl Response {
+    /// Builds a [`Vec<u8>`] valid http response from a [Response] and consumes it. Optionally
+    /// takes in a request for things like [Method::Head]
+    pub fn build(self, request: Option<Request>) -> Vec<u8> {
+        let compiled_headers = format!(
+            "HTTP/1.1 {}\r\nContent-Length: {}\r\nContent-Type: {}\r\n",
+            self.status.unwrap_or(Status::Ok),
+            self.body.get_len(),
+            self.body.get_mime()
+        ) + &self.headers.join("\r\n")
+            + "\r\n";
+        let is_head = if let Some(req) = request {
+            req.method == Method::Head
+        } else {
+            false
+        };
+        let compiled_body = if is_head {
+            vec![]
+        } else {
+            self.body.get_data()
+        };
+        let mut compiled_out: Vec<u8> = compiled_headers.into();
+        compiled_out.extend_from_slice(&compiled_body);
+        compiled_out
+    }
+    /// Builds and writes The http-Response, consumes the  [tokio::net::TcpStream] [Request] and [Response]
+    pub async fn write<T: AsyncRead + AsyncWrite + std::marker::Unpin>(self, mut stream: T, request: Option<Request>) -> Result<()> {
+        let resp = self.build(request);
+        stream.write_all(&resp).await?;
+        Ok(())
+    }
+}

core/http/src/handling/response/cookie_management/cookie.rs

+use std::{collections::HashMap, str::FromStr, time::Duration};
+
+use crate::{
+    handling::response::{cookie_management::error_types::CookieError, CookieBuilder},
+    utils::{url_utils::Uri, urlencoded::DeCodable},
+};
+
+macro_rules! update_map {
+    ($map:expr, $key:expr) => {
+        *$map.get_mut($key).unwrap() = true;
+    };
+}
+
+use super::error_types::{ParseCookieError, ParseSameSiteError, SameSiteError};
+
+/// Structure representing a Cookie
+/// # Creating a Cookie:
+/// ```
+/// use http::handling::response::Cookie;
+/// use http::handling::response::CookieBuilder;
+///
+/// let cookie = CookieBuilder::build("name", "value").finish();
+/// ```
+#[derive(PartialEq, Eq, PartialOrd, Ord, Debug)]
+pub struct Cookie {
+    /// Storage for the cookie string. Only used if this structure was derived
+    /// from a string that was subsequently parsed.
+    pub(crate) cookie_string: Option<String>,
+    pub(crate) name: String,
+    pub(crate) value: String,
+    /// Whether this cookie was marked Secure.
+    pub(crate) secure: bool,
+    /// Whether this cookie was marked HttpOnly.
+    pub(crate) http_only: bool,
+    pub(crate) partitioned: bool,
+    // expires: Option<Tm>,
+    pub(crate) max_age: Option<Duration>,
+    /// The draft `SameSite` attribute.
+    pub(crate) same_site: Option<SameSite>,
+    /// The cookie's domain, if any.
+    pub(crate) domain: Option<String>,
+    /// The cookie's path domain, if any.
+    pub(crate) path: Option<Uri>,
+    pub(crate) expires: Option<String>,
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+/// SameSite Paremeters
+pub enum SameSite {
+    /// Requires Secure
+    None,
+    Lax,
+    Strict,
+}
+
+impl std::fmt::Display for SameSite {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::None => write!(f, "SameSite=None"),
+            Self::Lax => write!(f, "SameSite=Lax"),
+            Self::Strict => write!(f, "SameSite=Strict"),
+        }
+    }
+}
+
+impl FromStr for SameSite {
+    type Err = ParseSameSiteError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "None" => Ok(SameSite::None),
+            "Lax" => Ok(SameSite::Lax),
+            "Strict" => Ok(SameSite::Strict),
+            _ => Err(Self::Err {
+                inner: SameSiteError::NotAValidVariant,
+            }),
+        }
+    }
+}
+
+impl std::fmt::Display for Cookie {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut appendix = String::from("");
+        if self.secure {
+            appendix += "; Secure";
+        }
+        if self.http_only {
+            appendix += "; HttpOnly";
+        }
+        if self.partitioned {
+            appendix += "; Partitioned";
+        }
+        if let Some(max_age) = &self.max_age {
+            appendix += &format!("; Max-Age={}", max_age.as_secs());
+        }
+        if let Some(domain) = &self.domain {
+            appendix += &format!("; Domain={}", domain);
+        }
+        if let Some(path) = &self.path {
+            appendix += &format!("; Path={}", path);
+        }
+        if let Some(same_site) = &self.same_site {
+            appendix += &format!("; {}", same_site);
+            if !self.secure && *same_site == SameSite::None {
+                appendix += "; Secure";
+            }
+        }
+        if let Some(expires) = &self.expires {
+            appendix += &format!("; Expires={}", expires)
+        }
+        write!(f, "Set-Cookie: {}={}{}", self.name, self.value, appendix)
+    }
+}
+
+impl FromStr for Cookie {
+    type Err = ParseCookieError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut map = HashMap::with_capacity(8);
+        map.insert("Partitioned", false);
+        map.insert("HttpOnly", false);
+        map.insert("Secure", false);
+        map.insert("SameSite", false);
+        map.insert("Max-Age", false);
+        map.insert("Domain", false);
+        map.insert("Path", false);
+        map.insert("Expires", false);
+        let mut final_result = CookieBuilder::build("", "");
+        let mut first = true;
+        let stripped = s.strip_prefix("Set-Cookie: ").ok_or(Self::Err {
+            inner: CookieError::NoSetCookieHeader,
+        })?;
+        for part in stripped.split(';') {
+            let trimmed_part = part.trim();
+            if first {
+                let Some(name_val) = part.split_once('=') else {
+                    return Err(Self::Err { inner: CookieError::MissingEqual  });
+                };
+                unsafe {
+                    final_result = CookieBuilder::build(
+                        &String::from_utf8_unchecked(if let Ok(name) = name_val.0.decode() {
+                            name
+                        } else {
+                            name_val.0.into()
+                        }),
+                        &String::from_utf8_unchecked(if let Ok(value) = name_val.1.decode() {
+                            value
+                        } else {
+                            name_val.1.into()
+                        }),
+                    );
+                }
+                first = false;
+                continue;
+            }
+            if !map.get("Max-Age").unwrap() && trimmed_part.starts_with("Max-Age=") {
+                final_result = final_result.max_age(Duration::from_secs(
+                    trimmed_part
+                        .strip_prefix("Max-Age=")
+                        .unwrap()
+                        .parse()
+                        .map_err(|_| Self::Err {
+                            inner: CookieError::InvalidMaxAge,
+                        })?,
+                ));
+                update_map!(map, "Max-Age");
+                continue;
+            }
+            if !map.get("Expires").unwrap() && trimmed_part.starts_with("Expires=") {
+                final_result = final_result.expires(trimmed_part.strip_prefix("Expires=").unwrap());
+                update_map!(map, "Expires");
+                continue;
+            }
+            if !map.get("HttpOnly").unwrap() && trimmed_part == "HttpOnly" {
+                final_result = final_result.http_only(true);
+                update_map!(map, "HttpOnly");
+                continue;
+            }
+            if !map.get("SameSite").unwrap() && trimmed_part.starts_with("SameSite=") {
+                final_result = final_result.same_site(
+                    trimmed_part
+                        .strip_prefix("SameSite=")
+                        .unwrap()
+                        .parse::<SameSite>()
+                        .map_err(|err| Self::Err {
+                            inner: CookieError::InvilidSameSite(err.inner),
+                        })?,
+                );
+                update_map!(map, "SameSite");
+                continue;
+            }
+            if !map.get("Path").unwrap() && trimmed_part.starts_with("Path=") {
+                final_result = final_result.path(
+                    trimmed_part
+                        .strip_prefix("Path=")
+                        .unwrap()
+                        .parse::<Uri>()
+                        .map_err(|err| Self::Err {
+                            inner: CookieError::PathError(err.error),
+                        })?,
+                );
+                update_map!(map, "Path");
+                continue;
+            }
+            if !map.get("Domain").unwrap() && trimmed_part.starts_with("Domain=") {
+                final_result = final_result.domain(trimmed_part.strip_prefix("Domain=").unwrap());
+                update_map!(map, "Domain");
+                continue;
+            }
+            if !map.get("Secure").unwrap() && trimmed_part == "Secure" {
+                final_result = final_result.secure(true);
+                update_map!(map, "Secure");
+                continue;
+            }
+
+            if !map.get("Partitioned").unwrap() && trimmed_part == "Partitioned" {
+                final_result = final_result.partitioned(true);
+                update_map!(map, "Partitioned");
+                continue;
+            }
+        }
+        Ok(final_result.finish())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::time::Duration;
+
+    use crate::handling::response::{Cookie, CookieBuilder};
+
+    use super::SameSite;
+
+    #[test]
+    fn test_cookie_to_string() {
+        let test_cookie1 = CookieBuilder::build("a", "cookie").finish().to_string();
+        let test_cookie1_res = "Set-Cookie: a=cookie";
+        let test_cookie2 = CookieBuilder::build("a", "secure_cookie")
+            .secure(true)
+            .finish()
+            .to_string();
+        let test_cookie2_res = "Set-Cookie: a=secure_cookie; Secure";
+        let test_cookie3 = CookieBuilder::build("ab", "ss")
+            .max_age(Duration::from_secs(24))
+            .domain("codecraft.com")
+            .path("/".parse().unwrap())
+            .same_site(SameSite::None)
+            .http_only(true)
+            .partitioned(true)
+            .expires("Monday")
+            .finish();
+        let test_cookie3_res = "Set-Cookie: ab=ss; Secure; HttpOnly; Partitioned; \
+            Max-Age=24; Domain=codecraft.com; Path=/; SameSite=None; Expires=Monday";
+
+        assert_eq!(test_cookie1_res, test_cookie1);
+        assert_eq!(test_cookie2_res, test_cookie2);
+        assert_eq!(test_cookie3_res, test_cookie3.to_string());
+    }
+    #[test]
+    fn cookie_from_string() {
+        let test_cookie3_res = "Set-Cookie: ab=ss; HttpOnly; Partitioned; \
+            Max-Age=24; Domain=codecraft.com; Path=/; SameSite=None; Secure; Expires=Monday";
+        let test_cookie3 = CookieBuilder::build("ab", "ss")
+            .max_age(Duration::from_secs(24))
+            .domain("codecraft.com")
+            .path("/".parse().unwrap())
+            .same_site(SameSite::None)
+            .http_only(true)
+            .partitioned(true)
+            .expires("Monday")
+            .finish();
+        assert_eq!(test_cookie3, test_cookie3_res.parse::<Cookie>().unwrap());
+    }
+}

core/http/src/handling/response/cookie_management/cookie_builder.rs

+use std::time::Duration;
+
+use crate::utils::{url_utils::Uri, urlencoded::EnCodable};
+
+use super::{Cookie, SameSite};
+
+/// Builder wrapper for a Cookie
+///
+/// # Example
+/// ```
+/// use http::handling::response::Cookie;
+/// use http::handling::response::CookieBuilder;
+///
+/// let cookie = CookieBuilder::build("name", "value").path("/".parse().unwrap()).finish();
+/// ```
+#[derive(Debug)]
+pub struct CookieBuilder {
+    /// Cookie under the hood
+    inner: Cookie,
+}
+
+impl CookieBuilder {
+    /// Builds a basic CookieBuilder from a name and a value
+    pub fn build(name: &str, value: &str) -> Self {
+        CookieBuilder {
+            inner: Cookie {
+                cookie_string: None,
+                name: name.encode(),
+                value: value.encode(),
+                max_age: None,
+                domain: None,
+                path: None,
+                secure: false,
+                http_only: false,
+                same_site: None,
+                expires: None,
+                partitioned: false,
+            },
+        }
+    }
+    pub fn finish(self) -> Cookie {
+        self.inner
+    }
+    pub fn max_age(mut self, duration: Duration) -> Self {
+        self.inner.max_age = Some(duration);
+        self
+    }
+    pub fn domain(mut self, domain: &str) -> Self {
+        self.inner.domain = Some(domain.encode());
+        self
+    }
+    pub fn path(mut self, path: Uri) -> Self {
+        self.inner.path = Some(path);
+        self
+    }
+    pub fn secure(mut self, secure: bool) -> Self {
+        self.inner.secure = secure;
+        self
+    }
+    pub fn http_only(mut self, http_only: bool) -> Self {
+        self.inner.http_only = http_only;
+        self
+    }
+    pub fn same_site(mut self, same_site: SameSite) -> Self {
+        if same_site == SameSite::None {
+            self.inner.secure = true;
+        }
+        self.inner.same_site = Some(same_site);
+        self
+    }
+    pub fn expires(mut self, expire: &str) -> Self {
+        self.inner.expires = Some(expire.encode());
+        self
+    }
+    pub fn partitioned(mut self, partitioned: bool) -> Self {
+        self.inner.partitioned = partitioned;
+        self
+    }
+    pub fn name(mut self, name: &str) -> Self {
+        self.inner.name = name.encode();
+        self
+    }
+    pub fn value(mut self, value: &str) -> Self {
+        self.inner.value = value.encode();
+        self
+    }
+}

core/http/src/handling/response/cookie_management/error_types.rs

+use std::error::Error;
+
+use crate::utils::url_utils::UriError;
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum SameSiteError {
+    NotAValidVariant,
+}
+
+#[derive(Debug)]
+pub struct ParseSameSiteError {
+    pub inner: SameSiteError,
+}
+
+impl Error for ParseSameSiteError {}
+
+impl std::fmt::Display for ParseSameSiteError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+impl Error for ParseCookieError {}
+
+#[derive(Debug)]
+pub struct ParseCookieError {
+    pub inner: CookieError,
+}
+
+#[derive(Debug, PartialEq, PartialOrd, Eq, Ord)]
+pub enum CookieError {
+    MissingEqual,
+    InvalidAttribute,
+    InvalidMaxAge,
+    NoSetCookieHeader,
+    InvilidSameSite(SameSiteError),
+    PathError(UriError),
+}
+
+impl std::fmt::Display for ParseCookieError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "ParseCookieError {{ error: {:?} }}", self.inner)
+    }
+}

core/http/src/handling/response/cookie_management/mod.rs

+mod cookie;
+mod cookie_builder;
+mod error_types;
+
+pub use cookie::Cookie;
+pub use cookie::SameSite;
+pub use cookie_builder::CookieBuilder;
+pub use error_types::CookieError;
+pub use error_types::ParseCookieError;
+pub use error_types::ParseSameSiteError;
+pub use error_types::SameSiteError;

core/http/src/handling/response/datatypes.rs

+use super::{Cookie, ResponseBody, Status};
+
+type HeaderMap = Vec<String>;
+
+#[derive(Debug)]
+/// Enum for the result of a Handling Function, where...
+///
+/// [Outcome::Success] represents that the route
+/// was successful and the Answer is contained in \[S\].
+/// [Outcome::Failure] represents that it was unsuccessful and nobody else is going to be
+/// successful. \[E\] represnts the Error Code.
+/// [Outcome::Forward] represents that some requirements weren't met for a route to be working with
+/// the request so the next one that matches should cover that \[F\] represents the maybe processed
+/// data of the request.
+///
+/// # Example
+/// ```
+/// use http::handling::{response::{Outcome, Response, Status}, routes::Data, request::Request};
+/// fn handler(request: Request, _data: Data) -> Outcome<Response, Status, Data> {
+///     todo!()
+/// }
+/// ```
+pub enum Outcome<S, E, F> {
+    Success(S),
+    Failure(E),
+    Forward(F),
+}
+
+/// Response is a wrapper for http responses.
+#[derive(Debug)]
+pub struct Response {
+    /// the [`Vec<String>`] of headers unrelated to `Content-Type` and `Content-Length`
+    pub headers: HeaderMap,
+    /// Optional Cookie in the response
+    pub cookies: Option<Cookie>,
+    /// Status code of the response
+    pub status: Option<Status>,
+    /// Response body and `Content-Type` and `Content-Length` headers.
+    pub body: Box<dyn ResponseBody>,
+}

core/http/src/handling/response/mod.rs

+mod build_and_write;
+mod cookie_management;
+mod datatypes;
+mod status;
+mod traits;
+
+pub use cookie_management::Cookie;
+pub use cookie_management::CookieBuilder;
+pub use cookie_management::SameSite;
+pub use datatypes::Outcome;
+pub use datatypes::Response;
+pub use status::Status;
+pub use traits::ResponseBody;

core/http/src/handling/response/status.rs

+use std::fmt::Display;
+
+#[derive(Debug)]
+/// Enum With every http status for complete documentation [here](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status)
+pub enum Status {
+    Continue,
+    SwitchingProtocols,
+    /// WebDAV
+    Processing,
+    /// Experimental
+    EarlyHints,
+    Ok,
+    Created,
+    Accepted,
+    NonAuthorativeIfnormation,
+    NoContent,
+    ResetContent,
+    PartialContent,
+    /// WebDAV
+    MultiStatus,
+    /// WebDAV
+    AlreadyReported,
+    HttpDataEncodingImUsed,
+    MultipleChoices,
+    MovedPermanently,
+    Found,
+    SeeOther,
+    NotModfiied,
+    /// Deprecated
+    UseProxy,
+    /// Deprecated
+    Unused,
+    TemporaryRedirect,
+    PermanentRedirect,
+    BadRequest,
+    Unauthorized,
+    /// Experimental
+    PaymentRequired,
+    Forbidden,
+    NotFound,
+    MethodNotAllowed,
+    NotAcceptable,
+    ProxyAuthenticationRequired,
+    RequestTimeout,
+    Conflict,
+    Gone,
+    LengthRequired,
+    PreconditionFailed,
+    PayloadTooLarge,
+    UriTooLong,
+    UnsupportedMediaType,
+    RangeNotSatisfiable,
+    ExpectationFailed,
+    ImATeapot,
+    MisdirectedRequest,
+    /// WebDAV
+    UnprocessableContent,
+    /// WebDAV
+    Locked,
+    /// WebDAV
+    FailedDependency,
+    /// Experimental
+    TooEarly,
+    UpgradeRequred,
+    PreconditionRequired,
+    TooManyRequests,
+    RequestHeaderFieldsTooLarge,
+    UnavailableForLegalReasons,
+    InternalServerError,
+    NotImplemented,
+    BadGetaway,
+    ServiceUnavailable,
+    GetawayTimeout,
+    HttpVersionNotSupported,
+    VariantAlsoNegotiates,
+    /// WebDAV
+    InsufficientStorage,
+    /// WebDAV
+    LoopDetected,
+    NotExtended,
+    NetworkAuthenticationRequired,
+}
+
+impl Display for Status {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Status::Continue => write!(f, "100 Continue"),
+            Status::SwitchingProtocols => write!(f, "101 Switching Protocols"),
+            Status::Processing => write!(f, "102 Processing"),
+            Status::EarlyHints => write!(f, "103 Early Hints"),
+            Status::Ok => write!(f, "200 OK"),
+            Status::Created => write!(f, "201 Created"),
+            Status::Accepted => write!(f, "202 Accepted"),
+            Status::NonAuthorativeIfnormation => write!(f, "203 Non-Authorative Information"),
+            Status::NoContent => write!(f, "204 No Content"),
+            Status::ResetContent => write!(f, "205 Reset Content"),
+            Status::PartialContent => write!(f, "206 Partial Content"),
+            Status::MultiStatus => write!(f, "207 Mutli-Status"),
+            Status::AlreadyReported => write!(f, "208 Already Reported"),
+            Status::HttpDataEncodingImUsed => write!(f, "226 IM Used"),
+            Status::MultipleChoices => write!(f, "300 Multiple Choices"),
+            Status::MovedPermanently => write!(f, "301 Moved Permanently"),
+            Status::Found => write!(f, "302 Found"),
+            Status::SeeOther => write!(f, "303 See Other"),
+            Status::NotModfiied => write!(f, "304 Not Modified"),
+            Status::TemporaryRedirect => write!(f, "307 Temporary Redirect"),
+            Status::PermanentRedirect => write!(f, "308 Permanent Redirect"),
+            Status::UseProxy => write!(f, "305 Use Proxy"),
+            Status::Unused => write!(f, "306 unused"),
+            Status::BadRequest => write!(f, "400 Bad Request"),
+            Status::Unauthorized => write!(f, "401 Unauthorized"),
+            Status::PaymentRequired => write!(f, "402 Payment Required"),
+            Status::Forbidden => write!(f, "403 Forbidden"),
+            Status::NotFound => write!(f, "404 Not Found"),
+            Status::MethodNotAllowed => write!(f, "405 Method Not Allowed"),
+            Status::NotAcceptable => write!(f, "406 Not Acceptable"),
+            Status::ProxyAuthenticationRequired => {
+                write!(f, "407 Proxy Athentication Required")
+            }
+            Status::RequestTimeout => write!(f, "408 Request Timout"),
+            Status::Conflict => write!(f, "409 Conflict"),
+            Status::Gone => write!(f, "410 Gone"),
+            Status::LengthRequired => write!(f, "411 Length Required"),
+            Status::PreconditionFailed => write!(f, "412 Precondition Failed"),
+            Status::PayloadTooLarge => write!(f, "413 Payload Too Large"),
+            Status::UriTooLong => write!(f, "414 URI Too Long"),
+            Status::UnsupportedMediaType => write!(f, "415 Unsupported Media Type"),
+            Status::RangeNotSatisfiable => write!(f, "416 Range Not Satisfiable"),
+            Status::ExpectationFailed => write!(f, "417 Expectation Failed"),
+            Status::ImATeapot => write!(f, "418 I'm a Teapot"),
+            Status::MisdirectedRequest => write!(f, "421 Misdirected Request"),
+            Status::UnprocessableContent => write!(f, "422 Unprocessable Content"),
+            Status::Locked => write!(f, "423 Locked"),
+            Status::FailedDependency => write!(f, "424 Failed Dependency"),
+            Status::TooEarly => write!(f, "425 Too Early"),
+            Status::UpgradeRequred => write!(f, "426 Upgrade Required"),
+            Status::PreconditionRequired => write!(f, "428 Precondition Required"),
+            Status::TooManyRequests => write!(f, "429 Too Many Requests"),
+            Status::RequestHeaderFieldsTooLarge => {
+                write!(f, "431 Request Header Fields Too Large")
+            }
+            Status::UnavailableForLegalReasons => {
+                write!(f, "451 Unavailable For Legal Reasons")
+            }
+            Status::InternalServerError => write!(f, "500 Internal Server Error"),
+            Status::NotImplemented => write!(f, "501 Not Implmenented"),
+            Status::BadGetaway => write!(f, "502 Bad Getaway"),
+            Status::ServiceUnavailable => write!(f, "503 Service Unavailable"),
+            Status::GetawayTimeout => write!(f, "504 Getaway Timeout"),
+            Status::HttpVersionNotSupported => write!(f, "505 HTTP Version Not Supported"),
+            Status::VariantAlsoNegotiates => write!(f, "506 Variant Also Negotiates"),
+            Status::InsufficientStorage => write!(f, "507 Insufficient Storage"),
+            Status::LoopDetected => write!(f, "508 Loop Detected"),
+            Status::NotExtended => write!(f, "510 Not Extendend"),
+            Status::NetworkAuthenticationRequired => {
+                write!(f, "511 Network Authentication Required")
+            }
+        }
+    }
+}

core/http/src/handling/response/traits.rs

+use std::fmt::Debug;
+
+use crate::{handling::routes::Body, utils::mime::Mime};
+
+/// Trait for using datatypes as response bodies
+pub trait ResponseBody: Send + Debug {
+    /// Get a cloned version of the data as a [`Vec<u8>`]
+    /// # Ecamples
+    /// ```
+    /// use http::handling::response::ResponseBody;
+    /// let data = "DATA";
+    /// assert_eq!(b"DATA".to_vec(), data.get_data());
+    /// ```
+    fn get_data(&self) -> Vec<u8>;
+    /// get the miem type of the data as a [Mime]
+    /// # Examples
+    /// ```
+    /// use http::handling::response::ResponseBody;
+    /// use http::utils::mime::Mime;
+    /// let data = "DATA";
+    /// assert_eq!(Mime::TextPlain, data.get_mime());
+    /// ```
+    fn get_mime(&self) -> Mime;
+    /// get the length in bytes of the data as a [usize]
+    /// # Examples
+    /// ```
+    /// use http::handling::response::ResponseBody;
+    /// let data = "DATA";
+    /// assert_eq!(4, data.get_len());
+    /// ```
+    fn get_len(&self) -> usize;
+}
+
+impl ResponseBody for Body {
+    fn get_data(&self) -> Vec<u8> {
+        self.body()
+    }
+    fn get_mime(&self) -> Mime {
+        self.mime_type()
+    }
+
+    fn get_len(&self) -> usize {
+        self.get_data().len()
+    }
+}
+
+impl ResponseBody for &str {
+    fn get_data(&self) -> Vec<u8> {
+        self.as_bytes().to_vec()
+    }
+
+    fn get_mime(&self) -> Mime {
+        Mime::TextPlain
+    }
+
+    fn get_len(&self) -> usize {
+        self.len()
+    }
+}
+
+impl ResponseBody for String {
+    fn get_data(&self) -> Vec<u8> {
+        self.as_bytes().to_vec()
+    }
+
+    fn get_mime(&self) -> Mime {
+        Mime::TextPlain
+    }
+
+    fn get_len(&self) -> usize {
+        self.len()
+    }
+}

core/http/src/handling/routes.rs

+use crate::{
+    handling::{
+        methods::Method,
+        request::{MediaType, Request},
+        response::{Outcome, Response, Status},
+    },
+    utils::{mime::Mime, url_utils::RawUri},
+};
+
+/// A RouteBuilder struct
+pub struct RouteBuilder {
+    /// An optional name of the route
+    name: Option<&'static str>,
+    /// The [Method] via which the route is accesable
+    method: Method,
+    /// The path of the route, allows special cases:
+    /// # Examples
+    /// ```
+    /// "/home"; // Only /home
+    /// "/<home>/something";
+    /// // Variable content the users provides this acts for /<anything>/something
+    /// "/<home..>";
+    /// // All Information after this sequence is irrelvent
+    /// // Matches: /a, /a/b/c ...
+    /// ```
+    path: &'static str,
+    /// The Handler function for this route, which gets called when the request need the route.
+    /// Inputs to the function are an [Request] and the [Data] which represents the body of the
+    /// [Request]. The Outcome is expected to be an [Outcome], which is a [Response], A [Status] if
+    /// something went wrong and a [Status] page is need or a [Outcome::Forward] of the requests
+    /// [Data] for the next [Route] to take care of.
+    handler: fn(Request, Data) -> Outcome<Response, Status, Data>,
+    /// The Specific answer format of the [Route] as a [MediaType]. Optional
+    format: Option<MediaType>,
+    /// The Optional Rank of the Route, dependent on its specificness. so the rank of a uri `"/home"` would be
+    /// ranked high, whereas a uri of `"/<anything..>"` would be ranked the lowest
+    /// If not given generated based on parematers.
+    rank: Option<isize>,
+}
+
+/// A struct to define Routes on the Server
+#[derive(Clone)]
+pub struct Route {
+    /// An optional name of the route
+    pub name: Option<&'static str>,
+    /// The [Method] via which the route is accesable
+    pub method: Method,
+    /// The Uri of the route, allows special cases:
+    /// # Examples
+    /// ```
+    /// "/home"; // Only /home
+    /// "/<home>/something";
+    /// // Variable content the users provides this acts for /<anything>/something
+    /// "/<home..>";
+    /// // All Information after this sequence is irrelvent
+    /// // Matches: /a, /a/b/c ...
+    /// ```
+    pub uri: RawUri,
+    /// The Handler function for this route, which gets called when the request need the route.
+    /// Inputs to the function are an [Request] and the [Data] which represents the body of the
+    /// [Request]. The Outcome is expected to be an [Outcome], which is a [Response], A [Status] if
+    /// something went wrong and a [Status] page is need or a [Outcome::Forward] of the requests
+    /// [Data] for the next [Route] to take care of.
+    pub handler: fn(Request, Data) -> Outcome<Response, Status, Data>,
+    /// The Rank of the Route, dependent on its specificness. so the rank of a uri `"/home"` would be
+    /// ranked high, whereas a uri of `"/<anything..>"` would be ranked the lowest
+    pub rank: isize,
+    /// The Specific answer format of the [Route] as a [MediaType]. Optional
+    pub format: Option<MediaType>,
+}
+
+impl Route {
+    /// generates a Route from a Routebuilder
+    //TODO: ranking
+    pub fn from(routeinfo: RouteBuilder) -> Self {
+        let rank = routeinfo.rank.unwrap_or(0);
+        Route {
+            name: routeinfo.name,
+            method: routeinfo.method,
+            uri: routeinfo
+                .path
+                .try_into()
+                .unwrap_or_else(|_| panic!("Incorrect RawUri for path {}", routeinfo.path)),
+            handler: routeinfo.handler,
+            rank,
+            format: routeinfo.format,
+        }
+    }
+}
+
+/// Alias for using a &'a str for Uri
+
+#[derive(Debug, Clone)]
+/// A basic Body type for respones
+pub struct Body {
+    /// The Response body
+    body: Vec<u8>,
+    /// The Mime Type
+    mime_type: Mime,
+}
+
+impl Body {
+    /// New body of a Response
+    pub fn new(body: Vec<u8>, mime_type: Mime) -> Self {
+        Self { body, mime_type }
+    }
+    /// Sets the `mime_type` of the Body
+    pub fn set_mime_type(&mut self, mime_type: Mime) {
+        self.mime_type = mime_type;
+    }
+    /// Reassigns the body
+    pub fn set_body(&mut self, body: Vec<u8>) {
+        self.body = body;
+    }
+    /// mime_type of the body
+    pub fn mime_type(&self) -> Mime {
+        self.mime_type
+    }
+    /// cloned body as [`Vec<u8>`]
+    pub fn body(&self) -> Vec<u8> {
+        self.body.clone()
+    }
+}
+
+#[derive(Debug, Clone)]
+/// Data of the Body of a [Request]
+pub struct Data {
+    /// The Data
+    pub buffer: Vec<u8>,
+    /// For Split Data if it is complete
+    pub is_complete: bool,
+}
+
+impl Data {
+    /// Checks if the buffer.oen() is -0
+    pub fn is_empty(&self) -> bool {
+        self.buffer.len() == 0
+    }
+}

core/http/src/lib.rs

-pub fn add(left: usize, right: usize) -> usize {
-    left + right
-}
+pub mod handlers;
+pub mod handling;
+mod setup;
+
+pub mod utils;
 
 #[cfg(test)]
-mod tests {
-    use super::*;
+mod tests {}
 
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
-    }
-}
+pub use setup::build;

core/http/src/setup.rs

+use std::thread::available_parallelism;
+
+use tokio::{
+    net::TcpListener,
+    select,
+    signal::unix::{signal, SignalKind, Signal},
+};
+
+#[cfg(feature = "secure")]
+use tokio_native_tls::{native_tls::{Identity, self}, TlsAcceptor};
+
+use crate::{
+    handlers::handler::handle_connection,
+    handling::routes::Route, utils::url_utils::Uri,
+};
+#[cfg(feature = "secure")]
+use crate::handling::response::{Response, Status};
+
+
+#[derive(Clone)]
+/// Represnts a [MountPoint] that can be mounted in the config
+pub struct MountPoint {
+    /// The prefix of the [MountPoint]
+    pub mountpoint: Uri,
+    /// All Routes mounted on the [MountPoint]. The Routes are all prefixed by the mountpoints
+    /// mountpoint
+    pub routes: Vec<Route>,
+}
+
+/// A server configuration that is run
+pub struct Config {
+    /// Contains an Optional [`Vec<MountPoint>`]. which contains all [MountPoint]s on the Server.
+    /// Which contain all the [Route]s
+    mountpoints: Option<Vec<MountPoint>>,
+    /// Contains a [tokio::net::TcpListener] that is bound for the server
+    address: TcpListener,
+    #[cfg(feature = "secure")]
+    to_secure_redirect: TcpListener,
+    #[cfg(feature = "secure")]
+    tls_acceptor: TlsAcceptor,
+}
+
+
+impl<'a> Config {
+    /// Utility that checks if the given mointpoint is already taken. takes in the uri of the to be
+    /// mounted mountpoint
+    fn check_mountpoint_taken(&self, to_insert: &Uri) -> bool {
+        if let Some(to_check) = &self.mountpoints {
+            for i in to_check.iter() {
+                if i.mountpoint == *to_insert {
+                    return true; // Found a duplicate &str
+                }
+            }
+        };
+        false
+    }
+    /// mounts a [MountPoint] on the [Config] takes in a blank [MountPoint] and the [Route]s to be
+    /// mounted, mounts them and inserts the new [MountPoint]. Also sorts by rank.
+    pub fn mount(mut self, mountpoint: Uri, mut routes: Vec<Route>) -> Self {
+        if self.check_mountpoint_taken(&mountpoint) {
+            eprintln!("\x1b[31mTrying to reassign a mountpoint, mountpoint `{}` already taken.\x1b[0m", mountpoint);
+            return self;
+        }
+        routes.sort_by(|a, b| a.rank.cmp(&b.rank));
+        let mut mount_message = format!("  >> \x1b[35m{}\x1b[0m\n", mountpoint.to_pretty_print_string());
+        for (index, route) in routes.iter().enumerate() {
+            let indent_sign = match index {
+                i if i == routes.len() - 1 => "└─",
+                _ => "├─",
+            };
+
+            mount_message += &format!(
+            "     \x1b[35m{indent_sign}\x1b[0m \x1b[36m(\x1b[0m{}\x1b[36m)\x1b[0m \x1b[32m{}\x1b[0m {}\n",
+                route.name.unwrap_or(""),
+                route.method,
+                route.uri.to_pretty_print_string(&mountpoint)
+            )
+        }
+
+        println!("{mount_message}");
+        let mut temp_mountpoints = None;
+        std::mem::swap(&mut self.mountpoints, &mut temp_mountpoints);
+
+        if let Some(mut mountpoints) = temp_mountpoints {
+            mountpoints.push(MountPoint { mountpoint, routes });
+            self.mountpoints = Some(mountpoints);
+        } else {
+            self.mountpoints = Some(vec![MountPoint { mountpoint, routes }]);
+        }
+        self
+    }
+    /// # Launches/Starts the webserver
+    /// Launches a Webserver Configuration
+    ///
+    /// Is Async
+    ///
+    /// Is Blocking -> Can be interrupted with ^C
+    ///
+    /// # Panics
+    /// Panics if there are no Mountpoints in the Confiuration to lauch, as well as when the there
+    /// is no interrupt signal
+    pub async fn launch(self) {
+        {
+            #[cfg(feature = "secure")] {
+                println!(
+                    "Server launched from https://{} and http://{}",
+                    self.address.local_addr().unwrap(), self.to_secure_redirect.local_addr().unwrap()
+                );
+            }
+            #[cfg(not(feature = "secure"))] {
+                println!("Server launched from http://{}", self.address.local_addr().unwrap())
+            }
+        }
+        let mut sigint = signal(SignalKind::interrupt()).unwrap();
+        let location_string = format!("Location: https://{}", self.address.local_addr().unwrap());
+        loop {
+            if !self.selector(&mut sigint, &location_string).await {
+                break;
+            }
+        }
+    }
+    #[cfg(feature = "secure")]
+    async fn selector(&self, sigint: &mut Signal, location_string: &str) -> bool{
+        select! {
+            _ = sigint.recv() => {
+                println!("Shutting down...");
+                return false;
+            }
+            Ok((socket, _)) = self.address.accept() => {
+                let mountpoints = self.mountpoints.clone().unwrap();
+                let Ok(socket) = self.tls_acceptor.accept(socket).await else { 
+                    eprintln!("\x1b[31mClient used http, not https\x1b[0m");
+                    return true;
+                };
+                tokio::spawn(async move { handle_connection(socket, mountpoints).await; });
+            }
+            Ok((socket, _)) = self.to_secure_redirect.accept() => {
+                let redirect_response = Response {
+                    headers: vec![location_string.to_string()],
+                    cookies: None,
+                    status: Some(Status::MovedPermanently),
+                    body: Box::new(""),
+                };
+                tokio::spawn(async move { let _ = redirect_response.write(socket, None).await; });
+            }
+        }
+        true
+    }
+    #[cfg(not(feature = "secure"))]
+    async fn selector(&self, sigint: &mut Signal, _location_string: &str) -> bool {
+        select! {
+            _ = sigint.recv() => {
+                println!("Shutting down...");
+                return false;
+            }
+            Ok((socket, _)) = self.address.accept() => {
+                let mountpoints = self.mountpoints.clone().unwrap();
+                tokio::spawn(async move { handle_connection(socket, mountpoints).await; });
+            }
+        }
+        true
+    }
+
+}
+
+/// # Creates a Webserver Config which can be launched with the launch function
+/// Takes the IP and Port as an argument
+///
+/// Prints out the configuration test
+///
+/// Is async
+///
+/// # Example
+/// ```
+/// async fn example() {
+///     let _ = http::build("127.0.0.1:8443", "127.0.0.1:8080");
+/// }
+/// ```
+/// # Panics
+/// Panics if the IP is not bindable, or other forms of system errors or it's not a valid
+/// IP-Address
+#[cfg(feature = "secure")]
+pub async fn build(ip: &str, ip_http: &str) -> Config {
+    let Ok(listener) = TcpListener::bind(ip).await  else {
+        panic!("\x1b[31mCould't bind Listener to address\x1b[0m");
+    };
+    let ip_vec = ip.splitn(2, ':').collect::<Vec<&str>>();
+    if ip_vec.len() != 2 {
+        panic!("Invalid IP Address");
+    }
+    let Ok(listener_http) = TcpListener::bind(ip_http).await  else {
+        panic!("\x1b[31mCould't bind Listener to address\x1b[0m");
+    };
+    let identity = Identity::from_pkcs12(include_bytes!("certificates/identity.pfx"), "1234").unwrap();
+
+    let port = ip_vec[1];
+    let ip = ip_vec[0];
+    let workers = available_parallelism().unwrap().get();
+    println!(
+"\x1b[34m⚙ Configuration\x1b[0m
+  >> \x1b[34mIp\x1b[0m: {ip}
+  >> \x1b[34mPort\x1b[0m: {port}
+  >> \x1b[34mWorkers\x1b[0m: {workers}
+\x1b[32m Security\x1b[0m
+  >> \x1b[32mHttp to Https Redirect: http://{ip_http} -> https://{ip}:{port}\x1b[0m
+\x1b[35m🛪 Mountpoints\x1b[0m"
+    );
+    Config {
+        mountpoints: None,
+        address: listener,
+        to_secure_redirect: listener_http,
+        tls_acceptor: native_tls::TlsAcceptor::builder(identity).build().unwrap().into()
+    }
+}
+#[cfg(not(feature = "secure"))]
+pub async fn build(ip: &str) -> Config {
+    let Ok(listener) = TcpListener::bind(ip).await  else {
+        panic!("\x1b[31mCould't bind Listener to address\x1b[0m");
+    };
+    let ip_vec = ip.splitn(2, ':').collect::<Vec<&str>>();
+    if ip_vec.len() != 2 {
+        panic!("Invalid IP Address");
+    }
+    let port = ip_vec[1];
+    let ip = ip_vec[0];
+    let workers = available_parallelism().unwrap().get();
+    println!(
+"\x1b[34m⚙ Configuration\x1b[0m
+  >> \x1b[34mIp\x1b[0m: {ip}
+  >> \x1b[34mPort\x1b[0m: {port}
+  >> \x1b[34mWorkers\x1b[0m: {workers}
+\x1b[35m🛪 Mountpoints\x1b[0m"
+    );
+    Config {
+        mountpoints: None,
+        address: listener,
+    }
+}

core/http/src/utils/mime/map.rs

+use super::mime_enum::Mime;
+
+/// Map with the string version of the Mime types and the values being corresponding [Mime]s
+pub static MIME_MAP: phf::Map<&'static str, Mime> = phf::phf_map! {
+    "application/1d-interleaved-parityfec" => Mime::Application1dInterleavedParityfec,
+    "application/3gpdash-qoe-report+xml" => Mime::Application3gpdashQoeReportXml,
+    "application/3gppHal+json" => Mime::Application3gpphalJson,
+    "application/3gppHalForms+json" => Mime::Application3gpphalformsJson,
+    "application/3gpp-ims+xml" => Mime::Application3gppImsXml,
+    "application/A2L" => Mime::ApplicationA2l,
+    "application/ace+cbor" => Mime::ApplicationAceCbor,
+    "application/ace+json" => Mime::ApplicationAceJson,
+    "application/activemessage" => Mime::ApplicationActivemessage,
+    "application/activity+json" => Mime::ApplicationActivityJson,
+    "application/aif+cbor" => Mime::ApplicationAifCbor,
+    "application/aif+json" => Mime::ApplicationAifJson,
+    "application/alto-cdni+json" => Mime::ApplicationAltoCdniJson,
+    "application/alto-cdnifilter+json" => Mime::ApplicationAltoCdnifilterJson,
+    "application/alto-costmap+json" => Mime::ApplicationAltoCostmapJson,
+    "application/alto-costmapfilter+json" => Mime::ApplicationAltoCostmapfilterJson,
+    "application/alto-directory+json" => Mime::ApplicationAltoDirectoryJson,
+    "application/alto-endpointprop+json" => Mime::ApplicationAltoEndpointpropJson,
+    "application/alto-endpointpropparams+json" => Mime::ApplicationAltoEndpointpropparamsJson,
+    "application/alto-endpointcost+json" => Mime::ApplicationAltoEndpointcostJson,
+    "application/alto-endpointcostparams+json" => Mime::ApplicationAltoEndpointcostparamsJson,
+    "application/alto-error+json" => Mime::ApplicationAltoErrorJson,
+    "application/alto-networkmapfilter+json" => Mime::ApplicationAltoNetworkmapfilterJson,
+    "application/alto-networkmap+json" => Mime::ApplicationAltoNetworkmapJson,
+    "application/alto-propmap+json" => Mime::ApplicationAltoPropmapJson,
+    "application/alto-propmapparams+json" => Mime::ApplicationAltoPropmapparamsJson,
+    "application/alto-updatestreamcontrol+json" => Mime::ApplicationAltoUpdatestreamcontrolJson,
+    "application/alto-updatestreamparams+json" => Mime::ApplicationAltoUpdatestreamparamsJson,
+    "application/AML" => Mime::ApplicationAml,
+    "application/andrew-inset" => Mime::ApplicationAndrewInset,
+    "application/applefile" => Mime::ApplicationApplefile,
+    "application/at+jwt" => Mime::ApplicationAtJwt,
+    "application/ATF" => Mime::ApplicationAtf,
+    "application/ATFX" => Mime::ApplicationAtfx,
+    "application/atom+xml" => Mime::ApplicationAtomXml,
+    "application/atomcat+xml" => Mime::ApplicationAtomcatXml,
+    "application/atomdeleted+xml" => Mime::ApplicationAtomdeletedXml,
+    "application/atomicmail" => Mime::ApplicationAtomicmail,
+    "application/atomsvc+xml" => Mime::ApplicationAtomsvcXml,
+    "application/atsc-dwd+xml" => Mime::ApplicationAtscDwdXml,
+    "application/atsc-dynamic-event-message" => Mime::ApplicationAtscDynamicEventMessage,
+    "application/atsc-held+xml" => Mime::ApplicationAtscHeldXml,
+    "application/atsc-rdt+json" => Mime::ApplicationAtscRdtJson,
+    "application/atsc-rsat+xml" => Mime::ApplicationAtscRsatXml,
+    "application/ATXML" => Mime::ApplicationAtxml,
+    "application/auth-policy+xml" => Mime::ApplicationAuthPolicyXml,
+    "application/automationml-aml+xml" => Mime::ApplicationAutomationmlAmlXml,
+    "application/automationml-amlx+zip" => Mime::ApplicationAutomationmlAmlxZip,
+    "application/bacnet-xdd+zip" => Mime::ApplicationBacnetXddZip,
+    "application/batch-SMTP" => Mime::ApplicationBatchSmtp,
+    "application/beep+xml" => Mime::ApplicationBeepXml,
+    "application/calendar+json" => Mime::ApplicationCalendarJson,
+    "application/calendar+xml" => Mime::ApplicationCalendarXml,
+    "application/call-completion" => Mime::ApplicationCallCompletion,
+    "application/CALS-1840" => Mime::ApplicationCals1840,
+    "application/captive+json" => Mime::ApplicationCaptiveJson,
+    "application/cbor" => Mime::ApplicationCbor,
+    "application/cbor-seq" => Mime::ApplicationCborSeq,
+    "application/cccex" => Mime::ApplicationCccex,
+    "application/ccmp+xml" => Mime::ApplicationCcmpXml,
+    "application/ccxml+xml" => Mime::ApplicationCcxmlXml,
+    "application/cda+xml" => Mime::ApplicationCdaXml,
+    "application/CDFX+XML" => Mime::ApplicationCdfxXml,
+    "application/cdmi-capability" => Mime::ApplicationCdmiCapability,
+    "application/cdmi-container" => Mime::ApplicationCdmiContainer,
+    "application/cdmi-domain" => Mime::ApplicationCdmiDomain,
+    "application/cdmi-object" => Mime::ApplicationCdmiObject,
+    "application/cdmi-queue" => Mime::ApplicationCdmiQueue,
+    "application/cdni" => Mime::ApplicationCdni,
+    "application/CEA" => Mime::ApplicationCea,
+    "application/cea-2018+xml" => Mime::ApplicationCea2018Xml,
+    "application/cellml+xml" => Mime::ApplicationCellmlXml,
+    "application/cfw" => Mime::ApplicationCfw,
+    "application/city+json" => Mime::ApplicationCityJson,
+    "application/clr" => Mime::ApplicationClr,
+    "application/clue_info+xml" => Mime::ApplicationClueInfoXml,
+    "application/clue+xml" => Mime::ApplicationClueXml,
+    "application/cms" => Mime::ApplicationCms,
+    "application/cnrp+xml" => Mime::ApplicationCnrpXml,
+    "application/coap-group+json" => Mime::ApplicationCoapGroupJson,
+    "application/coap-payload" => Mime::ApplicationCoapPayload,
+    "application/commonground" => Mime::ApplicationCommonground,
+    "application/concise-problem-details+cbor" => Mime::ApplicationConciseProblemDetailsCbor,
+    "application/conference-info+xml" => Mime::ApplicationConferenceInfoXml,
+    "application/cpl+xml" => Mime::ApplicationCplXml,
+    "application/cose" => Mime::ApplicationCose,
+    "application/cose-key" => Mime::ApplicationCoseKey,
+    "application/cose-key-set" => Mime::ApplicationCoseKeySet,
+    "application/cose-x509" => Mime::ApplicationCoseX509,
+    "application/csrattrs" => Mime::ApplicationCsrattrs,
+    "application/csta+xml" => Mime::ApplicationCstaXml,
+    "application/CSTAdata+xml" => Mime::ApplicationCstadataXml,
+    "application/csvm+json" => Mime::ApplicationCsvmJson,
+    "application/cwl" => Mime::ApplicationCwl,
+    "application/cwl+json" => Mime::ApplicationCwlJson,
+    "application/cwt" => Mime::ApplicationCwt,
+    "application/cybercash" => Mime::ApplicationCybercash,
+    "application/dash+xml" => Mime::ApplicationDashXml,
+    "application/dash-patch+xml" => Mime::ApplicationDashPatchXml,
+    "application/dashdelta" => Mime::ApplicationDashdelta,
+    "application/davmount+xml" => Mime::ApplicationDavmountXml,
+    "application/dca-rft" => Mime::ApplicationDcaRft,
+    "application/DCD" => Mime::ApplicationDcd,
+    "application/dec-dx" => Mime::ApplicationDecDx,
+    "application/dialog-info+xml" => Mime::ApplicationDialogInfoXml,
+    "application/dicom" => Mime::ApplicationDicom,
+    "application/dicom+json" => Mime::ApplicationDicomJson,
+    "application/dicom+xml" => Mime::ApplicationDicomXml,
+    "application/DII" => Mime::ApplicationDii,
+    "application/DIT" => Mime::ApplicationDit,
+    "application/dns" => Mime::ApplicationDns,
+    "application/dns+json" => Mime::ApplicationDnsJson,
+    "application/dns-message" => Mime::ApplicationDnsMessage,
+    "application/dots+cbor" => Mime::ApplicationDotsCbor,
+    "application/dpop+jwt" => Mime::ApplicationDpopJwt,
+    "application/dskpp+xml" => Mime::ApplicationDskppXml,
+    "application/dssc+der" => Mime::ApplicationDsscDer,
+    "application/dssc+xml" => Mime::ApplicationDsscXml,
+    "application/dvcs" => Mime::ApplicationDvcs,
+    "application/EDI-consent" => Mime::ApplicationEdiConsent,
+    "application/EDIFACT" => Mime::ApplicationEdifact,
+    "application/EDI-X12" => Mime::ApplicationEdiX12,
+    "application/efi" => Mime::ApplicationEfi,
+    "application/elm+json" => Mime::ApplicationElmJson,
+    "application/elm+xml" => Mime::ApplicationElmXml,
+    "application/EmergencyCallData.cap+xml" => Mime::ApplicationEmergencycalldataCapXml,
+    "application/EmergencyCallData.Comment+xml" => Mime::ApplicationEmergencycalldataCommentXml,
+    "application/EmergencyCallData.Control+xml" => Mime::ApplicationEmergencycalldataControlXml,
+    "application/EmergencyCallData.DeviceInfo+xml" => Mime::ApplicationEmergencycalldataDeviceinfoXml,
+    "application/EmergencyCallData.eCall.MSD" => Mime::ApplicationEmergencycalldataEcallMsd,
+    "application/EmergencyCallData.LegacyESN+json" => Mime::ApplicationEmergencycalldataLegacyesnJson,
+    "application/EmergencyCallData.ProviderInfo+xml" => Mime::ApplicationEmergencycalldataProviderinfoXml,
+    "application/EmergencyCallData.ServiceInfo+xml" => Mime::ApplicationEmergencycalldataServiceinfoXml,
+    "application/EmergencyCallData.SubscriberInfo+xml" => Mime::ApplicationEmergencycalldataSubscriberinfoXml,
+    "application/EmergencyCallData.VEDS+xml" => Mime::ApplicationEmergencycalldataVedsXml,
+    "application/emma+xml" => Mime::ApplicationEmmaXml,
+    "application/emotionml+xml" => Mime::ApplicationEmotionmlXml,
+    "application/encaprtp" => Mime::ApplicationEncaprtp,
+    "application/epp+xml" => Mime::ApplicationEppXml,
+    "application/epub+zip" => Mime::ApplicationEpubZip,
+    "application/eshop" => Mime::ApplicationEshop,
+    "application/example" => Mime::ApplicationExample,
+    "application/exi" => Mime::ApplicationExi,
+    "application/expect-ct-report+json" => Mime::ApplicationExpectCtReportJson,
+    "application/express" => Mime::ApplicationExpress,
+    "application/fastinfoset" => Mime::ApplicationFastinfoset,
+    "application/fastsoap" => Mime::ApplicationFastsoap,
+    "application/fdf" => Mime::ApplicationFdf,
+    "application/fdt+xml" => Mime::ApplicationFdtXml,
+    "application/fhir+json" => Mime::ApplicationFhirJson,
+    "application/fhir+xml" => Mime::ApplicationFhirXml,
+    "application/fits" => Mime::ApplicationFits,
+    "application/flexfec" => Mime::ApplicationFlexfec,
+    "application/font-tdpfr" => Mime::ApplicationFontTdpfr,
+    "application/framework-attributes+xml" => Mime::ApplicationFrameworkAttributesXml,
+    "application/geo+json" => Mime::ApplicationGeoJson,
+    "application/geo+json-seq" => Mime::ApplicationGeoJsonSeq,
+    "application/geopackage+sqlite3" => Mime::ApplicationGeopackageSqlite3,
+    "application/geoxacml+xml" => Mime::ApplicationGeoxacmlXml,
+    "application/gltf-buffer" => Mime::ApplicationGltfBuffer,
+    "application/gml+xml" => Mime::ApplicationGmlXml,
+    "application/gzip" => Mime::ApplicationGzip,
+    "application/H224" => Mime::ApplicationH224,
+    "application/held+xml" => Mime::ApplicationHeldXml,
+    "application/hl7v2+xml" => Mime::ApplicationHl7v2Xml,
+    "application/http" => Mime::ApplicationHttp,
+    "application/hyperstudio" => Mime::ApplicationHyperstudio,
+    "application/ibe-key-request+xml" => Mime::ApplicationIbeKeyRequestXml,
+    "application/ibe-pkg-reply+xml" => Mime::ApplicationIbePkgReplyXml,
+    "application/ibe-pp-data" => Mime::ApplicationIbePpData,
+    "application/iges" => Mime::ApplicationIges,
+    "application/im-iscomposing+xml" => Mime::ApplicationImIscomposingXml,
+    "application/index" => Mime::ApplicationIndex,
+    "application/index.cmd" => Mime::ApplicationIndexCmd,
+    "application/index.obj" => Mime::ApplicationIndexObj,
+    "application/index.response" => Mime::ApplicationIndexResponse,
+    "application/index.vnd" => Mime::ApplicationIndexVnd,
+    "application/inkml+xml" => Mime::ApplicationInkmlXml,
+    "application/IOTP" => Mime::ApplicationIotp,
+    "application/ipfix" => Mime::ApplicationIpfix,
+    "application/ipp" => Mime::ApplicationIpp,
+    "application/ISUP" => Mime::ApplicationIsup,
+    "application/its+xml" => Mime::ApplicationItsXml,
+    "application/java-archive" => Mime::ApplicationJavaArchive,
+    "application/jf2feed+json" => Mime::ApplicationJf2feedJson,
+    "application/jose" => Mime::ApplicationJose,
+    "application/jose+json" => Mime::ApplicationJoseJson,
+    "application/jrd+json" => Mime::ApplicationJrdJson,
+    "application/jscalendar+json" => Mime::ApplicationJscalendarJson,
+    "application/json" => Mime::ApplicationJson,
+    "application/json-patch+json" => Mime::ApplicationJsonPatchJson,
+    "application/json-seq" => Mime::ApplicationJsonSeq,
+    "application/jwk+json" => Mime::ApplicationJwkJson,
+    "application/jwk-set+json" => Mime::ApplicationJwkSetJson,
+    "application/jwt" => Mime::ApplicationJwt,
+    "application/kpml-request+xml" => Mime::ApplicationKpmlRequestXml,
+    "application/kpml-response+xml" => Mime::ApplicationKpmlResponseXml,
+    "application/ld+json" => Mime::ApplicationLdJson,
+    "application/lgr+xml" => Mime::ApplicationLgrXml,
+    "application/link-format" => Mime::ApplicationLinkFormat,
+    "application/linkset" => Mime::ApplicationLinkset,
+    "application/linkset+json" => Mime::ApplicationLinksetJson,
+    "application/load-control+xml" => Mime::ApplicationLoadControlXml,
+    "application/logout+jwt" => Mime::ApplicationLogoutJwt,
+    "application/lost+xml" => Mime::ApplicationLostXml,
+    "application/lostsync+xml" => Mime::ApplicationLostsyncXml,
+    "application/lpf+zip" => Mime::ApplicationLpfZip,
+    "application/LXF" => Mime::ApplicationLxf,
+    "application/mac-binhex40" => Mime::ApplicationMacBinhex40,
+    "application/macwriteii" => Mime::ApplicationMacwriteii,
+    "application/mads+xml" => Mime::ApplicationMadsXml,
+    "application/manifest+json" => Mime::ApplicationManifestJson,
+    "application/marc" => Mime::ApplicationMarc,
+    "application/marcxml+xml" => Mime::ApplicationMarcxmlXml,
+    "application/mathematica" => Mime::ApplicationMathematica,
+    "application/mathml+xml" => Mime::ApplicationMathmlXml,
+    "application/mathml-content+xml" => Mime::ApplicationMathmlContentXml,
+    "application/mathml-presentation+xml" => Mime::ApplicationMathmlPresentationXml,
+    "application/mbms-associated-procedure-description+xml" => Mime::ApplicationMbmsAssociatedProcedureDescriptionXml,
+    "application/mbms-deregister+xml" => Mime::ApplicationMbmsDeregisterXml,
+    "application/mbms-envelope+xml" => Mime::ApplicationMbmsEnvelopeXml,
+    "application/mbms-msk-response+xml" => Mime::ApplicationMbmsMskResponseXml,
+    "application/mbms-msk+xml" => Mime::ApplicationMbmsMskXml,
+    "application/mbms-protection-description+xml" => Mime::ApplicationMbmsProtectionDescriptionXml,
+    "application/mbms-reception-report+xml" => Mime::ApplicationMbmsReceptionReportXml,
+    "application/mbms-register-response+xml" => Mime::ApplicationMbmsRegisterResponseXml,
+    "application/mbms-register+xml" => Mime::ApplicationMbmsRegisterXml,
+    "application/mbms-schedule+xml" => Mime::ApplicationMbmsScheduleXml,
+    "application/mbms-user-service-description+xml" => Mime::ApplicationMbmsUserServiceDescriptionXml,
+    "application/mbox" => Mime::ApplicationMbox,
+    "application/media_control+xml" => Mime::ApplicationMediaControlXml,
+    "application/media-policy-dataset+xml" => Mime::ApplicationMediaPolicyDatasetXml,
+    "application/mediaservercontrol+xml" => Mime::ApplicationMediaservercontrolXml,
+    "application/merge-patch+json" => Mime::ApplicationMergePatchJson,
+    "application/metalink4+xml" => Mime::ApplicationMetalink4Xml,
+    "application/mets+xml" => Mime::ApplicationMetsXml,
+    "application/MF4" => Mime::ApplicationMf4,
+    "application/mikey" => Mime::ApplicationMikey,
+    "application/mipc" => Mime::ApplicationMipc,
+    "application/missing-blocks+cbor-seq" => Mime::ApplicationMissingBlocksCborSeq,
+    "application/mmt-aei+xml" => Mime::ApplicationMmtAeiXml,
+    "application/mmt-usd+xml" => Mime::ApplicationMmtUsdXml,
+    "application/mods+xml" => Mime::ApplicationModsXml,
+    "application/moss-keys" => Mime::ApplicationMossKeys,
+    "application/moss-signature" => Mime::ApplicationMossSignature,
+    "application/mosskey-data" => Mime::ApplicationMosskeyData,
+    "application/mosskey-request" => Mime::ApplicationMosskeyRequest,
+    "application/mp21" => Mime::ApplicationMp21,
+    "application/mp4" => Mime::ApplicationMp4,
+    "application/mpeg4-generic" => Mime::ApplicationMpeg4Generic,
+    "application/mpeg4-iod" => Mime::ApplicationMpeg4Iod,
+    "application/mpeg4-iod-xmt" => Mime::ApplicationMpeg4IodXmt,
+    "application/mrb-consumer+xml" => Mime::ApplicationMrbConsumerXml,
+    "application/mrb-publish+xml" => Mime::ApplicationMrbPublishXml,
+    "application/msc-ivr+xml" => Mime::ApplicationMscIvrXml,
+    "application/msc-mixer+xml" => Mime::ApplicationMscMixerXml,
+    "application/msword" => Mime::ApplicationMsword,
+    "application/mud+json" => Mime::ApplicationMudJson,
+    "application/multipart-core" => Mime::ApplicationMultipartCore,
+    "application/mxf" => Mime::ApplicationMxf,
+    "application/n-quads" => Mime::ApplicationNQuads,
+    "application/n-triples" => Mime::ApplicationNTriples,
+    "application/nasdata" => Mime::ApplicationNasdata,
+    "application/news-checkgroups" => Mime::ApplicationNewsCheckgroups,
+    "application/news-groupinfo" => Mime::ApplicationNewsGroupinfo,
+    "application/news-transmission" => Mime::ApplicationNewsTransmission,
+    "application/nlsml+xml" => Mime::ApplicationNlsmlXml,
+    "application/node" => Mime::ApplicationNode,
+    "application/nss" => Mime::ApplicationNss,
+    "application/oauth-authz-req+jwt" => Mime::ApplicationOauthAuthzReqJwt,
+    "application/oblivious-dns-message" => Mime::ApplicationObliviousDnsMessage,
+    "application/ocsp-request" => Mime::ApplicationOcspRequest,
+    "application/ocsp-response" => Mime::ApplicationOcspResponse,
+    "application/octet-stream" => Mime::ApplicationOctetStream,
+    "application/ODA" => Mime::ApplicationOda,
+    "application/odm+xml" => Mime::ApplicationOdmXml,
+    "application/ODX" => Mime::ApplicationOdx,
+    "application/oebps-package+xml" => Mime::ApplicationOebpsPackageXml,
+    "application/ogg" => Mime::ApplicationOgg,
+    "application/ohttp-keys" => Mime::ApplicationOhttpKeys,
+    "application/opc-nodeset+xml" => Mime::ApplicationOpcNodesetXml,
+    "application/oscore" => Mime::ApplicationOscore,
+    "application/oxps" => Mime::ApplicationOxps,
+    "application/p21" => Mime::ApplicationP21,
+    "application/p21+zip" => Mime::ApplicationP21Zip,
+    "application/p2p-overlay+xml" => Mime::ApplicationP2pOverlayXml,
+    "application/parityfec" => Mime::ApplicationParityfec,
+    "application/passport" => Mime::ApplicationPassport,
+    "application/patch-ops-error+xml" => Mime::ApplicationPatchOpsErrorXml,
+    "application/pdf" => Mime::ApplicationPdf,
+    "application/PDX" => Mime::ApplicationPdx,
+    "application/pem-certificate-chain" => Mime::ApplicationPemCertificateChain,
+    "application/pgp-encrypted" => Mime::ApplicationPgpEncrypted,
+    "application/pgp-keys" => Mime::ApplicationPgpKeys,
+    "application/pgp-signature" => Mime::ApplicationPgpSignature,
+    "application/pidf-diff+xml" => Mime::ApplicationPidfDiffXml,
+    "application/pidf+xml" => Mime::ApplicationPidfXml,
+    "application/pkcs10" => Mime::ApplicationPkcs10,
+    "application/pkcs7-mime" => Mime::ApplicationPkcs7Mime,
+    "application/pkcs7-signature" => Mime::ApplicationPkcs7Signature,
+    "application/pkcs8" => Mime::ApplicationPkcs8,
+    "application/pkcs8-encrypted" => Mime::ApplicationPkcs8Encrypted,
+    "application/pkcs12" => Mime::ApplicationPkcs12,
+    "application/pkix-attr-cert" => Mime::ApplicationPkixAttrCert,
+    "application/pkix-cert" => Mime::ApplicationPkixCert,
+    "application/pkix-crl" => Mime::ApplicationPkixCrl,
+    "application/pkix-pkipath" => Mime::ApplicationPkixPkipath,
+    "application/pkixcmp" => Mime::ApplicationPkixcmp,
+    "application/pls+xml" => Mime::ApplicationPlsXml,
+    "application/poc-settings+xml" => Mime::ApplicationPocSettingsXml,
+    "application/postscript" => Mime::ApplicationPostscript,
+    "application/ppsp-tracker+json" => Mime::ApplicationPpspTrackerJson,
+    "application/problem+json" => Mime::ApplicationProblemJson,
+    "application/problem+xml" => Mime::ApplicationProblemXml,
+    "application/provenance+xml" => Mime::ApplicationProvenanceXml,
+    "application/prs.alvestrand.titrax-sheet" => Mime::ApplicationPrsAlvestrandTitraxSheet,
+    "application/prs.cww" => Mime::ApplicationPrsCww,
+    "application/prs.cyn" => Mime::ApplicationPrsCyn,
+    "application/prs.hpub+zip" => Mime::ApplicationPrsHpubZip,
+    "application/prs.implied-document+xml" => Mime::ApplicationPrsImpliedDocumentXml,
+    "application/prs.implied-executable" => Mime::ApplicationPrsImpliedExecutable,
+    "application/prs.implied-structure" => Mime::ApplicationPrsImpliedStructure,
+    "application/prs.nprend" => Mime::ApplicationPrsNprend,
+    "application/prs.plucker" => Mime::ApplicationPrsPlucker,
+    "application/prs.rdf-xml-crypt" => Mime::ApplicationPrsRdfXmlCrypt,
+    "application/prs.xsf+xml" => Mime::ApplicationPrsXsfXml,
+    "application/pskc+xml" => Mime::ApplicationPskcXml,
+    "application/pvd+json" => Mime::ApplicationPvdJson,
+    "application/rdf+xml" => Mime::ApplicationRdfXml,
+    "application/route-apd+xml" => Mime::ApplicationRouteApdXml,
+    "application/route-s-tsid+xml" => Mime::ApplicationRouteSTsidXml,
+    "application/route-usd+xml" => Mime::ApplicationRouteUsdXml,
+    "application/QSIG" => Mime::ApplicationQsig,
+    "application/raptorfec" => Mime::ApplicationRaptorfec,
+    "application/rdap+json" => Mime::ApplicationRdapJson,
+    "application/reginfo+xml" => Mime::ApplicationReginfoXml,
+    "application/relax-ng-compact-syntax" => Mime::ApplicationRelaxNgCompactSyntax,
+    "application/reputon+json" => Mime::ApplicationReputonJson,
+    "application/resource-lists-diff+xml" => Mime::ApplicationResourceListsDiffXml,
+    "application/resource-lists+xml" => Mime::ApplicationResourceListsXml,
+    "application/rfc+xml" => Mime::ApplicationRfcXml,
+    "application/riscos" => Mime::ApplicationRiscos,
+    "application/rlmi+xml" => Mime::ApplicationRlmiXml,
+    "application/rls-services+xml" => Mime::ApplicationRlsServicesXml,
+    "application/rpki-checklist" => Mime::ApplicationRpkiChecklist,
+    "application/rpki-ghostbusters" => Mime::ApplicationRpkiGhostbusters,
+    "application/rpki-manifest" => Mime::ApplicationRpkiManifest,
+    "application/rpki-publication" => Mime::ApplicationRpkiPublication,
+    "application/rpki-roa" => Mime::ApplicationRpkiRoa,
+    "application/rpki-updown" => Mime::ApplicationRpkiUpdown,
+    "application/rtf" => Mime::ApplicationRtf,
+    "application/rtploopback" => Mime::ApplicationRtploopback,
+    "application/rtx" => Mime::ApplicationRtx,
+    "application/samlassertion+xml" => Mime::ApplicationSamlassertionXml,
+    "application/samlmetadata+xml" => Mime::ApplicationSamlmetadataXml,
+    "application/sarif-external-properties+json" => Mime::ApplicationSarifExternalPropertiesJson,
+    "application/sarif+json" => Mime::ApplicationSarifJson,
+    "application/sbe" => Mime::ApplicationSbe,
+    "application/sbml+xml" => Mime::ApplicationSbmlXml,
+    "application/scaip+xml" => Mime::ApplicationScaipXml,
+    "application/scim+json" => Mime::ApplicationScimJson,
+    "application/scvp-cv-request" => Mime::ApplicationScvpCvRequest,
+    "application/scvp-cv-response" => Mime::ApplicationScvpCvResponse,
+    "application/scvp-vp-request" => Mime::ApplicationScvpVpRequest,
+    "application/scvp-vp-response" => Mime::ApplicationScvpVpResponse,
+    "application/sdp" => Mime::ApplicationSdp,
+    "application/secevent+jwt" => Mime::ApplicationSeceventJwt,
+    "application/senml-etch+cbor" => Mime::ApplicationSenmlEtchCbor,
+    "application/senml-etch+json" => Mime::ApplicationSenmlEtchJson,
+    "application/senml-exi" => Mime::ApplicationSenmlExi,
+    "application/senml+cbor" => Mime::ApplicationSenmlCbor,
+    "application/senml+json" => Mime::ApplicationSenmlJson,
+    "application/senml+xml" => Mime::ApplicationSenmlXml,
+    "application/sensml-exi" => Mime::ApplicationSensmlExi,
+    "application/sensml+cbor" => Mime::ApplicationSensmlCbor,
+    "application/sensml+json" => Mime::ApplicationSensmlJson,
+    "application/sensml+xml" => Mime::ApplicationSensmlXml,
+    "application/sep-exi" => Mime::ApplicationSepExi,
+    "application/sep+xml" => Mime::ApplicationSepXml,
+    "application/session-info" => Mime::ApplicationSessionInfo,
+    "application/set-payment" => Mime::ApplicationSetPayment,
+    "application/set-payment-initiation" => Mime::ApplicationSetPaymentInitiation,
+    "application/set-registration" => Mime::ApplicationSetRegistration,
+    "application/set-registration-initiation" => Mime::ApplicationSetRegistrationInitiation,
+    "application/SGML" => Mime::ApplicationSgml,
+    "application/sgml-open-catalog" => Mime::ApplicationSgmlOpenCatalog,
+    "application/shf+xml" => Mime::ApplicationShfXml,
+    "application/sieve" => Mime::ApplicationSieve,
+    "application/simple-filter+xml" => Mime::ApplicationSimpleFilterXml,
+    "application/simple-message-summary" => Mime::ApplicationSimpleMessageSummary,
+    "application/simpleSymbolContainer" => Mime::ApplicationSimplesymbolcontainer,
+    "application/sipc" => Mime::ApplicationSipc,
+    "application/slate" => Mime::ApplicationSlate,
+    "application/smil+xml" => Mime::ApplicationSmilXml,
+    "application/smpte336m" => Mime::ApplicationSmpte336m,
+    "application/soap+fastinfoset" => Mime::ApplicationSoapFastinfoset,
+    "application/soap+xml" => Mime::ApplicationSoapXml,
+    "application/sparql-query" => Mime::ApplicationSparqlQuery,
+    "application/spdx+json" => Mime::ApplicationSpdxJson,
+    "application/sparql-results+xml" => Mime::ApplicationSparqlResultsXml,
+    "application/spirits-event+xml" => Mime::ApplicationSpiritsEventXml,
+    "application/sql" => Mime::ApplicationSql,
+    "application/srgs" => Mime::ApplicationSrgs,
+    "application/srgs+xml" => Mime::ApplicationSrgsXml,
+    "application/sru+xml" => Mime::ApplicationSruXml,
+    "application/ssml+xml" => Mime::ApplicationSsmlXml,
+    "application/stix+json" => Mime::ApplicationStixJson,
+    "application/swid+cbor" => Mime::ApplicationSwidCbor,
+    "application/swid+xml" => Mime::ApplicationSwidXml,
+    "application/tamp-apex-update" => Mime::ApplicationTampApexUpdate,
+    "application/tamp-apex-update-confirm" => Mime::ApplicationTampApexUpdateConfirm,
+    "application/tamp-community-update" => Mime::ApplicationTampCommunityUpdate,
+    "application/tamp-community-update-confirm" => Mime::ApplicationTampCommunityUpdateConfirm,
+    "application/tamp-error" => Mime::ApplicationTampError,
+    "application/tamp-sequence-adjust" => Mime::ApplicationTampSequenceAdjust,
+    "application/tamp-sequence-adjust-confirm" => Mime::ApplicationTampSequenceAdjustConfirm,
+    "application/tamp-status-query" => Mime::ApplicationTampStatusQuery,
+    "application/tamp-status-response" => Mime::ApplicationTampStatusResponse,
+    "application/tamp-update" => Mime::ApplicationTampUpdate,
+    "application/tamp-update-confirm" => Mime::ApplicationTampUpdateConfirm,
+    "application/taxii+json" => Mime::ApplicationTaxiiJson,
+    "application/td+json" => Mime::ApplicationTdJson,
+    "application/tei+xml" => Mime::ApplicationTeiXml,
+    "application/TETRA_ISI" => Mime::ApplicationTetraIsi,
+    "application/thraud+xml" => Mime::ApplicationThraudXml,
+    "application/timestamp-query" => Mime::ApplicationTimestampQuery,
+    "application/timestamp-reply" => Mime::ApplicationTimestampReply,
+    "application/timestamped-data" => Mime::ApplicationTimestampedData,
+    "application/tlsrpt+gzip" => Mime::ApplicationTlsrptGzip,
+    "application/tlsrpt+json" => Mime::ApplicationTlsrptJson,
+    "application/tm+json" => Mime::ApplicationTmJson,
+    "application/tnauthlist" => Mime::ApplicationTnauthlist,
+    "application/token-introspection+jwt" => Mime::ApplicationTokenIntrospectionJwt,
+    "application/trickle-ice-sdpfrag" => Mime::ApplicationTrickleIceSdpfrag,
+    "application/trig" => Mime::ApplicationTrig,
+    "application/ttml+xml" => Mime::ApplicationTtmlXml,
+    "application/tve-trigger" => Mime::ApplicationTveTrigger,
+    "application/tzif" => Mime::ApplicationTzif,
+    "application/tzif-leap" => Mime::ApplicationTzifLeap,
+    "application/ulpfec" => Mime::ApplicationUlpfec,
+    "application/urc-grpsheet+xml" => Mime::ApplicationUrcGrpsheetXml,
+    "application/urc-ressheet+xml" => Mime::ApplicationUrcRessheetXml,
+    "application/urc-targetdesc+xml" => Mime::ApplicationUrcTargetdescXml,
+    "application/urc-uisocketdesc+xml" => Mime::ApplicationUrcUisocketdescXml,
+    "application/vcard+json" => Mime::ApplicationVcardJson,
+    "application/vcard+xml" => Mime::ApplicationVcardXml,
+    "application/vemmi" => Mime::ApplicationVemmi,
+    "application/vnd.1000minds.decision-model+xml" => Mime::ApplicationVnd1000mindsDecisionModelXml,
+    "application/vnd.1ob" => Mime::ApplicationVnd1ob,
+    "application/vnd.3gpp.5gnas" => Mime::ApplicationVnd3gpp5gnas,
+    "application/vnd.3gpp.access-transfer-events+xml" => Mime::ApplicationVnd3gppAccessTransferEventsXml,
+    "application/vnd.3gpp.bsf+xml" => Mime::ApplicationVnd3gppBsfXml,
+    "application/vnd.3gpp.crs+xml" => Mime::ApplicationVnd3gppCrsXml,
+    "application/vnd.3gpp.current-location-discovery+xml" => Mime::ApplicationVnd3gppCurrentLocationDiscoveryXml,
+    "application/vnd.3gpp.GMOP+xml" => Mime::ApplicationVnd3gppGmopXml,
+    "application/vnd.3gpp.gtpc" => Mime::ApplicationVnd3gppGtpc,
+    "application/vnd.3gpp.interworking-data" => Mime::ApplicationVnd3gppInterworkingData,
+    "application/vnd.3gpp.lpp" => Mime::ApplicationVnd3gppLpp,
+    "application/vnd.3gpp.mc-signalling-ear" => Mime::ApplicationVnd3gppMcSignallingEar,
+    "application/vnd.3gpp.mcdata-affiliation-command+xml" => Mime::ApplicationVnd3gppMcdataAffiliationCommandXml,
+    "application/vnd.3gpp.mcdata-info+xml" => Mime::ApplicationVnd3gppMcdataInfoXml,
+    "application/vnd.3gpp.mcdata-msgstore-ctrl-request+xml" => Mime::ApplicationVnd3gppMcdataMsgstoreCtrlRequestXml,
+    "application/vnd.3gpp.mcdata-payload" => Mime::ApplicationVnd3gppMcdataPayload,
+    "application/vnd.3gpp.mcdata-regroup+xml" => Mime::ApplicationVnd3gppMcdataRegroupXml,
+    "application/vnd.3gpp.mcdata-service-config+xml" => Mime::ApplicationVnd3gppMcdataServiceConfigXml,
+    "application/vnd.3gpp.mcdata-signalling" => Mime::ApplicationVnd3gppMcdataSignalling,
+    "application/vnd.3gpp.mcdata-ue-config+xml" => Mime::ApplicationVnd3gppMcdataUeConfigXml,
+    "application/vnd.3gpp.mcdata-user-profile+xml" => Mime::ApplicationVnd3gppMcdataUserProfileXml,
+    "application/vnd.3gpp.mcptt-affiliation-command+xml" => Mime::ApplicationVnd3gppMcpttAffiliationCommandXml,
+    "application/vnd.3gpp.mcptt-floor-request+xml" => Mime::ApplicationVnd3gppMcpttFloorRequestXml,
+    "application/vnd.3gpp.mcptt-info+xml" => Mime::ApplicationVnd3gppMcpttInfoXml,
+    "application/vnd.3gpp.mcptt-location-info+xml" => Mime::ApplicationVnd3gppMcpttLocationInfoXml,
+    "application/vnd.3gpp.mcptt-mbms-usage-info+xml" => Mime::ApplicationVnd3gppMcpttMbmsUsageInfoXml,
+    "application/vnd.3gpp.mcptt-regroup+xml" => Mime::ApplicationVnd3gppMcpttRegroupXml,
+    "application/vnd.3gpp.mcptt-service-config+xml" => Mime::ApplicationVnd3gppMcpttServiceConfigXml,
+    "application/vnd.3gpp.mcptt-signed+xml" => Mime::ApplicationVnd3gppMcpttSignedXml,
+    "application/vnd.3gpp.mcptt-ue-config+xml" => Mime::ApplicationVnd3gppMcpttUeConfigXml,
+    "application/vnd.3gpp.mcptt-ue-init-config+xml" => Mime::ApplicationVnd3gppMcpttUeInitConfigXml,
+    "application/vnd.3gpp.mcptt-user-profile+xml" => Mime::ApplicationVnd3gppMcpttUserProfileXml,
+    "application/vnd.3gpp.mcvideo-affiliation-command+xml" => Mime::ApplicationVnd3gppMcvideoAffiliationCommandXml,
+    "application/vnd.3gpp.mcvideo-info+xml" => Mime::ApplicationVnd3gppMcvideoInfoXml,
+    "application/vnd.3gpp.mcvideo-location-info+xml" => Mime::ApplicationVnd3gppMcvideoLocationInfoXml,
+    "application/vnd.3gpp.mcvideo-mbms-usage-info+xml" => Mime::ApplicationVnd3gppMcvideoMbmsUsageInfoXml,
+    "application/vnd.3gpp.mcvideo-regroup+xml" => Mime::ApplicationVnd3gppMcvideoRegroupXml,
+    "application/vnd.3gpp.mcvideo-service-config+xml" => Mime::ApplicationVnd3gppMcvideoServiceConfigXml,
+    "application/vnd.3gpp.mcvideo-transmission-request+xml" => Mime::ApplicationVnd3gppMcvideoTransmissionRequestXml,
+    "application/vnd.3gpp.mcvideo-ue-config+xml" => Mime::ApplicationVnd3gppMcvideoUeConfigXml,
+    "application/vnd.3gpp.mcvideo-user-profile+xml" => Mime::ApplicationVnd3gppMcvideoUserProfileXml,
+    "application/vnd.3gpp.mid-call+xml" => Mime::ApplicationVnd3gppMidCallXml,
+    "application/vnd.3gpp.ngap" => Mime::ApplicationVnd3gppNgap,
+    "application/vnd.3gpp.pfcp" => Mime::ApplicationVnd3gppPfcp,
+    "application/vnd.3gpp.pic-bw-large" => Mime::ApplicationVnd3gppPicBwLarge,
+    "application/vnd.3gpp.pic-bw-small" => Mime::ApplicationVnd3gppPicBwSmall,
+    "application/vnd.3gpp.pic-bw-var" => Mime::ApplicationVnd3gppPicBwVar,
+    "application/vnd.3gpp-prose-pc3a+xml" => Mime::ApplicationVnd3gppProsePc3aXml,
+    "application/vnd.3gpp-prose-pc3ach+xml" => Mime::ApplicationVnd3gppProsePc3achXml,
+    "application/vnd.3gpp-prose-pc3ch+xml" => Mime::ApplicationVnd3gppProsePc3chXml,
+    "application/vnd.3gpp-prose-pc8+xml" => Mime::ApplicationVnd3gppProsePc8Xml,
+    "application/vnd.3gpp-prose+xml" => Mime::ApplicationVnd3gppProseXml,
+    "application/vnd.3gpp.s1ap" => Mime::ApplicationVnd3gppS1ap,
+    "application/vnd.3gpp.seal-group-doc+xml" => Mime::ApplicationVnd3gppSealGroupDocXml,
+    "application/vnd.3gpp.seal-info+xml" => Mime::ApplicationVnd3gppSealInfoXml,
+    "application/vnd.3gpp.seal-location-info+xml" => Mime::ApplicationVnd3gppSealLocationInfoXml,
+    "application/vnd.3gpp.seal-mbms-usage-info+xml" => Mime::ApplicationVnd3gppSealMbmsUsageInfoXml,
+    "application/vnd.3gpp.seal-network-QoS-management-info+xml" => Mime::ApplicationVnd3gppSealNetworkQosManagementInfoXml,
+    "application/vnd.3gpp.seal-ue-config-info+xml" => Mime::ApplicationVnd3gppSealUeConfigInfoXml,
+    "application/vnd.3gpp.seal-unicast-info+xml" => Mime::ApplicationVnd3gppSealUnicastInfoXml,
+    "application/vnd.3gpp.seal-user-profile-info+xml" => Mime::ApplicationVnd3gppSealUserProfileInfoXml,
+    "application/vnd.3gpp.sms" => Mime::ApplicationVnd3gppSms,
+    "application/vnd.3gpp.sms+xml" => Mime::ApplicationVnd3gppSmsXml,
+    "application/vnd.3gpp.srvcc-ext+xml" => Mime::ApplicationVnd3gppSrvccExtXml,
+    "application/vnd.3gpp.SRVCC-info+xml" => Mime::ApplicationVnd3gppSrvccInfoXml,
+    "application/vnd.3gpp.state-and-event-info+xml" => Mime::ApplicationVnd3gppStateAndEventInfoXml,
+    "application/vnd.3gpp.ussd+xml" => Mime::ApplicationVnd3gppUssdXml,
+    "application/vnd.3gpp.vae-info+xml" => Mime::ApplicationVnd3gppVaeInfoXml,
+    "application/vnd.3gpp-v2x-local-service-information" => Mime::ApplicationVnd3gppV2xLocalServiceInformation,
+    "application/vnd.3gpp2.bcmcsinfo+xml" => Mime::ApplicationVnd3gpp2BcmcsinfoXml,
+    "application/vnd.3gpp2.sms" => Mime::ApplicationVnd3gpp2Sms,
+    "application/vnd.3gpp2.tcap" => Mime::ApplicationVnd3gpp2Tcap,
+    "application/vnd.3gpp.v2x" => Mime::ApplicationVnd3gppV2x,
+    "application/vnd.3lightssoftware.imagescal" => Mime::ApplicationVnd3lightssoftwareImagescal,
+    "application/vnd.3M.Post-it-Notes" => Mime::ApplicationVnd3mPostItNotes,
+    "application/vnd.accpac.simply.aso" => Mime::ApplicationVndAccpacSimplyAso,
+    "application/vnd.accpac.simply.imp" => Mime::ApplicationVndAccpacSimplyImp,
+    "application/vnd.acm.addressxfer+json" => Mime::ApplicationVndAcmAddressxferJson,
+    "application/vnd.acucobol" => Mime::ApplicationVndAcucobol,
+    "application/vnd.acucorp" => Mime::ApplicationVndAcucorp,
+    "application/vnd.adobe.flash.movie" => Mime::ApplicationVndAdobeFlashMovie,
+    "application/vnd.adobe.formscentral.fcdt" => Mime::ApplicationVndAdobeFormscentralFcdt,
+    "application/vnd.adobe.fxp" => Mime::ApplicationVndAdobeFxp,
+    "application/vnd.adobe.partial-upload" => Mime::ApplicationVndAdobePartialUpload,
+    "application/vnd.adobe.xdp+xml" => Mime::ApplicationVndAdobeXdpXml,
+    "application/vnd.aether.imp" => Mime::ApplicationVndAetherImp,
+    "application/vnd.afpc.afplinedata" => Mime::ApplicationVndAfpcAfplinedata,
+    "application/vnd.afpc.afplinedata-pagedef" => Mime::ApplicationVndAfpcAfplinedataPagedef,
+    "application/vnd.afpc.cmoca-cmresource" => Mime::ApplicationVndAfpcCmocaCmresource,
+    "application/vnd.afpc.foca-charset" => Mime::ApplicationVndAfpcFocaCharset,
+    "application/vnd.afpc.foca-codedfont" => Mime::ApplicationVndAfpcFocaCodedfont,
+    "application/vnd.afpc.foca-codepage" => Mime::ApplicationVndAfpcFocaCodepage,
+    "application/vnd.afpc.modca" => Mime::ApplicationVndAfpcModca,
+    "application/vnd.afpc.modca-cmtable" => Mime::ApplicationVndAfpcModcaCmtable,
+    "application/vnd.afpc.modca-formdef" => Mime::ApplicationVndAfpcModcaFormdef,
+    "application/vnd.afpc.modca-mediummap" => Mime::ApplicationVndAfpcModcaMediummap,
+    "application/vnd.afpc.modca-objectcontainer" => Mime::ApplicationVndAfpcModcaObjectcontainer,
+    "application/vnd.afpc.modca-overlay" => Mime::ApplicationVndAfpcModcaOverlay,
+    "application/vnd.afpc.modca-pagesegment" => Mime::ApplicationVndAfpcModcaPagesegment,
+    "application/vnd.age" => Mime::ApplicationVndAge,
+    "application/vnd.ah-barcode" => Mime::ApplicationVndAhBarcode,
+    "application/vnd.ahead.space" => Mime::ApplicationVndAheadSpace,
+    "application/vnd.airzip.filesecure.azf" => Mime::ApplicationVndAirzipFilesecureAzf,
+    "application/vnd.airzip.filesecure.azs" => Mime::ApplicationVndAirzipFilesecureAzs,
+    "application/vnd.amadeus+json" => Mime::ApplicationVndAmadeusJson,
+    "application/vnd.amazon.mobi8-ebook" => Mime::ApplicationVndAmazonMobi8Ebook,
+    "application/vnd.americandynamics.acc" => Mime::ApplicationVndAmericandynamicsAcc,
+    "application/vnd.amiga.ami" => Mime::ApplicationVndAmigaAmi,
+    "application/vnd.amundsen.maze+xml" => Mime::ApplicationVndAmundsenMazeXml,
+    "application/vnd.android.ota" => Mime::ApplicationVndAndroidOta,
+    "application/vnd.anki" => Mime::ApplicationVndAnki,
+    "application/vnd.anser-web-certificate-issue-initiation" => Mime::ApplicationVndAnserWebCertificateIssueInitiation,
+    "application/vnd.antix.game-component" => Mime::ApplicationVndAntixGameComponent,
+    "application/vnd.apache.arrow.file" => Mime::ApplicationVndApacheArrowFile,
+    "application/vnd.apache.arrow.stream" => Mime::ApplicationVndApacheArrowStream,
+    "application/vnd.apache.thrift.binary" => Mime::ApplicationVndApacheThriftBinary,
+    "application/vnd.apache.thrift.compact" => Mime::ApplicationVndApacheThriftCompact,
+    "application/vnd.apache.thrift.json" => Mime::ApplicationVndApacheThriftJson,
+    "application/vnd.apexlang" => Mime::ApplicationVndApexlang,
+    "application/vnd.api+json" => Mime::ApplicationVndApiJson,
+    "application/vnd.aplextor.warrp+json" => Mime::ApplicationVndAplextorWarrpJson,
+    "application/vnd.apothekende.reservation+json" => Mime::ApplicationVndApothekendeReservationJson,
+    "application/vnd.apple.installer+xml" => Mime::ApplicationVndAppleInstallerXml,
+    "application/vnd.apple.keynote" => Mime::ApplicationVndAppleKeynote,
+    "application/vnd.apple.mpegurl" => Mime::ApplicationVndAppleMpegurl,
+    "application/vnd.apple.numbers" => Mime::ApplicationVndAppleNumbers,
+    "application/vnd.apple.pages" => Mime::ApplicationVndApplePages,
+    "application/vnd.aristanetworks.swi" => Mime::ApplicationVndAristanetworksSwi,
+    "application/vnd.artisan+json" => Mime::ApplicationVndArtisanJson,
+    "application/vnd.artsquare" => Mime::ApplicationVndArtsquare,
+    "application/vnd.astraea-software.iota" => Mime::ApplicationVndAstraeaSoftwareIota,
+    "application/vnd.audiograph" => Mime::ApplicationVndAudiograph,
+    "application/vnd.autopackage" => Mime::ApplicationVndAutopackage,
+    "application/vnd.avalon+json" => Mime::ApplicationVndAvalonJson,
+    "application/vnd.avistar+xml" => Mime::ApplicationVndAvistarXml,
+    "application/vnd.balsamiq.bmml+xml" => Mime::ApplicationVndBalsamiqBmmlXml,
+    "application/vnd.banana-accounting" => Mime::ApplicationVndBananaAccounting,
+    "application/vnd.bbf.usp.error" => Mime::ApplicationVndBbfUspError,
+    "application/vnd.bbf.usp.msg" => Mime::ApplicationVndBbfUspMsg,
+    "application/vnd.bbf.usp.msg+json" => Mime::ApplicationVndBbfUspMsgJson,
+    "application/vnd.balsamiq.bmpr" => Mime::ApplicationVndBalsamiqBmpr,
+    "application/vnd.bekitzur-stech+json" => Mime::ApplicationVndBekitzurStechJson,
+    "application/vnd.belightsoft.lhzd+zip" => Mime::ApplicationVndBelightsoftLhzdZip,
+    "application/vnd.belightsoft.lhzl+zip" => Mime::ApplicationVndBelightsoftLhzlZip,
+    "application/vnd.bint.med-content" => Mime::ApplicationVndBintMedContent,
+    "application/vnd.biopax.rdf+xml" => Mime::ApplicationVndBiopaxRdfXml,
+    "application/vnd.blink-idb-value-wrapper" => Mime::ApplicationVndBlinkIdbValueWrapper,
+    "application/vnd.blueice.multipass" => Mime::ApplicationVndBlueiceMultipass,
+    "application/vnd.bluetooth.ep.oob" => Mime::ApplicationVndBluetoothEpOob,
+    "application/vnd.bluetooth.le.oob" => Mime::ApplicationVndBluetoothLeOob,
+    "application/vnd.bmi" => Mime::ApplicationVndBmi,
+    "application/vnd.bpf" => Mime::ApplicationVndBpf,
+    "application/vnd.bpf3" => Mime::ApplicationVndBpf3,
+    "application/vnd.businessobjects" => Mime::ApplicationVndBusinessobjects,
+    "application/vnd.byu.uapi+json" => Mime::ApplicationVndByuUapiJson,
+    "application/vnd.cab-jscript" => Mime::ApplicationVndCabJscript,
+    "application/vnd.canon-cpdl" => Mime::ApplicationVndCanonCpdl,
+    "application/vnd.canon-lips" => Mime::ApplicationVndCanonLips,
+    "application/vnd.capasystems-pg+json" => Mime::ApplicationVndCapasystemsPgJson,
+    "application/vnd.cendio.thinlinc.clientconf" => Mime::ApplicationVndCendioThinlincClientconf,
+    "application/vnd.century-systems.tcp_stream" => Mime::ApplicationVndCenturySystemsTcpStream,
+    "application/vnd.chemdraw+xml" => Mime::ApplicationVndChemdrawXml,
+    "application/vnd.chess-pgn" => Mime::ApplicationVndChessPgn,
+    "application/vnd.chipnuts.karaoke-mmd" => Mime::ApplicationVndChipnutsKaraokeMmd,
+    "application/vnd.ciedi" => Mime::ApplicationVndCiedi,
+    "application/vnd.cinderella" => Mime::ApplicationVndCinderella,
+    "application/vnd.cirpack.isdn-ext" => Mime::ApplicationVndCirpackIsdnExt,
+    "application/vnd.citationstyles.style+xml" => Mime::ApplicationVndCitationstylesStyleXml,
+    "application/vnd.claymore" => Mime::ApplicationVndClaymore,
+    "application/vnd.cloanto.rp9" => Mime::ApplicationVndCloantoRp9,
+    "application/vnd.clonk.c4group" => Mime::ApplicationVndClonkC4group,
+    "application/vnd.cluetrust.cartomobile-config" => Mime::ApplicationVndCluetrustCartomobileConfig,
+    "application/vnd.cluetrust.cartomobile-config-pkg" => Mime::ApplicationVndCluetrustCartomobileConfigPkg,
+    "application/vnd.cncf.helm.chart.content.v1.tar+gzip" => Mime::ApplicationVndCncfHelmChartContentV1TarGzip,
+    "application/vnd.cncf.helm.chart.provenance.v1.prov" => Mime::ApplicationVndCncfHelmChartProvenanceV1Prov,
+    "application/vnd.cncf.helm.config.v1+json" => Mime::ApplicationVndCncfHelmConfigV1Json,
+    "application/vnd.coffeescript" => Mime::ApplicationVndCoffeescript,
+    "application/vnd.collabio.xodocuments.document" => Mime::ApplicationVndCollabioXodocumentsDocument,
+    "application/vnd.collabio.xodocuments.document-template" => Mime::ApplicationVndCollabioXodocumentsDocumentTemplate,
+    "application/vnd.collabio.xodocuments.presentation" => Mime::ApplicationVndCollabioXodocumentsPresentation,
+    "application/vnd.collabio.xodocuments.presentation-template" => Mime::ApplicationVndCollabioXodocumentsPresentationTemplate,
+    "application/vnd.collabio.xodocuments.spreadsheet" => Mime::ApplicationVndCollabioXodocumentsSpreadsheet,
+    "application/vnd.collabio.xodocuments.spreadsheet-template" => Mime::ApplicationVndCollabioXodocumentsSpreadsheetTemplate,
+    "application/vnd.collection.doc+json" => Mime::ApplicationVndCollectionDocJson,
+    "application/vnd.collection+json" => Mime::ApplicationVndCollectionJson,
+    "application/vnd.collection.next+json" => Mime::ApplicationVndCollectionNextJson,
+    "application/vnd.comicbook-rar" => Mime::ApplicationVndComicbookRar,
+    "application/vnd.comicbook+zip" => Mime::ApplicationVndComicbookZip,
+    "application/vnd.commerce-battelle" => Mime::ApplicationVndCommerceBattelle,
+    "application/vnd.commonspace" => Mime::ApplicationVndCommonspace,
+    "application/vnd.coreos.ignition+json" => Mime::ApplicationVndCoreosIgnitionJson,
+    "application/vnd.cosmocaller" => Mime::ApplicationVndCosmocaller,
+    "application/vnd.contact.cmsg" => Mime::ApplicationVndContactCmsg,
+    "application/vnd.crick.clicker" => Mime::ApplicationVndCrickClicker,
+    "application/vnd.crick.clicker.keyboard" => Mime::ApplicationVndCrickClickerKeyboard,
+    "application/vnd.crick.clicker.palette" => Mime::ApplicationVndCrickClickerPalette,
+    "application/vnd.crick.clicker.template" => Mime::ApplicationVndCrickClickerTemplate,
+    "application/vnd.crick.clicker.wordbank" => Mime::ApplicationVndCrickClickerWordbank,
+    "application/vnd.criticaltools.wbs+xml" => Mime::ApplicationVndCriticaltoolsWbsXml,
+    "application/vnd.cryptii.pipe+json" => Mime::ApplicationVndCryptiiPipeJson,
+    "application/vnd.crypto-shade-file" => Mime::ApplicationVndCryptoShadeFile,
+    "application/vnd.cryptomator.encrypted" => Mime::ApplicationVndCryptomatorEncrypted,
+    "application/vnd.cryptomator.vault" => Mime::ApplicationVndCryptomatorVault,
+    "application/vnd.ctc-posml" => Mime::ApplicationVndCtcPosml,
+    "application/vnd.ctct.ws+xml" => Mime::ApplicationVndCtctWsXml,
+    "application/vnd.cups-pdf" => Mime::ApplicationVndCupsPdf,
+    "application/vnd.cups-postscript" => Mime::ApplicationVndCupsPostscript,
+    "application/vnd.cups-ppd" => Mime::ApplicationVndCupsPpd,
+    "application/vnd.cups-raster" => Mime::ApplicationVndCupsRaster,
+    "application/vnd.cups-raw" => Mime::ApplicationVndCupsRaw,
+    "application/vnd.curl" => Mime::ApplicationVndCurl,
+    "application/vnd.cyan.dean.root+xml" => Mime::ApplicationVndCyanDeanRootXml,
+    "application/vnd.cybank" => Mime::ApplicationVndCybank,
+    "application/vnd.cyclonedx+json" => Mime::ApplicationVndCyclonedxJson,
+    "application/vnd.cyclonedx+xml" => Mime::ApplicationVndCyclonedxXml,
+    "application/vnd.d2l.coursepackage1p0+zip" => Mime::ApplicationVndD2lCoursepackage1p0Zip,
+    "application/vnd.d3m-dataset" => Mime::ApplicationVndD3mDataset,
+    "application/vnd.d3m-problem" => Mime::ApplicationVndD3mProblem,
+    "application/vnd.dart" => Mime::ApplicationVndDart,
+    "application/vnd.data-vision.rdz" => Mime::ApplicationVndDataVisionRdz,
+    "application/vnd.datalog" => Mime::ApplicationVndDatalog,
+    "application/vnd.datapackage+json" => Mime::ApplicationVndDatapackageJson,
+    "application/vnd.dataresource+json" => Mime::ApplicationVndDataresourceJson,
+    "application/vnd.dbf" => Mime::ApplicationVndDbf,
+    "application/vnd.debian.binary-package" => Mime::ApplicationVndDebianBinaryPackage,
+    "application/vnd.dece.data" => Mime::ApplicationVndDeceData,
+    "application/vnd.dece.ttml+xml" => Mime::ApplicationVndDeceTtmlXml,
+    "application/vnd.dece.unspecified" => Mime::ApplicationVndDeceUnspecified,
+    "application/vnd.dece.zip" => Mime::ApplicationVndDeceZip,
+    "application/vnd.denovo.fcselayout-link" => Mime::ApplicationVndDenovoFcselayoutLink,
+    "application/vnd.desmume.movie" => Mime::ApplicationVndDesmumeMovie,
+    "application/vnd.dir-bi.plate-dl-nosuffix" => Mime::ApplicationVndDirBiPlateDlNosuffix,
+    "application/vnd.dm.delegation+xml" => Mime::ApplicationVndDmDelegationXml,
+    "application/vnd.dna" => Mime::ApplicationVndDna,
+    "application/vnd.document+json" => Mime::ApplicationVndDocumentJson,
+    "application/vnd.dolby.mobile.1" => Mime::ApplicationVndDolbyMobile1,
+    "application/vnd.dolby.mobile.2" => Mime::ApplicationVndDolbyMobile2,
+    "application/vnd.doremir.scorecloud-binary-document" => Mime::ApplicationVndDoremirScorecloudBinaryDocument,
+    "application/vnd.dpgraph" => Mime::ApplicationVndDpgraph,
+    "application/vnd.dreamfactory" => Mime::ApplicationVndDreamfactory,
+    "application/vnd.drive+json" => Mime::ApplicationVndDriveJson,
+    "application/vnd.dtg.local" => Mime::ApplicationVndDtgLocal,
+    "application/vnd.dtg.local.flash" => Mime::ApplicationVndDtgLocalFlash,
+    "application/vnd.dtg.local.html" => Mime::ApplicationVndDtgLocalHtml,
+    "application/vnd.dvb.ait" => Mime::ApplicationVndDvbAit,
+    "application/vnd.dvb.dvbisl+xml" => Mime::ApplicationVndDvbDvbislXml,
+    "application/vnd.dvb.dvbj" => Mime::ApplicationVndDvbDvbj,
+    "application/vnd.dvb.esgcontainer" => Mime::ApplicationVndDvbEsgcontainer,
+    "application/vnd.dvb.ipdcdftnotifaccess" => Mime::ApplicationVndDvbIpdcdftnotifaccess,
+    "application/vnd.dvb.ipdcesgaccess" => Mime::ApplicationVndDvbIpdcesgaccess,
+    "application/vnd.dvb.ipdcesgaccess2" => Mime::ApplicationVndDvbIpdcesgaccess2,
+    "application/vnd.dvb.ipdcesgpdd" => Mime::ApplicationVndDvbIpdcesgpdd,
+    "application/vnd.dvb.ipdcroaming" => Mime::ApplicationVndDvbIpdcroaming,
+    "application/vnd.dvb.iptv.alfec-base" => Mime::ApplicationVndDvbIptvAlfecBase,
+    "application/vnd.dvb.iptv.alfec-enhancement" => Mime::ApplicationVndDvbIptvAlfecEnhancement,
+    "application/vnd.dvb.notif-aggregate-root+xml" => Mime::ApplicationVndDvbNotifAggregateRootXml,
+    "application/vnd.dvb.notif-container+xml" => Mime::ApplicationVndDvbNotifContainerXml,
+    "application/vnd.dvb.notif-generic+xml" => Mime::ApplicationVndDvbNotifGenericXml,
+    "application/vnd.dvb.notif-ia-msglist+xml" => Mime::ApplicationVndDvbNotifIaMsglistXml,
+    "application/vnd.dvb.notif-ia-registration-request+xml" => Mime::ApplicationVndDvbNotifIaRegistrationRequestXml,
+    "application/vnd.dvb.notif-ia-registration-response+xml" => Mime::ApplicationVndDvbNotifIaRegistrationResponseXml,
+    "application/vnd.dvb.notif-init+xml" => Mime::ApplicationVndDvbNotifInitXml,
+    "application/vnd.dvb.pfr" => Mime::ApplicationVndDvbPfr,
+    "application/vnd.dvb.service" => Mime::ApplicationVndDvbService,
+    "application/vnd.dxr" => Mime::ApplicationVndDxr,
+    "application/vnd.dynageo" => Mime::ApplicationVndDynageo,
+    "application/vnd.dzr" => Mime::ApplicationVndDzr,
+    "application/vnd.easykaraoke.cdgdownload" => Mime::ApplicationVndEasykaraokeCdgdownload,
+    "application/vnd.ecip.rlp" => Mime::ApplicationVndEcipRlp,
+    "application/vnd.ecdis-update" => Mime::ApplicationVndEcdisUpdate,
+    "application/vnd.eclipse.ditto+json" => Mime::ApplicationVndEclipseDittoJson,
+    "application/vnd.ecowin.chart" => Mime::ApplicationVndEcowinChart,
+    "application/vnd.ecowin.filerequest" => Mime::ApplicationVndEcowinFilerequest,
+    "application/vnd.ecowin.fileupdate" => Mime::ApplicationVndEcowinFileupdate,
+    "application/vnd.ecowin.series" => Mime::ApplicationVndEcowinSeries,
+    "application/vnd.ecowin.seriesrequest" => Mime::ApplicationVndEcowinSeriesrequest,
+    "application/vnd.ecowin.seriesupdate" => Mime::ApplicationVndEcowinSeriesupdate,
+    "application/vnd.efi.img" => Mime::ApplicationVndEfiImg,
+    "application/vnd.efi.iso" => Mime::ApplicationVndEfiIso,
+    "application/vnd.eln+zip" => Mime::ApplicationVndElnZip,
+    "application/vnd.emclient.accessrequest+xml" => Mime::ApplicationVndEmclientAccessrequestXml,
+    "application/vnd.enliven" => Mime::ApplicationVndEnliven,
+    "application/vnd.enphase.envoy" => Mime::ApplicationVndEnphaseEnvoy,
+    "application/vnd.eprints.data+xml" => Mime::ApplicationVndEprintsDataXml,
+    "application/vnd.epson.esf" => Mime::ApplicationVndEpsonEsf,
+    "application/vnd.epson.msf" => Mime::ApplicationVndEpsonMsf,
+    "application/vnd.epson.quickanime" => Mime::ApplicationVndEpsonQuickanime,
+    "application/vnd.epson.salt" => Mime::ApplicationVndEpsonSalt,
+    "application/vnd.epson.ssf" => Mime::ApplicationVndEpsonSsf,
+    "application/vnd.ericsson.quickcall" => Mime::ApplicationVndEricssonQuickcall,
+    "application/vnd.espass-espass+zip" => Mime::ApplicationVndEspassEspassZip,
+    "application/vnd.eszigno3+xml" => Mime::ApplicationVndEszigno3Xml,
+    "application/vnd.etsi.aoc+xml" => Mime::ApplicationVndEtsiAocXml,
+    "application/vnd.etsi.asic-s+zip" => Mime::ApplicationVndEtsiAsicSZip,
+    "application/vnd.etsi.asic-e+zip" => Mime::ApplicationVndEtsiAsicEZip,
+    "application/vnd.etsi.cug+xml" => Mime::ApplicationVndEtsiCugXml,
+    "application/vnd.etsi.iptvcommand+xml" => Mime::ApplicationVndEtsiIptvcommandXml,
+    "application/vnd.etsi.iptvdiscovery+xml" => Mime::ApplicationVndEtsiIptvdiscoveryXml,
+    "application/vnd.etsi.iptvprofile+xml" => Mime::ApplicationVndEtsiIptvprofileXml,
+    "application/vnd.etsi.iptvsad-bc+xml" => Mime::ApplicationVndEtsiIptvsadBcXml,
+    "application/vnd.etsi.iptvsad-cod+xml" => Mime::ApplicationVndEtsiIptvsadCodXml,
+    "application/vnd.etsi.iptvsad-npvr+xml" => Mime::ApplicationVndEtsiIptvsadNpvrXml,
+    "application/vnd.etsi.iptvservice+xml" => Mime::ApplicationVndEtsiIptvserviceXml,
+    "application/vnd.etsi.iptvsync+xml" => Mime::ApplicationVndEtsiIptvsyncXml,
+    "application/vnd.etsi.iptvueprofile+xml" => Mime::ApplicationVndEtsiIptvueprofileXml,
+    "application/vnd.etsi.mcid+xml" => Mime::ApplicationVndEtsiMcidXml,
+    "application/vnd.etsi.mheg5" => Mime::ApplicationVndEtsiMheg5,
+    "application/vnd.etsi.overload-control-policy-dataset+xml" => Mime::ApplicationVndEtsiOverloadControlPolicyDatasetXml,
+    "application/vnd.etsi.pstn+xml" => Mime::ApplicationVndEtsiPstnXml,
+    "application/vnd.etsi.sci+xml" => Mime::ApplicationVndEtsiSciXml,
+    "application/vnd.etsi.simservs+xml" => Mime::ApplicationVndEtsiSimservsXml,
+    "application/vnd.etsi.timestamp-token" => Mime::ApplicationVndEtsiTimestampToken,
+    "application/vnd.etsi.tsl+xml" => Mime::ApplicationVndEtsiTslXml,
+    "application/vnd.etsi.tsl.der" => Mime::ApplicationVndEtsiTslDer,
+    "application/vnd.eu.kasparian.car+json" => Mime::ApplicationVndEuKasparianCarJson,
+    "application/vnd.eudora.data" => Mime::ApplicationVndEudoraData,
+    "application/vnd.evolv.ecig.profile" => Mime::ApplicationVndEvolvEcigProfile,
+    "application/vnd.evolv.ecig.settings" => Mime::ApplicationVndEvolvEcigSettings,
+    "application/vnd.evolv.ecig.theme" => Mime::ApplicationVndEvolvEcigTheme,
+    "application/vnd.exstream-empower+zip" => Mime::ApplicationVndExstreamEmpowerZip,
+    "application/vnd.exstream-package" => Mime::ApplicationVndExstreamPackage,
+    "application/vnd.ezpix-album" => Mime::ApplicationVndEzpixAlbum,
+    "application/vnd.ezpix-package" => Mime::ApplicationVndEzpixPackage,
+    "application/vnd.f-secure.mobile" => Mime::ApplicationVndFSecureMobile,
+    "application/vnd.fastcopy-disk-image" => Mime::ApplicationVndFastcopyDiskImage,
+    "application/vnd.familysearch.gedcom+zip" => Mime::ApplicationVndFamilysearchGedcomZip,
+    "application/vnd.fdsn.mseed" => Mime::ApplicationVndFdsnMseed,
+    "application/vnd.fdsn.seed" => Mime::ApplicationVndFdsnSeed,
+    "application/vnd.ffsns" => Mime::ApplicationVndFfsns,
+    "application/vnd.ficlab.flb+zip" => Mime::ApplicationVndFiclabFlbZip,
+    "application/vnd.filmit.zfc" => Mime::ApplicationVndFilmitZfc,
+    "application/vnd.fints" => Mime::ApplicationVndFints,
+    "application/vnd.firemonkeys.cloudcell" => Mime::ApplicationVndFiremonkeysCloudcell,
+    "application/vnd.FloGraphIt" => Mime::ApplicationVndFlographit,
+    "application/vnd.fluxtime.clip" => Mime::ApplicationVndFluxtimeClip,
+    "application/vnd.font-fontforge-sfd" => Mime::ApplicationVndFontFontforgeSfd,
+    "application/vnd.framemaker" => Mime::ApplicationVndFramemaker,
+    "application/vnd.fsc.weblaunch" => Mime::ApplicationVndFscWeblaunch,
+    "application/vnd.fujifilm.fb.docuworks" => Mime::ApplicationVndFujifilmFbDocuworks,
+    "application/vnd.fujifilm.fb.docuworks.binder" => Mime::ApplicationVndFujifilmFbDocuworksBinder,
+    "application/vnd.fujifilm.fb.docuworks.container" => Mime::ApplicationVndFujifilmFbDocuworksContainer,
+    "application/vnd.fujifilm.fb.jfi+xml" => Mime::ApplicationVndFujifilmFbJfiXml,
+    "application/vnd.fujitsu.oasys" => Mime::ApplicationVndFujitsuOasys,
+    "application/vnd.fujitsu.oasys2" => Mime::ApplicationVndFujitsuOasys2,
+    "application/vnd.fujitsu.oasys3" => Mime::ApplicationVndFujitsuOasys3,
+    "application/vnd.fujitsu.oasysgp" => Mime::ApplicationVndFujitsuOasysgp,
+    "application/vnd.fujitsu.oasysprs" => Mime::ApplicationVndFujitsuOasysprs,
+    "application/vnd.fujixerox.ART4" => Mime::ApplicationVndFujixeroxArt4,
+    "application/vnd.fujixerox.ART-EX" => Mime::ApplicationVndFujixeroxArtEx,
+    "application/vnd.fujixerox.ddd" => Mime::ApplicationVndFujixeroxDdd,
+    "application/vnd.fujixerox.docuworks" => Mime::ApplicationVndFujixeroxDocuworks,
+    "application/vnd.fujixerox.docuworks.binder" => Mime::ApplicationVndFujixeroxDocuworksBinder,
+    "application/vnd.fujixerox.docuworks.container" => Mime::ApplicationVndFujixeroxDocuworksContainer,
+    "application/vnd.fujixerox.HBPL" => Mime::ApplicationVndFujixeroxHbpl,
+    "application/vnd.fut-misnet" => Mime::ApplicationVndFutMisnet,
+    "application/vnd.futoin+cbor" => Mime::ApplicationVndFutoinCbor,
+    "application/vnd.futoin+json" => Mime::ApplicationVndFutoinJson,
+    "application/vnd.fuzzysheet" => Mime::ApplicationVndFuzzysheet,
+    "application/vnd.genomatix.tuxedo" => Mime::ApplicationVndGenomatixTuxedo,
+    "application/vnd.genozip" => Mime::ApplicationVndGenozip,
+    "application/vnd.gentics.grd+json" => Mime::ApplicationVndGenticsGrdJson,
+    "application/vnd.gentoo.catmetadata+xml" => Mime::ApplicationVndGentooCatmetadataXml,
+    "application/vnd.gentoo.ebuild" => Mime::ApplicationVndGentooEbuild,
+    "application/vnd.gentoo.eclass" => Mime::ApplicationVndGentooEclass,
+    "application/vnd.gentoo.gpkg" => Mime::ApplicationVndGentooGpkg,
+    "application/vnd.gentoo.manifest" => Mime::ApplicationVndGentooManifest,
+    "application/vnd.gentoo.xpak" => Mime::ApplicationVndGentooXpak,
+    "application/vnd.gentoo.pkgmetadata+xml" => Mime::ApplicationVndGentooPkgmetadataXml,
+    "application/vnd.geogebra.file" => Mime::ApplicationVndGeogebraFile,
+    "application/vnd.geogebra.slides" => Mime::ApplicationVndGeogebraSlides,
+    "application/vnd.geogebra.tool" => Mime::ApplicationVndGeogebraTool,
+    "application/vnd.geometry-explorer" => Mime::ApplicationVndGeometryExplorer,
+    "application/vnd.geonext" => Mime::ApplicationVndGeonext,
+    "application/vnd.geoplan" => Mime::ApplicationVndGeoplan,
+    "application/vnd.geospace" => Mime::ApplicationVndGeospace,
+    "application/vnd.gerber" => Mime::ApplicationVndGerber,
+    "application/vnd.globalplatform.card-content-mgt" => Mime::ApplicationVndGlobalplatformCardContentMgt,
+    "application/vnd.globalplatform.card-content-mgt-response" => Mime::ApplicationVndGlobalplatformCardContentMgtResponse,
+    "application/vnd.gnu.taler.exchange+json" => Mime::ApplicationVndGnuTalerExchangeJson,
+    "application/vnd.gnu.taler.merchant+json" => Mime::ApplicationVndGnuTalerMerchantJson,
+    "application/vnd.google-earth.kml+xml" => Mime::ApplicationVndGoogleEarthKmlXml,
+    "application/vnd.google-earth.kmz" => Mime::ApplicationVndGoogleEarthKmz,
+    "application/vnd.gov.sk.e-form+xml" => Mime::ApplicationVndGovSkEFormXml,
+    "application/vnd.gov.sk.e-form+zip" => Mime::ApplicationVndGovSkEFormZip,
+    "application/vnd.gov.sk.xmldatacontainer+xml" => Mime::ApplicationVndGovSkXmldatacontainerXml,
+    "application/vnd.gpxsee.map+xml" => Mime::ApplicationVndGpxseeMapXml,
+    "application/vnd.grafeq" => Mime::ApplicationVndGrafeq,
+    "application/vnd.gridmp" => Mime::ApplicationVndGridmp,
+    "application/vnd.groove-account" => Mime::ApplicationVndGrooveAccount,
+    "application/vnd.groove-help" => Mime::ApplicationVndGrooveHelp,
+    "application/vnd.groove-identity-message" => Mime::ApplicationVndGrooveIdentityMessage,
+    "application/vnd.groove-injector" => Mime::ApplicationVndGrooveInjector,
+    "application/vnd.groove-tool-message" => Mime::ApplicationVndGrooveToolMessage,
+    "application/vnd.groove-tool-template" => Mime::ApplicationVndGrooveToolTemplate,
+    "application/vnd.groove-vcard" => Mime::ApplicationVndGrooveVcard,
+    "application/vnd.hal+json" => Mime::ApplicationVndHalJson,
+    "application/vnd.hal+xml" => Mime::ApplicationVndHalXml,
+    "application/vnd.HandHeld-Entertainment+xml" => Mime::ApplicationVndHandheldEntertainmentXml,
+    "application/vnd.hbci" => Mime::ApplicationVndHbci,
+    "application/vnd.hc+json" => Mime::ApplicationVndHcJson,
+    "application/vnd.hcl-bireports" => Mime::ApplicationVndHclBireports,
+    "application/vnd.hdt" => Mime::ApplicationVndHdt,
+    "application/vnd.heroku+json" => Mime::ApplicationVndHerokuJson,
+    "application/vnd.hhe.lesson-player" => Mime::ApplicationVndHheLessonPlayer,
+    "application/vnd.hp-HPGL" => Mime::ApplicationVndHpHpgl,
+    "application/vnd.hp-hpid" => Mime::ApplicationVndHpHpid,
+    "application/vnd.hp-hps" => Mime::ApplicationVndHpHps,
+    "application/vnd.hp-jlyt" => Mime::ApplicationVndHpJlyt,
+    "application/vnd.hp-PCL" => Mime::ApplicationVndHpPcl,
+    "application/vnd.hp-PCLXL" => Mime::ApplicationVndHpPclxl,
+    "application/vnd.hsl" => Mime::ApplicationVndHsl,
+    "application/vnd.httphone" => Mime::ApplicationVndHttphone,
+    "application/vnd.hydrostatix.sof-data" => Mime::ApplicationVndHydrostatixSofData,
+    "application/vnd.hyper-item+json" => Mime::ApplicationVndHyperItemJson,
+    "application/vnd.hyper+json" => Mime::ApplicationVndHyperJson,
+    "application/vnd.hyperdrive+json" => Mime::ApplicationVndHyperdriveJson,
+    "application/vnd.hzn-3d-crossword" => Mime::ApplicationVndHzn3dCrossword,
+    "application/vnd.ibm.electronic-media" => Mime::ApplicationVndIbmElectronicMedia,
+    "application/vnd.ibm.MiniPay" => Mime::ApplicationVndIbmMinipay,
+    "application/vnd.ibm.rights-management" => Mime::ApplicationVndIbmRightsManagement,
+    "application/vnd.ibm.secure-container" => Mime::ApplicationVndIbmSecureContainer,
+    "application/vnd.iccprofile" => Mime::ApplicationVndIccprofile,
+    "application/vnd.ieee.1905" => Mime::ApplicationVndIeee1905,
+    "application/vnd.igloader" => Mime::ApplicationVndIgloader,
+    "application/vnd.imagemeter.folder+zip" => Mime::ApplicationVndImagemeterFolderZip,
+    "application/vnd.imagemeter.image+zip" => Mime::ApplicationVndImagemeterImageZip,
+    "application/vnd.immervision-ivp" => Mime::ApplicationVndImmervisionIvp,
+    "application/vnd.immervision-ivu" => Mime::ApplicationVndImmervisionIvu,
+    "application/vnd.ims.imsccv1p1" => Mime::ApplicationVndImsImsccv1p1,
+    "application/vnd.ims.imsccv1p2" => Mime::ApplicationVndImsImsccv1p2,
+    "application/vnd.ims.imsccv1p3" => Mime::ApplicationVndImsImsccv1p3,
+    "application/vnd.ims.lis.v2.result+json" => Mime::ApplicationVndImsLisV2ResultJson,
+    "application/vnd.ims.lti.v2.toolconsumerprofile+json" => Mime::ApplicationVndImsLtiV2ToolconsumerprofileJson,
+    "application/vnd.ims.lti.v2.toolproxy.id+json" => Mime::ApplicationVndImsLtiV2ToolproxyIdJson,
+    "application/vnd.ims.lti.v2.toolproxy+json" => Mime::ApplicationVndImsLtiV2ToolproxyJson,
+    "application/vnd.ims.lti.v2.toolsettings+json" => Mime::ApplicationVndImsLtiV2ToolsettingsJson,
+    "application/vnd.ims.lti.v2.toolsettings.simple+json" => Mime::ApplicationVndImsLtiV2ToolsettingsSimpleJson,
+    "application/vnd.informedcontrol.rms+xml" => Mime::ApplicationVndInformedcontrolRmsXml,
+    "application/vnd.infotech.project" => Mime::ApplicationVndInfotechProject,
+    "application/vnd.infotech.project+xml" => Mime::ApplicationVndInfotechProjectXml,
+    "application/vnd.innopath.wamp.notification" => Mime::ApplicationVndInnopathWampNotification,
+    "application/vnd.insors.igm" => Mime::ApplicationVndInsorsIgm,
+    "application/vnd.intercon.formnet" => Mime::ApplicationVndInterconFormnet,
+    "application/vnd.intergeo" => Mime::ApplicationVndIntergeo,
+    "application/vnd.intertrust.digibox" => Mime::ApplicationVndIntertrustDigibox,
+    "application/vnd.intertrust.nncp" => Mime::ApplicationVndIntertrustNncp,
+    "application/vnd.intu.qbo" => Mime::ApplicationVndIntuQbo,
+    "application/vnd.intu.qfx" => Mime::ApplicationVndIntuQfx,
+    "application/vnd.ipfs.ipns-record" => Mime::ApplicationVndIpfsIpnsRecord,
+    "application/vnd.ipld.car" => Mime::ApplicationVndIpldCar,
+    "application/vnd.ipld.dag-cbor" => Mime::ApplicationVndIpldDagCbor,
+    "application/vnd.ipld.dag-json" => Mime::ApplicationVndIpldDagJson,
+    "application/vnd.ipld.raw" => Mime::ApplicationVndIpldRaw,
+    "application/vnd.iptc.g2.catalogitem+xml" => Mime::ApplicationVndIptcG2CatalogitemXml,
+    "application/vnd.iptc.g2.conceptitem+xml" => Mime::ApplicationVndIptcG2ConceptitemXml,
+    "application/vnd.iptc.g2.knowledgeitem+xml" => Mime::ApplicationVndIptcG2KnowledgeitemXml,
+    "application/vnd.iptc.g2.newsitem+xml" => Mime::ApplicationVndIptcG2NewsitemXml,
+    "application/vnd.iptc.g2.newsmessage+xml" => Mime::ApplicationVndIptcG2NewsmessageXml,
+    "application/vnd.iptc.g2.packageitem+xml" => Mime::ApplicationVndIptcG2PackageitemXml,
+    "application/vnd.iptc.g2.planningitem+xml" => Mime::ApplicationVndIptcG2PlanningitemXml,
+    "application/vnd.ipunplugged.rcprofile" => Mime::ApplicationVndIpunpluggedRcprofile,
+    "application/vnd.irepository.package+xml" => Mime::ApplicationVndIrepositoryPackageXml,
+    "application/vnd.is-xpr" => Mime::ApplicationVndIsXpr,
+    "application/vnd.isac.fcs" => Mime::ApplicationVndIsacFcs,
+    "application/vnd.jam" => Mime::ApplicationVndJam,
+    "application/vnd.iso11783-10+zip" => Mime::ApplicationVndIso1178310Zip,
+    "application/vnd.japannet-directory-service" => Mime::ApplicationVndJapannetDirectoryService,
+    "application/vnd.japannet-jpnstore-wakeup" => Mime::ApplicationVndJapannetJpnstoreWakeup,
+    "application/vnd.japannet-payment-wakeup" => Mime::ApplicationVndJapannetPaymentWakeup,
+    "application/vnd.japannet-registration" => Mime::ApplicationVndJapannetRegistration,
+    "application/vnd.japannet-registration-wakeup" => Mime::ApplicationVndJapannetRegistrationWakeup,
+    "application/vnd.japannet-setstore-wakeup" => Mime::ApplicationVndJapannetSetstoreWakeup,
+    "application/vnd.japannet-verification" => Mime::ApplicationVndJapannetVerification,
+    "application/vnd.japannet-verification-wakeup" => Mime::ApplicationVndJapannetVerificationWakeup,
+    "application/vnd.jcp.javame.midlet-rms" => Mime::ApplicationVndJcpJavameMidletRms,
+    "application/vnd.jisp" => Mime::ApplicationVndJisp,
+    "application/vnd.joost.joda-archive" => Mime::ApplicationVndJoostJodaArchive,
+    "application/vnd.jsk.isdn-ngn" => Mime::ApplicationVndJskIsdnNgn,
+    "application/vnd.kahootz" => Mime::ApplicationVndKahootz,
+    "application/vnd.kde.karbon" => Mime::ApplicationVndKdeKarbon,
+    "application/vnd.kde.kchart" => Mime::ApplicationVndKdeKchart,
+    "application/vnd.kde.kformula" => Mime::ApplicationVndKdeKformula,
+    "application/vnd.kde.kivio" => Mime::ApplicationVndKdeKivio,
+    "application/vnd.kde.kontour" => Mime::ApplicationVndKdeKontour,
+    "application/vnd.kde.kpresenter" => Mime::ApplicationVndKdeKpresenter,
+    "application/vnd.kde.kspread" => Mime::ApplicationVndKdeKspread,
+    "application/vnd.kde.kword" => Mime::ApplicationVndKdeKword,
+    "application/vnd.kenameaapp" => Mime::ApplicationVndKenameaapp,
+    "application/vnd.kidspiration" => Mime::ApplicationVndKidspiration,
+    "application/vnd.Kinar" => Mime::ApplicationVndKinar,
+    "application/vnd.koan" => Mime::ApplicationVndKoan,
+    "application/vnd.kodak-descriptor" => Mime::ApplicationVndKodakDescriptor,
+    "application/vnd.las" => Mime::ApplicationVndLas,
+    "application/vnd.las.las+json" => Mime::ApplicationVndLasLasJson,
+    "application/vnd.las.las+xml" => Mime::ApplicationVndLasLasXml,
+    "application/vnd.laszip" => Mime::ApplicationVndLaszip,
+    "application/vnd.leap+json" => Mime::ApplicationVndLeapJson,
+    "application/vnd.liberty-request+xml" => Mime::ApplicationVndLibertyRequestXml,
+    "application/vnd.llamagraphics.life-balance.desktop" => Mime::ApplicationVndLlamagraphicsLifeBalanceDesktop,
+    "application/vnd.llamagraphics.life-balance.exchange+xml" => Mime::ApplicationVndLlamagraphicsLifeBalanceExchangeXml,
+    "application/vnd.logipipe.circuit+zip" => Mime::ApplicationVndLogipipeCircuitZip,
+    "application/vnd.loom" => Mime::ApplicationVndLoom,
+    "application/vnd.lotus-1-2-3" => Mime::ApplicationVndLotus123,
+    "application/vnd.lotus-approach" => Mime::ApplicationVndLotusApproach,
+    "application/vnd.lotus-freelance" => Mime::ApplicationVndLotusFreelance,
+    "application/vnd.lotus-notes" => Mime::ApplicationVndLotusNotes,
+    "application/vnd.lotus-organizer" => Mime::ApplicationVndLotusOrganizer,
+    "application/vnd.lotus-screencam" => Mime::ApplicationVndLotusScreencam,
+    "application/vnd.lotus-wordpro" => Mime::ApplicationVndLotusWordpro,
+    "application/vnd.macports.portpkg" => Mime::ApplicationVndMacportsPortpkg,
+    "application/vnd.mapbox-vector-tile" => Mime::ApplicationVndMapboxVectorTile,
+    "application/vnd.marlin.drm.actiontoken+xml" => Mime::ApplicationVndMarlinDrmActiontokenXml,
+    "application/vnd.marlin.drm.conftoken+xml" => Mime::ApplicationVndMarlinDrmConftokenXml,
+    "application/vnd.marlin.drm.license+xml" => Mime::ApplicationVndMarlinDrmLicenseXml,
+    "application/vnd.marlin.drm.mdcf" => Mime::ApplicationVndMarlinDrmMdcf,
+    "application/vnd.mason+json" => Mime::ApplicationVndMasonJson,
+    "application/vnd.maxar.archive.3tz+zip" => Mime::ApplicationVndMaxarArchive3tzZip,
+    "application/vnd.maxmind.maxmind-db" => Mime::ApplicationVndMaxmindMaxmindDb,
+    "application/vnd.mcd" => Mime::ApplicationVndMcd,
+    "application/vnd.mdl" => Mime::ApplicationVndMdl,
+    "application/vnd.mdl-mbsdf" => Mime::ApplicationVndMdlMbsdf,
+    "application/vnd.medcalcdata" => Mime::ApplicationVndMedcalcdata,
+    "application/vnd.mediastation.cdkey" => Mime::ApplicationVndMediastationCdkey,
+    "application/vnd.medicalholodeck.recordxr" => Mime::ApplicationVndMedicalholodeckRecordxr,
+    "application/vnd.meridian-slingshot" => Mime::ApplicationVndMeridianSlingshot,
+    "application/vnd.MFER" => Mime::ApplicationVndMfer,
+    "application/vnd.mfmp" => Mime::ApplicationVndMfmp,
+    "application/vnd.micro+json" => Mime::ApplicationVndMicroJson,
+    "application/vnd.micrografx.flo" => Mime::ApplicationVndMicrografxFlo,
+    "application/vnd.micrografx.igx" => Mime::ApplicationVndMicrografxIgx,
+    "application/vnd.microsoft.portable-executable" => Mime::ApplicationVndMicrosoftPortableExecutable,
+    "application/vnd.microsoft.windows.thumbnail-cache" => Mime::ApplicationVndMicrosoftWindowsThumbnailCache,
+    "application/vnd.miele+json" => Mime::ApplicationVndMieleJson,
+    "application/vnd.mif" => Mime::ApplicationVndMif,
+    "application/vnd.minisoft-hp3000-save" => Mime::ApplicationVndMinisoftHp3000Save,
+    "application/vnd.mitsubishi.misty-guard.trustweb" => Mime::ApplicationVndMitsubishiMistyGuardTrustweb,
+    "application/vnd.Mobius.DAF" => Mime::ApplicationVndMobiusDaf,
+    "application/vnd.Mobius.DIS" => Mime::ApplicationVndMobiusDis,
+    "application/vnd.Mobius.MBK" => Mime::ApplicationVndMobiusMbk,
+    "application/vnd.Mobius.MQY" => Mime::ApplicationVndMobiusMqy,
+    "application/vnd.Mobius.MSL" => Mime::ApplicationVndMobiusMsl,
+    "application/vnd.Mobius.PLC" => Mime::ApplicationVndMobiusPlc,
+    "application/vnd.Mobius.TXF" => Mime::ApplicationVndMobiusTxf,
+    "application/vnd.modl" => Mime::ApplicationVndModl,
+    "application/vnd.mophun.application" => Mime::ApplicationVndMophunApplication,
+    "application/vnd.mophun.certificate" => Mime::ApplicationVndMophunCertificate,
+    "application/vnd.motorola.flexsuite" => Mime::ApplicationVndMotorolaFlexsuite,
+    "application/vnd.motorola.flexsuite.adsi" => Mime::ApplicationVndMotorolaFlexsuiteAdsi,
+    "application/vnd.motorola.flexsuite.fis" => Mime::ApplicationVndMotorolaFlexsuiteFis,
+    "application/vnd.motorola.flexsuite.gotap" => Mime::ApplicationVndMotorolaFlexsuiteGotap,
+    "application/vnd.motorola.flexsuite.kmr" => Mime::ApplicationVndMotorolaFlexsuiteKmr,
+    "application/vnd.motorola.flexsuite.ttc" => Mime::ApplicationVndMotorolaFlexsuiteTtc,
+    "application/vnd.motorola.flexsuite.wem" => Mime::ApplicationVndMotorolaFlexsuiteWem,
+    "application/vnd.motorola.iprm" => Mime::ApplicationVndMotorolaIprm,
+    "application/vnd.mozilla.xul+xml" => Mime::ApplicationVndMozillaXulXml,
+    "application/vnd.ms-artgalry" => Mime::ApplicationVndMsArtgalry,
+    "application/vnd.ms-asf" => Mime::ApplicationVndMsAsf,
+    "application/vnd.ms-cab-compressed" => Mime::ApplicationVndMsCabCompressed,
+    "application/vnd.ms-3mfdocument" => Mime::ApplicationVndMs3mfdocument,
+    "application/vnd.ms-excel" => Mime::ApplicationVndMsExcel,
+    "application/vnd.ms-excel.addin.macroEnabled.12" => Mime::ApplicationVndMsExcelAddinMacroenabled12,
+    "application/vnd.ms-excel.sheet.binary.macroEnabled.12" => Mime::ApplicationVndMsExcelSheetBinaryMacroenabled12,
+    "application/vnd.ms-excel.sheet.macroEnabled.12" => Mime::ApplicationVndMsExcelSheetMacroenabled12,
+    "application/vnd.ms-excel.template.macroEnabled.12" => Mime::ApplicationVndMsExcelTemplateMacroenabled12,
+    "application/vnd.ms-fontobject" => Mime::ApplicationVndMsFontobject,
+    "application/vnd.ms-htmlhelp" => Mime::ApplicationVndMsHtmlhelp,
+    "application/vnd.ms-ims" => Mime::ApplicationVndMsIms,
+    "application/vnd.ms-lrm" => Mime::ApplicationVndMsLrm,
+    "application/vnd.ms-office.activeX+xml" => Mime::ApplicationVndMsOfficeActivexXml,
+    "application/vnd.ms-officetheme" => Mime::ApplicationVndMsOfficetheme,
+    "application/vnd.ms-playready.initiator+xml" => Mime::ApplicationVndMsPlayreadyInitiatorXml,
+    "application/vnd.ms-powerpoint" => Mime::ApplicationVndMsPowerpoint,
+    "application/vnd.ms-powerpoint.addin.macroEnabled.12" => Mime::ApplicationVndMsPowerpointAddinMacroenabled12,
+    "application/vnd.ms-powerpoint.presentation.macroEnabled.12" => Mime::ApplicationVndMsPowerpointPresentationMacroenabled12,
+    "application/vnd.ms-powerpoint.slide.macroEnabled.12" => Mime::ApplicationVndMsPowerpointSlideMacroenabled12,
+    "application/vnd.ms-powerpoint.slideshow.macroEnabled.12" => Mime::ApplicationVndMsPowerpointSlideshowMacroenabled12,
+    "application/vnd.ms-powerpoint.template.macroEnabled.12" => Mime::ApplicationVndMsPowerpointTemplateMacroenabled12,
+    "application/vnd.ms-PrintDeviceCapabilities+xml" => Mime::ApplicationVndMsPrintdevicecapabilitiesXml,
+    "application/vnd.ms-PrintSchemaTicket+xml" => Mime::ApplicationVndMsPrintschematicketXml,
+    "application/vnd.ms-project" => Mime::ApplicationVndMsProject,
+    "application/vnd.ms-tnef" => Mime::ApplicationVndMsTnef,
+    "application/vnd.ms-windows.devicepairing" => Mime::ApplicationVndMsWindowsDevicepairing,
+    "application/vnd.ms-windows.nwprinting.oob" => Mime::ApplicationVndMsWindowsNwprintingOob,
+    "application/vnd.ms-windows.printerpairing" => Mime::ApplicationVndMsWindowsPrinterpairing,
+    "application/vnd.ms-windows.wsd.oob" => Mime::ApplicationVndMsWindowsWsdOob,
+    "application/vnd.ms-wmdrm.lic-chlg-req" => Mime::ApplicationVndMsWmdrmLicChlgReq,
+    "application/vnd.ms-wmdrm.lic-resp" => Mime::ApplicationVndMsWmdrmLicResp,
+    "application/vnd.ms-wmdrm.meter-chlg-req" => Mime::ApplicationVndMsWmdrmMeterChlgReq,
+    "application/vnd.ms-wmdrm.meter-resp" => Mime::ApplicationVndMsWmdrmMeterResp,
+    "application/vnd.ms-word.document.macroEnabled.12" => Mime::ApplicationVndMsWordDocumentMacroenabled12,
+    "application/vnd.ms-word.template.macroEnabled.12" => Mime::ApplicationVndMsWordTemplateMacroenabled12,
+    "application/vnd.ms-works" => Mime::ApplicationVndMsWorks,
+    "application/vnd.ms-wpl" => Mime::ApplicationVndMsWpl,
+    "application/vnd.ms-xpsdocument" => Mime::ApplicationVndMsXpsdocument,
+    "application/vnd.msa-disk-image" => Mime::ApplicationVndMsaDiskImage,
+    "application/vnd.mseq" => Mime::ApplicationVndMseq,
+    "application/vnd.msign" => Mime::ApplicationVndMsign,
+    "application/vnd.multiad.creator" => Mime::ApplicationVndMultiadCreator,
+    "application/vnd.multiad.creator.cif" => Mime::ApplicationVndMultiadCreatorCif,
+    "application/vnd.musician" => Mime::ApplicationVndMusician,
+    "application/vnd.music-niff" => Mime::ApplicationVndMusicNiff,
+    "application/vnd.muvee.style" => Mime::ApplicationVndMuveeStyle,
+    "application/vnd.mynfc" => Mime::ApplicationVndMynfc,
+    "application/vnd.nacamar.ybrid+json" => Mime::ApplicationVndNacamarYbridJson,
+    "application/vnd.ncd.control" => Mime::ApplicationVndNcdControl,
+    "application/vnd.ncd.reference" => Mime::ApplicationVndNcdReference,
+    "application/vnd.nearst.inv+json" => Mime::ApplicationVndNearstInvJson,
+    "application/vnd.nebumind.line" => Mime::ApplicationVndNebumindLine,
+    "application/vnd.nervana" => Mime::ApplicationVndNervana,
+    "application/vnd.netfpx" => Mime::ApplicationVndNetfpx,
+    "application/vnd.neurolanguage.nlu" => Mime::ApplicationVndNeurolanguageNlu,
+    "application/vnd.nimn" => Mime::ApplicationVndNimn,
+    "application/vnd.nintendo.snes.rom" => Mime::ApplicationVndNintendoSnesRom,
+    "application/vnd.nintendo.nitro.rom" => Mime::ApplicationVndNintendoNitroRom,
+    "application/vnd.nitf" => Mime::ApplicationVndNitf,
+    "application/vnd.noblenet-directory" => Mime::ApplicationVndNoblenetDirectory,
+    "application/vnd.noblenet-sealer" => Mime::ApplicationVndNoblenetSealer,
+    "application/vnd.noblenet-web" => Mime::ApplicationVndNoblenetWeb,
+    "application/vnd.nokia.catalogs" => Mime::ApplicationVndNokiaCatalogs,
+    "application/vnd.nokia.conml+wbxml" => Mime::ApplicationVndNokiaConmlWbxml,
+    "application/vnd.nokia.conml+xml" => Mime::ApplicationVndNokiaConmlXml,
+    "application/vnd.nokia.iptv.config+xml" => Mime::ApplicationVndNokiaIptvConfigXml,
+    "application/vnd.nokia.iSDS-radio-presets" => Mime::ApplicationVndNokiaIsdsRadioPresets,
+    "application/vnd.nokia.landmark+wbxml" => Mime::ApplicationVndNokiaLandmarkWbxml,
+    "application/vnd.nokia.landmark+xml" => Mime::ApplicationVndNokiaLandmarkXml,
+    "application/vnd.nokia.landmarkcollection+xml" => Mime::ApplicationVndNokiaLandmarkcollectionXml,
+    "application/vnd.nokia.ncd" => Mime::ApplicationVndNokiaNcd,
+    "application/vnd.nokia.n-gage.ac+xml" => Mime::ApplicationVndNokiaNGageAcXml,
+    "application/vnd.nokia.n-gage.data" => Mime::ApplicationVndNokiaNGageData,
+    "application/vnd.nokia.pcd+wbxml" => Mime::ApplicationVndNokiaPcdWbxml,
+    "application/vnd.nokia.pcd+xml" => Mime::ApplicationVndNokiaPcdXml,
+    "application/vnd.nokia.radio-preset" => Mime::ApplicationVndNokiaRadioPreset,
+    "application/vnd.nokia.radio-presets" => Mime::ApplicationVndNokiaRadioPresets,
+    "application/vnd.novadigm.EDM" => Mime::ApplicationVndNovadigmEdm,
+    "application/vnd.novadigm.EDX" => Mime::ApplicationVndNovadigmEdx,
+    "application/vnd.novadigm.EXT" => Mime::ApplicationVndNovadigmExt,
+    "application/vnd.ntt-local.content-share" => Mime::ApplicationVndNttLocalContentShare,
+    "application/vnd.ntt-local.file-transfer" => Mime::ApplicationVndNttLocalFileTransfer,
+    "application/vnd.ntt-local.ogw_remote-access" => Mime::ApplicationVndNttLocalOgwRemoteAccess,
+    "application/vnd.ntt-local.sip-ta_remote" => Mime::ApplicationVndNttLocalSipTaRemote,
+    "application/vnd.ntt-local.sip-ta_tcp_stream" => Mime::ApplicationVndNttLocalSipTaTcpStream,
+    "application/vnd.oasis.opendocument.base" => Mime::ApplicationVndOasisOpendocumentBase,
+    "application/vnd.oasis.opendocument.chart" => Mime::ApplicationVndOasisOpendocumentChart,
+    "application/vnd.oasis.opendocument.chart-template" => Mime::ApplicationVndOasisOpendocumentChartTemplate,
+    "application/vnd.oasis.opendocument.formula" => Mime::ApplicationVndOasisOpendocumentFormula,
+    "application/vnd.oasis.opendocument.formula-template" => Mime::ApplicationVndOasisOpendocumentFormulaTemplate,
+    "application/vnd.oasis.opendocument.graphics" => Mime::ApplicationVndOasisOpendocumentGraphics,
+    "application/vnd.oasis.opendocument.graphics-template" => Mime::ApplicationVndOasisOpendocumentGraphicsTemplate,
+    "application/vnd.oasis.opendocument.image" => Mime::ApplicationVndOasisOpendocumentImage,
+    "application/vnd.oasis.opendocument.image-template" => Mime::ApplicationVndOasisOpendocumentImageTemplate,
+    "application/vnd.oasis.opendocument.presentation" => Mime::ApplicationVndOasisOpendocumentPresentation,
+    "application/vnd.oasis.opendocument.presentation-template" => Mime::ApplicationVndOasisOpendocumentPresentationTemplate,
+    "application/vnd.oasis.opendocument.spreadsheet" => Mime::ApplicationVndOasisOpendocumentSpreadsheet,
+    "application/vnd.oasis.opendocument.spreadsheet-template" => Mime::ApplicationVndOasisOpendocumentSpreadsheetTemplate,
+    "application/vnd.oasis.opendocument.text" => Mime::ApplicationVndOasisOpendocumentText,
+    "application/vnd.oasis.opendocument.text-master" => Mime::ApplicationVndOasisOpendocumentTextMaster,
+    "application/vnd.oasis.opendocument.text-master-template" => Mime::ApplicationVndOasisOpendocumentTextMasterTemplate,
+    "application/vnd.oasis.opendocument.text-template" => Mime::ApplicationVndOasisOpendocumentTextTemplate,
+    "application/vnd.oasis.opendocument.text-web" => Mime::ApplicationVndOasisOpendocumentTextWeb,
+    "application/vnd.obn" => Mime::ApplicationVndObn,
+    "application/vnd.ocf+cbor" => Mime::ApplicationVndOcfCbor,
+    "application/vnd.oci.image.manifest.v1+json" => Mime::ApplicationVndOciImageManifestV1Json,
+    "application/vnd.oftn.l10n+json" => Mime::ApplicationVndOftnL10nJson,
+    "application/vnd.oipf.contentaccessdownload+xml" => Mime::ApplicationVndOipfContentaccessdownloadXml,
+    "application/vnd.oipf.contentaccessstreaming+xml" => Mime::ApplicationVndOipfContentaccessstreamingXml,
+    "application/vnd.oipf.cspg-hexbinary" => Mime::ApplicationVndOipfCspgHexbinary,
+    "application/vnd.oipf.dae.svg+xml" => Mime::ApplicationVndOipfDaeSvgXml,
+    "application/vnd.oipf.dae.xhtml+xml" => Mime::ApplicationVndOipfDaeXhtmlXml,
+    "application/vnd.oipf.mippvcontrolmessage+xml" => Mime::ApplicationVndOipfMippvcontrolmessageXml,
+    "application/vnd.oipf.pae.gem" => Mime::ApplicationVndOipfPaeGem,
+    "application/vnd.oipf.spdiscovery+xml" => Mime::ApplicationVndOipfSpdiscoveryXml,
+    "application/vnd.oipf.spdlist+xml" => Mime::ApplicationVndOipfSpdlistXml,
+    "application/vnd.oipf.ueprofile+xml" => Mime::ApplicationVndOipfUeprofileXml,
+    "application/vnd.oipf.userprofile+xml" => Mime::ApplicationVndOipfUserprofileXml,
+    "application/vnd.olpc-sugar" => Mime::ApplicationVndOlpcSugar,
+    "application/vnd.oma.bcast.associated-procedure-parameter+xml" => Mime::ApplicationVndOmaBcastAssociatedProcedureParameterXml,
+    "application/vnd.oma.bcast.drm-trigger+xml" => Mime::ApplicationVndOmaBcastDrmTriggerXml,
+    "application/vnd.oma.bcast.imd+xml" => Mime::ApplicationVndOmaBcastImdXml,
+    "application/vnd.oma.bcast.ltkm" => Mime::ApplicationVndOmaBcastLtkm,
+    "application/vnd.oma.bcast.notification+xml" => Mime::ApplicationVndOmaBcastNotificationXml,
+    "application/vnd.oma.bcast.provisioningtrigger" => Mime::ApplicationVndOmaBcastProvisioningtrigger,
+    "application/vnd.oma.bcast.sgboot" => Mime::ApplicationVndOmaBcastSgboot,
+    "application/vnd.oma.bcast.sgdd+xml" => Mime::ApplicationVndOmaBcastSgddXml,
+    "application/vnd.oma.bcast.sgdu" => Mime::ApplicationVndOmaBcastSgdu,
+    "application/vnd.oma.bcast.simple-symbol-container" => Mime::ApplicationVndOmaBcastSimpleSymbolContainer,
+    "application/vnd.oma.bcast.smartcard-trigger+xml" => Mime::ApplicationVndOmaBcastSmartcardTriggerXml,
+    "application/vnd.oma.bcast.sprov+xml" => Mime::ApplicationVndOmaBcastSprovXml,
+    "application/vnd.oma.bcast.stkm" => Mime::ApplicationVndOmaBcastStkm,
+    "application/vnd.oma.cab-address-book+xml" => Mime::ApplicationVndOmaCabAddressBookXml,
+    "application/vnd.oma.cab-feature-handler+xml" => Mime::ApplicationVndOmaCabFeatureHandlerXml,
+    "application/vnd.oma.cab-pcc+xml" => Mime::ApplicationVndOmaCabPccXml,
+    "application/vnd.oma.cab-subs-invite+xml" => Mime::ApplicationVndOmaCabSubsInviteXml,
+    "application/vnd.oma.cab-user-prefs+xml" => Mime::ApplicationVndOmaCabUserPrefsXml,
+    "application/vnd.oma.dcd" => Mime::ApplicationVndOmaDcd,
+    "application/vnd.oma.dcdc" => Mime::ApplicationVndOmaDcdc,
+    "application/vnd.oma.dd2+xml" => Mime::ApplicationVndOmaDd2Xml,
+    "application/vnd.oma.drm.risd+xml" => Mime::ApplicationVndOmaDrmRisdXml,
+    "application/vnd.oma.group-usage-list+xml" => Mime::ApplicationVndOmaGroupUsageListXml,
+    "application/vnd.oma.lwm2m+cbor" => Mime::ApplicationVndOmaLwm2mCbor,
+    "application/vnd.oma.lwm2m+json" => Mime::ApplicationVndOmaLwm2mJson,
+    "application/vnd.oma.lwm2m+tlv" => Mime::ApplicationVndOmaLwm2mTlv,
+    "application/vnd.oma.pal+xml" => Mime::ApplicationVndOmaPalXml,
+    "application/vnd.oma.poc.detailed-progress-report+xml" => Mime::ApplicationVndOmaPocDetailedProgressReportXml,
+    "application/vnd.oma.poc.final-report+xml" => Mime::ApplicationVndOmaPocFinalReportXml,
+    "application/vnd.oma.poc.groups+xml" => Mime::ApplicationVndOmaPocGroupsXml,
+    "application/vnd.oma.poc.invocation-descriptor+xml" => Mime::ApplicationVndOmaPocInvocationDescriptorXml,
+    "application/vnd.oma.poc.optimized-progress-report+xml" => Mime::ApplicationVndOmaPocOptimizedProgressReportXml,
+    "application/vnd.oma.push" => Mime::ApplicationVndOmaPush,
+    "application/vnd.oma.scidm.messages+xml" => Mime::ApplicationVndOmaScidmMessagesXml,
+    "application/vnd.oma.xcap-directory+xml" => Mime::ApplicationVndOmaXcapDirectoryXml,
+    "application/vnd.omads-email+xml" => Mime::ApplicationVndOmadsEmailXml,
+    "application/vnd.omads-file+xml" => Mime::ApplicationVndOmadsFileXml,
+    "application/vnd.omads-folder+xml" => Mime::ApplicationVndOmadsFolderXml,
+    "application/vnd.omaloc-supl-init" => Mime::ApplicationVndOmalocSuplInit,
+    "application/vnd.oma-scws-config" => Mime::ApplicationVndOmaScwsConfig,
+    "application/vnd.oma-scws-http-request" => Mime::ApplicationVndOmaScwsHttpRequest,
+    "application/vnd.oma-scws-http-response" => Mime::ApplicationVndOmaScwsHttpResponse,
+    "application/vnd.onepager" => Mime::ApplicationVndOnepager,
+    "application/vnd.onepagertamp" => Mime::ApplicationVndOnepagertamp,
+    "application/vnd.onepagertamx" => Mime::ApplicationVndOnepagertamx,
+    "application/vnd.onepagertat" => Mime::ApplicationVndOnepagertat,
+    "application/vnd.onepagertatp" => Mime::ApplicationVndOnepagertatp,
+    "application/vnd.onepagertatx" => Mime::ApplicationVndOnepagertatx,
+    "application/vnd.onvif.metadata" => Mime::ApplicationVndOnvifMetadata,
+    "application/vnd.openblox.game-binary" => Mime::ApplicationVndOpenbloxGameBinary,
+    "application/vnd.openblox.game+xml" => Mime::ApplicationVndOpenbloxGameXml,
+    "application/vnd.openeye.oeb" => Mime::ApplicationVndOpeneyeOeb,
+    "application/vnd.openstreetmap.data+xml" => Mime::ApplicationVndOpenstreetmapDataXml,
+    "application/vnd.opentimestamps.ots" => Mime::ApplicationVndOpentimestampsOts,
+    "application/vnd.openxmlformats-officedocument.custom-properties+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentCustomPropertiesXml,
+    "application/vnd.openxmlformats-officedocument.customXmlProperties+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentCustomxmlpropertiesXml,
+    "application/vnd.openxmlformats-officedocument.drawing+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentDrawingXml,
+    "application/vnd.openxmlformats-officedocument.drawingml.chart+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentDrawingmlChartXml,
+    "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentDrawingmlChartshapesXml,
+    "application/vnd.openxmlformats-officedocument.drawingml.diagramColors+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramcolorsXml,
+    "application/vnd.openxmlformats-officedocument.drawingml.diagramData+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramdataXml,
+    "application/vnd.openxmlformats-officedocument.drawingml.diagramLayout+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramlayoutXml,
+    "application/vnd.openxmlformats-officedocument.drawingml.diagramStyle+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramstyleXml,
+    "application/vnd.openxmlformats-officedocument.extended-properties+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentExtendedPropertiesXml,
+    "application/vnd.openxmlformats-officedocument.presentationml.commentAuthors+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlCommentauthorsXml,
+    "application/vnd.openxmlformats-officedocument.presentationml.comments+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlCommentsXml,
+    "application/vnd.openxmlformats-officedocument.presentationml.handoutMaster+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlHandoutmasterXml,
+    "application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlNotesmasterXml,
+    "application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlNotesslideXml,
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlPresentation,
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlPresentationMainXml,
+    "application/vnd.openxmlformats-officedocument.presentationml.presProps+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlPrespropsXml,
+    "application/vnd.openxmlformats-officedocument.presentationml.slide" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlide,
+    "application/vnd.openxmlformats-officedocument.presentationml.slide+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideXml,
+    "application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlidelayoutXml,
+    "application/vnd.openxmlformats-officedocument.presentationml.slideMaster+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlidemasterXml,
+    "application/vnd.openxmlformats-officedocument.presentationml.slideshow" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideshow,
+    "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideshowMainXml,
+    "application/vnd.openxmlformats-officedocument.presentationml.slideUpdateInfo+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideupdateinfoXml,
+    "application/vnd.openxmlformats-officedocument.presentationml.tableStyles+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlTablestylesXml,
+    "application/vnd.openxmlformats-officedocument.presentationml.tags+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlTagsXml,
+    "application/vnd.openxmlformats-officedocument.presentationml.template" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlTemplate,
+    "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlTemplateMainXml,
+    "application/vnd.openxmlformats-officedocument.presentationml.viewProps+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentPresentationmlViewpropsXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.calcChain+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlCalcchainXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlChartsheetXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlCommentsXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlConnectionsXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlDialogsheetXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.externalLink+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlExternallinkXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlPivotcachedefinitionXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlPivotcacherecordsXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlPivottableXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.queryTable+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlQuerytableXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionHeaders+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlRevisionheadersXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionLog+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlRevisionlogXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSharedstringsXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSheet,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSheetMainXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSheetmetadataXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlStylesXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTableXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.tableSingleCells+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTablesinglecellsXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.template" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTemplate,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTemplateMainXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.userNames+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlUsernamesXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.volatileDependencies+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlVolatiledependenciesXml,
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlWorksheetXml,
+    "application/vnd.openxmlformats-officedocument.theme+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentThemeXml,
+    "application/vnd.openxmlformats-officedocument.themeOverride+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentThemeoverrideXml,
+    "application/vnd.openxmlformats-officedocument.vmlDrawing" => Mime::ApplicationVndOpenxmlformatsOfficedocumentVmldrawing,
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlCommentsXml,
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document" => Mime::ApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlDocument,
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlDocumentGlossaryXml,
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlDocumentMainXml,
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlEndnotesXml,
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlFonttableXml,
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlFooterXml,
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlFootnotesXml,
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlNumberingXml,
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlSettingsXml,
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlStylesXml,
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.template" => Mime::ApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlTemplate,
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlTemplateMainXml,
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml" => Mime::ApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlWebsettingsXml,
+    "application/vnd.openxmlformats-package.core-properties+xml" => Mime::ApplicationVndOpenxmlformatsPackageCorePropertiesXml,
+    "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml" => Mime::ApplicationVndOpenxmlformatsPackageDigitalSignatureXmlsignatureXml,
+    "application/vnd.openxmlformats-package.relationships+xml" => Mime::ApplicationVndOpenxmlformatsPackageRelationshipsXml,
+    "application/vnd.oracle.resource+json" => Mime::ApplicationVndOracleResourceJson,
+    "application/vnd.orange.indata" => Mime::ApplicationVndOrangeIndata,
+    "application/vnd.osa.netdeploy" => Mime::ApplicationVndOsaNetdeploy,
+    "application/vnd.osgeo.mapguide.package" => Mime::ApplicationVndOsgeoMapguidePackage,
+    "application/vnd.osgi.bundle" => Mime::ApplicationVndOsgiBundle,
+    "application/vnd.osgi.dp" => Mime::ApplicationVndOsgiDp,
+    "application/vnd.osgi.subsystem" => Mime::ApplicationVndOsgiSubsystem,
+    "application/vnd.otps.ct-kip+xml" => Mime::ApplicationVndOtpsCtKipXml,
+    "application/vnd.oxli.countgraph" => Mime::ApplicationVndOxliCountgraph,
+    "application/vnd.pagerduty+json" => Mime::ApplicationVndPagerdutyJson,
+    "application/vnd.palm" => Mime::ApplicationVndPalm,
+    "application/vnd.panoply" => Mime::ApplicationVndPanoply,
+    "application/vnd.paos.xml" => Mime::ApplicationVndPaosXml,
+    "application/vnd.patentdive" => Mime::ApplicationVndPatentdive,
+    "application/vnd.patientecommsdoc" => Mime::ApplicationVndPatientecommsdoc,
+    "application/vnd.pawaafile" => Mime::ApplicationVndPawaafile,
+    "application/vnd.pcos" => Mime::ApplicationVndPcos,
+    "application/vnd.pg.format" => Mime::ApplicationVndPgFormat,
+    "application/vnd.pg.osasli" => Mime::ApplicationVndPgOsasli,
+    "application/vnd.piaccess.application-licence" => Mime::ApplicationVndPiaccessApplicationLicence,
+    "application/vnd.picsel" => Mime::ApplicationVndPicsel,
+    "application/vnd.pmi.widget" => Mime::ApplicationVndPmiWidget,
+    "application/vnd.poc.group-advertisement+xml" => Mime::ApplicationVndPocGroupAdvertisementXml,
+    "application/vnd.pocketlearn" => Mime::ApplicationVndPocketlearn,
+    "application/vnd.powerbuilder6" => Mime::ApplicationVndPowerbuilder6,
+    "application/vnd.powerbuilder6-s" => Mime::ApplicationVndPowerbuilder6S,
+    "application/vnd.powerbuilder7" => Mime::ApplicationVndPowerbuilder7,
+    "application/vnd.powerbuilder75" => Mime::ApplicationVndPowerbuilder75,
+    "application/vnd.powerbuilder75-s" => Mime::ApplicationVndPowerbuilder75S,
+    "application/vnd.powerbuilder7-s" => Mime::ApplicationVndPowerbuilder7S,
+    "application/vnd.preminet" => Mime::ApplicationVndPreminet,
+    "application/vnd.previewsystems.box" => Mime::ApplicationVndPreviewsystemsBox,
+    "application/vnd.proteus.magazine" => Mime::ApplicationVndProteusMagazine,
+    "application/vnd.psfs" => Mime::ApplicationVndPsfs,
+    "application/vnd.pt.mundusmundi" => Mime::ApplicationVndPtMundusmundi,
+    "application/vnd.publishare-delta-tree" => Mime::ApplicationVndPublishareDeltaTree,
+    "application/vnd.pvi.ptid1" => Mime::ApplicationVndPviPtid1,
+    "application/vnd.pwg-multiplexed" => Mime::ApplicationVndPwgMultiplexed,
+    "application/vnd.pwg-xhtml-print+xml" => Mime::ApplicationVndPwgXhtmlPrintXml,
+    "application/vnd.qualcomm.brew-app-res" => Mime::ApplicationVndQualcommBrewAppRes,
+    "application/vnd.quarantainenet" => Mime::ApplicationVndQuarantainenet,
+    "application/vnd.Quark.QuarkXPress" => Mime::ApplicationVndQuarkQuarkxpress,
+    "application/vnd.quobject-quoxdocument" => Mime::ApplicationVndQuobjectQuoxdocument,
+    "application/vnd.radisys.moml+xml" => Mime::ApplicationVndRadisysMomlXml,
+    "application/vnd.radisys.msml-audit-conf+xml" => Mime::ApplicationVndRadisysMsmlAuditConfXml,
+    "application/vnd.radisys.msml-audit-conn+xml" => Mime::ApplicationVndRadisysMsmlAuditConnXml,
+    "application/vnd.radisys.msml-audit-dialog+xml" => Mime::ApplicationVndRadisysMsmlAuditDialogXml,
+    "application/vnd.radisys.msml-audit-stream+xml" => Mime::ApplicationVndRadisysMsmlAuditStreamXml,
+    "application/vnd.radisys.msml-audit+xml" => Mime::ApplicationVndRadisysMsmlAuditXml,
+    "application/vnd.radisys.msml-conf+xml" => Mime::ApplicationVndRadisysMsmlConfXml,
+    "application/vnd.radisys.msml-dialog-base+xml" => Mime::ApplicationVndRadisysMsmlDialogBaseXml,
+    "application/vnd.radisys.msml-dialog-fax-detect+xml" => Mime::ApplicationVndRadisysMsmlDialogFaxDetectXml,
+    "application/vnd.radisys.msml-dialog-fax-sendrecv+xml" => Mime::ApplicationVndRadisysMsmlDialogFaxSendrecvXml,
+    "application/vnd.radisys.msml-dialog-group+xml" => Mime::ApplicationVndRadisysMsmlDialogGroupXml,
+    "application/vnd.radisys.msml-dialog-speech+xml" => Mime::ApplicationVndRadisysMsmlDialogSpeechXml,
+    "application/vnd.radisys.msml-dialog-transform+xml" => Mime::ApplicationVndRadisysMsmlDialogTransformXml,
+    "application/vnd.radisys.msml-dialog+xml" => Mime::ApplicationVndRadisysMsmlDialogXml,
+    "application/vnd.radisys.msml+xml" => Mime::ApplicationVndRadisysMsmlXml,
+    "application/vnd.rainstor.data" => Mime::ApplicationVndRainstorData,
+    "application/vnd.rapid" => Mime::ApplicationVndRapid,
+    "application/vnd.rar" => Mime::ApplicationVndRar,
+    "application/vnd.realvnc.bed" => Mime::ApplicationVndRealvncBed,
+    "application/vnd.recordare.musicxml" => Mime::ApplicationVndRecordareMusicxml,
+    "application/vnd.recordare.musicxml+xml" => Mime::ApplicationVndRecordareMusicxmlXml,
+    "application/vnd.RenLearn.rlprint" => Mime::ApplicationVndRenlearnRlprint,
+    "application/vnd.resilient.logic" => Mime::ApplicationVndResilientLogic,
+    "application/vnd.restful+json" => Mime::ApplicationVndRestfulJson,
+    "application/vnd.rig.cryptonote" => Mime::ApplicationVndRigCryptonote,
+    "application/vnd.route66.link66+xml" => Mime::ApplicationVndRoute66Link66Xml,
+    "application/vnd.rs-274x" => Mime::ApplicationVndRs274x,
+    "application/vnd.ruckus.download" => Mime::ApplicationVndRuckusDownload,
+    "application/vnd.s3sms" => Mime::ApplicationVndS3sms,
+    "application/vnd.sailingtracker.track" => Mime::ApplicationVndSailingtrackerTrack,
+    "application/vnd.sar" => Mime::ApplicationVndSar,
+    "application/vnd.sbm.cid" => Mime::ApplicationVndSbmCid,
+    "application/vnd.sbm.mid2" => Mime::ApplicationVndSbmMid2,
+    "application/vnd.scribus" => Mime::ApplicationVndScribus,
+    "application/vnd.sealed.3df" => Mime::ApplicationVndSealed3df,
+    "application/vnd.sealed.csf" => Mime::ApplicationVndSealedCsf,
+    "application/vnd.sealed.doc" => Mime::ApplicationVndSealedDoc,
+    "application/vnd.sealed.eml" => Mime::ApplicationVndSealedEml,
+    "application/vnd.sealed.mht" => Mime::ApplicationVndSealedMht,
+    "application/vnd.sealed.net" => Mime::ApplicationVndSealedNet,
+    "application/vnd.sealed.ppt" => Mime::ApplicationVndSealedPpt,
+    "application/vnd.sealed.tiff" => Mime::ApplicationVndSealedTiff,
+    "application/vnd.sealed.xls" => Mime::ApplicationVndSealedXls,
+    "application/vnd.sealedmedia.softseal.html" => Mime::ApplicationVndSealedmediaSoftsealHtml,
+    "application/vnd.sealedmedia.softseal.pdf" => Mime::ApplicationVndSealedmediaSoftsealPdf,
+    "application/vnd.seemail" => Mime::ApplicationVndSeemail,
+    "application/vnd.seis+json" => Mime::ApplicationVndSeisJson,
+    "application/vnd.sema" => Mime::ApplicationVndSema,
+    "application/vnd.semd" => Mime::ApplicationVndSemd,
+    "application/vnd.semf" => Mime::ApplicationVndSemf,
+    "application/vnd.shade-save-file" => Mime::ApplicationVndShadeSaveFile,
+    "application/vnd.shana.informed.formdata" => Mime::ApplicationVndShanaInformedFormdata,
+    "application/vnd.shana.informed.formtemplate" => Mime::ApplicationVndShanaInformedFormtemplate,
+    "application/vnd.shana.informed.interchange" => Mime::ApplicationVndShanaInformedInterchange,
+    "application/vnd.shana.informed.package" => Mime::ApplicationVndShanaInformedPackage,
+    "application/vnd.shootproof+json" => Mime::ApplicationVndShootproofJson,
+    "application/vnd.shopkick+json" => Mime::ApplicationVndShopkickJson,
+    "application/vnd.shp" => Mime::ApplicationVndShp,
+    "application/vnd.shx" => Mime::ApplicationVndShx,
+    "application/vnd.sigrok.session" => Mime::ApplicationVndSigrokSession,
+    "application/vnd.SimTech-MindMapper" => Mime::ApplicationVndSimtechMindmapper,
+    "application/vnd.siren+json" => Mime::ApplicationVndSirenJson,
+    "application/vnd.smaf" => Mime::ApplicationVndSmaf,
+    "application/vnd.smart.notebook" => Mime::ApplicationVndSmartNotebook,
+    "application/vnd.smart.teacher" => Mime::ApplicationVndSmartTeacher,
+    "application/vnd.smintio.portals.archive" => Mime::ApplicationVndSmintioPortalsArchive,
+    "application/vnd.snesdev-page-table" => Mime::ApplicationVndSnesdevPageTable,
+    "application/vnd.software602.filler.form+xml" => Mime::ApplicationVndSoftware602FillerFormXml,
+    "application/vnd.software602.filler.form-xml-zip" => Mime::ApplicationVndSoftware602FillerFormXmlZip,
+    "application/vnd.solent.sdkm+xml" => Mime::ApplicationVndSolentSdkmXml,
+    "application/vnd.spotfire.dxp" => Mime::ApplicationVndSpotfireDxp,
+    "application/vnd.spotfire.sfs" => Mime::ApplicationVndSpotfireSfs,
+    "application/vnd.sqlite3" => Mime::ApplicationVndSqlite3,
+    "application/vnd.sss-cod" => Mime::ApplicationVndSssCod,
+    "application/vnd.sss-dtf" => Mime::ApplicationVndSssDtf,
+    "application/vnd.sss-ntf" => Mime::ApplicationVndSssNtf,
+    "application/vnd.stepmania.package" => Mime::ApplicationVndStepmaniaPackage,
+    "application/vnd.stepmania.stepchart" => Mime::ApplicationVndStepmaniaStepchart,
+    "application/vnd.street-stream" => Mime::ApplicationVndStreetStream,
+    "application/vnd.sun.wadl+xml" => Mime::ApplicationVndSunWadlXml,
+    "application/vnd.sus-calendar" => Mime::ApplicationVndSusCalendar,
+    "application/vnd.svd" => Mime::ApplicationVndSvd,
+    "application/vnd.swiftview-ics" => Mime::ApplicationVndSwiftviewIcs,
+    "application/vnd.sybyl.mol2" => Mime::ApplicationVndSybylMol2,
+    "application/vnd.sycle+xml" => Mime::ApplicationVndSycleXml,
+    "application/vnd.syft+json" => Mime::ApplicationVndSyftJson,
+    "application/vnd.syncml.dm.notification" => Mime::ApplicationVndSyncmlDmNotification,
+    "application/vnd.syncml.dmddf+xml" => Mime::ApplicationVndSyncmlDmddfXml,
+    "application/vnd.syncml.dmtnds+wbxml" => Mime::ApplicationVndSyncmlDmtndsWbxml,
+    "application/vnd.syncml.dmtnds+xml" => Mime::ApplicationVndSyncmlDmtndsXml,
+    "application/vnd.syncml.dmddf+wbxml" => Mime::ApplicationVndSyncmlDmddfWbxml,
+    "application/vnd.syncml.dm+wbxml" => Mime::ApplicationVndSyncmlDmWbxml,
+    "application/vnd.syncml.dm+xml" => Mime::ApplicationVndSyncmlDmXml,
+    "application/vnd.syncml.ds.notification" => Mime::ApplicationVndSyncmlDsNotification,
+    "application/vnd.syncml+xml" => Mime::ApplicationVndSyncmlXml,
+    "application/vnd.tableschema+json" => Mime::ApplicationVndTableschemaJson,
+    "application/vnd.tao.intent-module-archive" => Mime::ApplicationVndTaoIntentModuleArchive,
+    "application/vnd.tcpdump.pcap" => Mime::ApplicationVndTcpdumpPcap,
+    "application/vnd.think-cell.ppttc+json" => Mime::ApplicationVndThinkCellPpttcJson,
+    "application/vnd.tml" => Mime::ApplicationVndTml,
+    "application/vnd.tmd.mediaflex.api+xml" => Mime::ApplicationVndTmdMediaflexApiXml,
+    "application/vnd.tmobile-livetv" => Mime::ApplicationVndTmobileLivetv,
+    "application/vnd.tri.onesource" => Mime::ApplicationVndTriOnesource,
+    "application/vnd.trid.tpt" => Mime::ApplicationVndTridTpt,
+    "application/vnd.triscape.mxs" => Mime::ApplicationVndTriscapeMxs,
+    "application/vnd.trueapp" => Mime::ApplicationVndTrueapp,
+    "application/vnd.truedoc" => Mime::ApplicationVndTruedoc,
+    "application/vnd.ubisoft.webplayer" => Mime::ApplicationVndUbisoftWebplayer,
+    "application/vnd.ufdl" => Mime::ApplicationVndUfdl,
+    "application/vnd.uiq.theme" => Mime::ApplicationVndUiqTheme,
+    "application/vnd.umajin" => Mime::ApplicationVndUmajin,
+    "application/vnd.unity" => Mime::ApplicationVndUnity,
+    "application/vnd.uoml+xml" => Mime::ApplicationVndUomlXml,
+    "application/vnd.uplanet.alert" => Mime::ApplicationVndUplanetAlert,
+    "application/vnd.uplanet.alert-wbxml" => Mime::ApplicationVndUplanetAlertWbxml,
+    "application/vnd.uplanet.bearer-choice" => Mime::ApplicationVndUplanetBearerChoice,
+    "application/vnd.uplanet.bearer-choice-wbxml" => Mime::ApplicationVndUplanetBearerChoiceWbxml,
+    "application/vnd.uplanet.cacheop" => Mime::ApplicationVndUplanetCacheop,
+    "application/vnd.uplanet.cacheop-wbxml" => Mime::ApplicationVndUplanetCacheopWbxml,
+    "application/vnd.uplanet.channel" => Mime::ApplicationVndUplanetChannel,
+    "application/vnd.uplanet.channel-wbxml" => Mime::ApplicationVndUplanetChannelWbxml,
+    "application/vnd.uplanet.list" => Mime::ApplicationVndUplanetList,
+    "application/vnd.uplanet.listcmd" => Mime::ApplicationVndUplanetListcmd,
+    "application/vnd.uplanet.listcmd-wbxml" => Mime::ApplicationVndUplanetListcmdWbxml,
+    "application/vnd.uplanet.list-wbxml" => Mime::ApplicationVndUplanetListWbxml,
+    "application/vnd.uri-map" => Mime::ApplicationVndUriMap,
+    "application/vnd.uplanet.signal" => Mime::ApplicationVndUplanetSignal,
+    "application/vnd.valve.source.material" => Mime::ApplicationVndValveSourceMaterial,
+    "application/vnd.vcx" => Mime::ApplicationVndVcx,
+    "application/vnd.vd-study" => Mime::ApplicationVndVdStudy,
+    "application/vnd.vectorworks" => Mime::ApplicationVndVectorworks,
+    "application/vnd.vel+json" => Mime::ApplicationVndVelJson,
+    "application/vnd.verimatrix.vcas" => Mime::ApplicationVndVerimatrixVcas,
+    "application/vnd.veritone.aion+json" => Mime::ApplicationVndVeritoneAionJson,
+    "application/vnd.veryant.thin" => Mime::ApplicationVndVeryantThin,
+    "application/vnd.ves.encrypted" => Mime::ApplicationVndVesEncrypted,
+    "application/vnd.vidsoft.vidconference" => Mime::ApplicationVndVidsoftVidconference,
+    "application/vnd.visio" => Mime::ApplicationVndVisio,
+    "application/vnd.visionary" => Mime::ApplicationVndVisionary,
+    "application/vnd.vividence.scriptfile" => Mime::ApplicationVndVividenceScriptfile,
+    "application/vnd.vsf" => Mime::ApplicationVndVsf,
+    "application/vnd.wap.sic" => Mime::ApplicationVndWapSic,
+    "application/vnd.wap.slc" => Mime::ApplicationVndWapSlc,
+    "application/vnd.wap.wbxml" => Mime::ApplicationVndWapWbxml,
+    "application/vnd.wap.wmlc" => Mime::ApplicationVndWapWmlc,
+    "application/vnd.wap.wmlscriptc" => Mime::ApplicationVndWapWmlscriptc,
+    "application/vnd.wasmflow.wafl" => Mime::ApplicationVndWasmflowWafl,
+    "application/vnd.webturbo" => Mime::ApplicationVndWebturbo,
+    "application/vnd.wfa.dpp" => Mime::ApplicationVndWfaDpp,
+    "application/vnd.wfa.p2p" => Mime::ApplicationVndWfaP2p,
+    "application/vnd.wfa.wsc" => Mime::ApplicationVndWfaWsc,
+    "application/vnd.windows.devicepairing" => Mime::ApplicationVndWindowsDevicepairing,
+    "application/vnd.wmc" => Mime::ApplicationVndWmc,
+    "application/vnd.wmf.bootstrap" => Mime::ApplicationVndWmfBootstrap,
+    "application/vnd.wolfram.mathematica" => Mime::ApplicationVndWolframMathematica,
+    "application/vnd.wolfram.mathematica.package" => Mime::ApplicationVndWolframMathematicaPackage,
+    "application/vnd.wolfram.player" => Mime::ApplicationVndWolframPlayer,
+    "application/vnd.wordlift" => Mime::ApplicationVndWordlift,
+    "application/vnd.wordperfect" => Mime::ApplicationVndWordperfect,
+    "application/vnd.wqd" => Mime::ApplicationVndWqd,
+    "application/vnd.wrq-hp3000-labelled" => Mime::ApplicationVndWrqHp3000Labelled,
+    "application/vnd.wt.stf" => Mime::ApplicationVndWtStf,
+    "application/vnd.wv.csp+xml" => Mime::ApplicationVndWvCspXml,
+    "application/vnd.wv.csp+wbxml" => Mime::ApplicationVndWvCspWbxml,
+    "application/vnd.wv.ssp+xml" => Mime::ApplicationVndWvSspXml,
+    "application/vnd.xacml+json" => Mime::ApplicationVndXacmlJson,
+    "application/vnd.xara" => Mime::ApplicationVndXara,
+    "application/vnd.xfdl" => Mime::ApplicationVndXfdl,
+    "application/vnd.xfdl.webform" => Mime::ApplicationVndXfdlWebform,
+    "application/vnd.xmi+xml" => Mime::ApplicationVndXmiXml,
+    "application/vnd.xmpie.cpkg" => Mime::ApplicationVndXmpieCpkg,
+    "application/vnd.xmpie.dpkg" => Mime::ApplicationVndXmpieDpkg,
+    "application/vnd.xmpie.plan" => Mime::ApplicationVndXmpiePlan,
+    "application/vnd.xmpie.ppkg" => Mime::ApplicationVndXmpiePpkg,
+    "application/vnd.xmpie.xlim" => Mime::ApplicationVndXmpieXlim,
+    "application/vnd.yamaha.hv-dic" => Mime::ApplicationVndYamahaHvDic,
+    "application/vnd.yamaha.hv-script" => Mime::ApplicationVndYamahaHvScript,
+    "application/vnd.yamaha.hv-voice" => Mime::ApplicationVndYamahaHvVoice,
+    "application/vnd.yamaha.openscoreformat.osfpvg+xml" => Mime::ApplicationVndYamahaOpenscoreformatOsfpvgXml,
+    "application/vnd.yamaha.openscoreformat" => Mime::ApplicationVndYamahaOpenscoreformat,
+    "application/vnd.yamaha.remote-setup" => Mime::ApplicationVndYamahaRemoteSetup,
+    "application/vnd.yamaha.smaf-audio" => Mime::ApplicationVndYamahaSmafAudio,
+    "application/vnd.yamaha.smaf-phrase" => Mime::ApplicationVndYamahaSmafPhrase,
+    "application/vnd.yamaha.through-ngn" => Mime::ApplicationVndYamahaThroughNgn,
+    "application/vnd.yamaha.tunnel-udpencap" => Mime::ApplicationVndYamahaTunnelUdpencap,
+    "application/vnd.yaoweme" => Mime::ApplicationVndYaoweme,
+    "application/vnd.yellowriver-custom-menu" => Mime::ApplicationVndYellowriverCustomMenu,
+    "application/vnd.zul" => Mime::ApplicationVndZul,
+    "application/vnd.zzazz.deck+xml" => Mime::ApplicationVndZzazzDeckXml,
+    "application/voicexml+xml" => Mime::ApplicationVoicexmlXml,
+    "application/voucher-cms+json" => Mime::ApplicationVoucherCmsJson,
+    "application/vq-rtcpxr" => Mime::ApplicationVqRtcpxr,
+    "application/wasm" => Mime::ApplicationWasm,
+    "application/watcherinfo+xml" => Mime::ApplicationWatcherinfoXml,
+    "application/webpush-options+json" => Mime::ApplicationWebpushOptionsJson,
+    "application/whoispp-query" => Mime::ApplicationWhoisppQuery,
+    "application/whoispp-response" => Mime::ApplicationWhoisppResponse,
+    "application/widget" => Mime::ApplicationWidget,
+    "application/wita" => Mime::ApplicationWita,
+    "application/wordperfect5.1" => Mime::ApplicationWordperfect51,
+    "application/wsdl+xml" => Mime::ApplicationWsdlXml,
+    "application/wspolicy+xml" => Mime::ApplicationWspolicyXml,
+    "application/x-pki-message" => Mime::ApplicationXPkiMessage,
+    "application/x-www-form-urlencoded" => Mime::ApplicationXWwwFormUrlencoded,
+    "application/x-x509-ca-cert" => Mime::ApplicationXX509CaCert,
+    "application/x-x509-ca-ra-cert" => Mime::ApplicationXX509CaRaCert,
+    "application/x-x509-next-ca-cert" => Mime::ApplicationXX509NextCaCert,
+    "application/x400-bp" => Mime::ApplicationX400Bp,
+    "application/xacml+xml" => Mime::ApplicationXacmlXml,
+    "application/xcap-att+xml" => Mime::ApplicationXcapAttXml,
+    "application/xcap-caps+xml" => Mime::ApplicationXcapCapsXml,
+    "application/xcap-diff+xml" => Mime::ApplicationXcapDiffXml,
+    "application/xcap-el+xml" => Mime::ApplicationXcapElXml,
+    "application/xcap-error+xml" => Mime::ApplicationXcapErrorXml,
+    "application/xcap-ns+xml" => Mime::ApplicationXcapNsXml,
+    "application/xcon-conference-info-diff+xml" => Mime::ApplicationXconConferenceInfoDiffXml,
+    "application/xcon-conference-info+xml" => Mime::ApplicationXconConferenceInfoXml,
+    "application/xenc+xml" => Mime::ApplicationXencXml,
+    "application/xfdf" => Mime::ApplicationXfdf,
+    "application/xhtml+xml" => Mime::ApplicationXhtmlXml,
+    "application/xliff+xml" => Mime::ApplicationXliffXml,
+    "application/xml" => Mime::ApplicationXml,
+    "application/xml-dtd" => Mime::ApplicationXmlDtd,
+    "application/xml-external-parsed-entity" => Mime::ApplicationXmlExternalParsedEntity,
+    "application/xml-patch+xml" => Mime::ApplicationXmlPatchXml,
+    "application/xmpp+xml" => Mime::ApplicationXmppXml,
+    "application/xop+xml" => Mime::ApplicationXopXml,
+    "application/xslt+xml" => Mime::ApplicationXsltXml,
+    "application/xv+xml" => Mime::ApplicationXvXml,
+    "application/yang" => Mime::ApplicationYang,
+    "application/yang-data+cbor" => Mime::ApplicationYangDataCbor,
+    "application/yang-data+json" => Mime::ApplicationYangDataJson,
+    "application/yang-data+xml" => Mime::ApplicationYangDataXml,
+    "application/yang-patch+json" => Mime::ApplicationYangPatchJson,
+    "application/yang-patch+xml" => Mime::ApplicationYangPatchXml,
+    "application/yin+xml" => Mime::ApplicationYinXml,
+    "application/zip" => Mime::ApplicationZip,
+    "application/zlib" => Mime::ApplicationZlib,
+    "application/zstd" => Mime::ApplicationZstd,
+    "audio/1d-interleaved-parityfec" => Mime::Audio1dInterleavedParityfec,
+    "audio/32kadpcm" => Mime::Audio32kadpcm,
+    "audio/3gpp" => Mime::Audio3gpp,
+    "audio/3gpp2" => Mime::Audio3gpp2,
+    "audio/aac" => Mime::AudioAac,
+    "audio/ac3" => Mime::AudioAc3,
+    "audio/AMR" => Mime::AudioAmr,
+    "audio/AMR-WB" => Mime::AudioAmrWb,
+    "audio/amr-wb+" => Mime::AudioAmrWbPlus,
+    "audio/aptx" => Mime::AudioAptx,
+    "audio/asc" => Mime::AudioAsc,
+    "audio/ATRAC-ADVANCED-LOSSLESS" => Mime::AudioAtracAdvancedLossless,
+    "audio/ATRAC-X" => Mime::AudioAtracX,
+    "audio/ATRAC3" => Mime::AudioAtrac3,
+    "audio/basic" => Mime::AudioBasic,
+    "audio/BV16" => Mime::AudioBv16,
+    "audio/BV32" => Mime::AudioBv32,
+    "audio/clearmode" => Mime::AudioClearmode,
+    "audio/CN" => Mime::AudioCn,
+    "audio/DAT12" => Mime::AudioDat12,
+    "audio/dls" => Mime::AudioDls,
+    "audio/dsr-es201108" => Mime::AudioDsrEs201108,
+    "audio/dsr-es202050" => Mime::AudioDsrEs202050,
+    "audio/dsr-es202211" => Mime::AudioDsrEs202211,
+    "audio/dsr-es202212" => Mime::AudioDsrEs202212,
+    "audio/DV" => Mime::AudioDv,
+    "audio/DVI4" => Mime::AudioDvi4,
+    "audio/eac3" => Mime::AudioEac3,
+    "audio/encaprtp" => Mime::AudioEncaprtp,
+    "audio/EVRC" => Mime::AudioEvrc,
+    "audio/EVRC-QCP" => Mime::AudioEvrcQcp,
+    "audio/EVRC0" => Mime::AudioEvrc0,
+    "audio/EVRC1" => Mime::AudioEvrc1,
+    "audio/EVRCB" => Mime::AudioEvrcb,
+    "audio/EVRCB0" => Mime::AudioEvrcb0,
+    "audio/EVRCB1" => Mime::AudioEvrcb1,
+    "audio/EVRCNW" => Mime::AudioEvrcnw,
+    "audio/EVRCNW0" => Mime::AudioEvrcnw0,
+    "audio/EVRCNW1" => Mime::AudioEvrcnw1,
+    "audio/EVRCWB" => Mime::AudioEvrcwb,
+    "audio/EVRCWB0" => Mime::AudioEvrcwb0,
+    "audio/EVRCWB1" => Mime::AudioEvrcwb1,
+    "audio/EVS" => Mime::AudioEvs,
+    "audio/example" => Mime::AudioExample,
+    "audio/flexfec" => Mime::AudioFlexfec,
+    "audio/fwdred" => Mime::AudioFwdred,
+    "audio/G711-0" => Mime::AudioG7110,
+    "audio/G719" => Mime::AudioG719,
+    "audio/G7221" => Mime::AudioG7221,
+    "audio/G722" => Mime::AudioG722,
+    "audio/G723" => Mime::AudioG723,
+    "audio/G726-16" => Mime::AudioG72616,
+    "audio/G726-24" => Mime::AudioG72624,
+    "audio/G726-32" => Mime::AudioG72632,
+    "audio/G726-40" => Mime::AudioG72640,
+    "audio/G728" => Mime::AudioG728,
+    "audio/G729" => Mime::AudioG729,
+    "audio/G7291" => Mime::AudioG7291,
+    "audio/G729D" => Mime::AudioG729d,
+    "audio/G729E" => Mime::AudioG729e,
+    "audio/GSM" => Mime::AudioGsm,
+    "audio/GSM-EFR" => Mime::AudioGsmEfr,
+    "audio/GSM-HR-08" => Mime::AudioGsmHr08,
+    "audio/iLBC" => Mime::AudioIlbc,
+    "audio/ip-mr_v2.5" => Mime::AudioIpMrV25 ,
+    "audio/L8" => Mime::AudioL8,
+    "audio/L16" => Mime::AudioL16,
+    "audio/L20" => Mime::AudioL20,
+    "audio/L24" => Mime::AudioL24,
+    "audio/LPC" => Mime::AudioLpc,
+    "audio/MELP" => Mime::AudioMelp,
+    "audio/MELP600" => Mime::AudioMelp600,
+    "audio/MELP1200" => Mime::AudioMelp1200,
+    "audio/MELP2400" => Mime::AudioMelp2400,
+    "audio/mhas" => Mime::AudioMhas,
+    "audio/mobile-xmf" => Mime::AudioMobileXmf,
+    "audio/MPA" => Mime::AudioMpa,
+    "audio/mp4" => Mime::AudioMp4,
+    "audio/MP4A-LATM" => Mime::AudioMp4aLatm,
+    "audio/mpa-robust" => Mime::AudioMpaRobust,
+    "audio/mpeg" => Mime::AudioMpeg,
+    "audio/mpeg4-generic" => Mime::AudioMpeg4Generic,
+    "audio/ogg" => Mime::AudioOgg,
+    "audio/opus" => Mime::AudioOpus,
+    "audio/parityfec" => Mime::AudioParityfec,
+    "audio/PCMA" => Mime::AudioPcma,
+    "audio/PCMA-WB" => Mime::AudioPcmaWb,
+    "audio/PCMU" => Mime::AudioPcmu,
+    "audio/PCMU-WB" => Mime::AudioPcmuWb,
+    "audio/prs.sid" => Mime::AudioPrsSid,
+    "audio/QCELP" => Mime::AudioQcelp,
+    "audio/raptorfec" => Mime::AudioRaptorfec,
+    "audio/RED" => Mime::AudioRed,
+    "audio/rtp-enc-aescm128" => Mime::AudioRtpEncAescm128,
+    "audio/rtploopback" => Mime::AudioRtploopback,
+    "audio/rtp-midi" => Mime::AudioRtpMidi,
+    "audio/rtx" => Mime::AudioRtx,
+    "audio/scip" => Mime::AudioScip,
+    "audio/SMV" => Mime::AudioSmv,
+    "audio/SMV0" => Mime::AudioSmv0,
+    "audio/SMV-QCP" => Mime::AudioSmvQcp,
+    "audio/sofa" => Mime::AudioSofa,
+    "audio/sp-midi" => Mime::AudioSpMidi,
+    "audio/speex" => Mime::AudioSpeex,
+    "audio/t140c" => Mime::AudioT140c,
+    "audio/t38" => Mime::AudioT38,
+    "audio/telephone-event" => Mime::AudioTelephoneEvent,
+    "audio/tone" => Mime::AudioTone,
+    "audio/TETRA_ACELP" => Mime::AudioTetraAcelp,
+    "audio/TETRA_ACELP_BB" => Mime::AudioTetraAcelpBb ,
+    "audio/TSVCIS" => Mime::AudioTsvcis,
+    "audio/UEMCLIP" => Mime::AudioUemclip,
+    "audio/ulpfec" => Mime::AudioUlpfec,
+    "audio/usac" => Mime::AudioUsac,
+    "audio/VDVI" => Mime::AudioVdvi,
+    "audio/VMR-WB" => Mime::AudioVmrWb,
+    "audio/vnd.3gpp.iufp" => Mime::AudioVnd3gppIufp,
+    "audio/vnd.4SB" => Mime::AudioVnd4sb,
+    "audio/vnd.audiokoz" => Mime::AudioVndAudiokoz,
+    "audio/vnd.CELP" => Mime::AudioVndCelp,
+    "audio/vnd.cisco.nse" => Mime::AudioVndCiscoNse,
+    "audio/vnd.cmles.radio-events" => Mime::AudioVndCmlesRadioEvents,
+    "audio/vnd.cns.anp1" => Mime::AudioVndCnsAnp1,
+    "audio/vnd.cns.inf1" => Mime::AudioVndCnsInf1,
+    "audio/vnd.dece.audio" => Mime::AudioVndDeceAudio,
+    "audio/vnd.digital-winds" => Mime::AudioVndDigitalWinds,
+    "audio/vnd.dlna.adts" => Mime::AudioVndDlnaAdts,
+    "audio/vnd.dolby.heaac.1" => Mime::AudioVndDolbyHeaac1,
+    "audio/vnd.dolby.heaac.2" => Mime::AudioVndDolbyHeaac2,
+    "audio/vnd.dolby.mlp" => Mime::AudioVndDolbyMlp,
+    "audio/vnd.dolby.mps" => Mime::AudioVndDolbyMps,
+    "audio/vnd.dolby.pl2" => Mime::AudioVndDolbyPl2,
+    "audio/vnd.dolby.pl2x" => Mime::AudioVndDolbyPl2x,
+    "audio/vnd.dolby.pl2z" => Mime::AudioVndDolbyPl2z,
+    "audio/vnd.dolby.pulse.1" => Mime::AudioVndDolbyPulse1,
+    "audio/vnd.dra" => Mime::AudioVndDra,
+    "audio/vnd.dts" => Mime::AudioVndDts,
+    "audio/vnd.dts.hd" => Mime::AudioVndDtsHd,
+    "audio/vnd.dts.uhd" => Mime::AudioVndDtsUhd,
+    "audio/vnd.dvb.file" => Mime::AudioVndDvbFile,
+    "audio/vnd.everad.plj" => Mime::AudioVndEveradPlj,
+    "audio/vnd.hns.audio" => Mime::AudioVndHnsAudio,
+    "audio/vnd.lucent.voice" => Mime::AudioVndLucentVoice,
+    "audio/vnd.ms-playready.media.pya" => Mime::AudioVndMsPlayreadyMediaPya,
+    "audio/vnd.nokia.mobile-xmf" => Mime::AudioVndNokiaMobileXmf,
+    "audio/vnd.nortel.vbk" => Mime::AudioVndNortelVbk,
+    "audio/vnd.nuera.ecelp4800" => Mime::AudioVndNueraEcelp4800,
+    "audio/vnd.nuera.ecelp7470" => Mime::AudioVndNueraEcelp7470,
+    "audio/vnd.nuera.ecelp9600" => Mime::AudioVndNueraEcelp9600,
+    "audio/vnd.octel.sbc" => Mime::AudioVndOctelSbc,
+    "audio/vnd.presonus.multitrack" => Mime::AudioVndPresonusMultitrack,
+    "audio/vnd.rhetorex.32kadpcm" => Mime::AudioVndRhetorex32kadpcm,
+    "audio/vnd.rip" => Mime::AudioVndRip,
+    "audio/vnd.sealedmedia.softseal.mpeg" => Mime::AudioVndSealedmediaSoftsealMpeg,
+    "audio/vnd.vmx.cvsd" => Mime::AudioVndVmxCvsd,
+    "audio/vorbis" => Mime::AudioVorbis,
+    "audio/vorbis-config" => Mime::AudioVorbisConfig,
+    "font/collection" => Mime::FontCollection,
+    "font/otf" => Mime::FontOtf,
+    "font/sfnt" => Mime::FontSfnt,
+    "font/ttf" => Mime::FontTtf,
+    "font/woff" => Mime::FontWoff,
+    "font/woff2" => Mime::FontWoff2,
+    "image/aces" => Mime::ImageAces,
+    "image/apng" => Mime::ImageApng,
+    "image/avci" => Mime::ImageAvci,
+    "image/avcs" => Mime::ImageAvcs,
+    "image/avif" => Mime::ImageAvif,
+    "image/bmp" => Mime::ImageBmp,
+    "image/cgm" => Mime::ImageCgm,
+    "image/dicom-rle" => Mime::ImageDicomRle,
+    "image/dpx" => Mime::ImageDpx,
+    "image/emf" => Mime::ImageEmf,
+    "image/example" => Mime::ImageExample,
+    "image/fits" => Mime::ImageFits,
+    "image/g3fax" => Mime::ImageG3fax,
+    "image/heic" => Mime::ImageHeic,
+    "image/heic-sequence" => Mime::ImageHeicSequence,
+    "image/heif" => Mime::ImageHeif,
+    "image/heif-sequence" => Mime::ImageHeifSequence,
+    "image/hej2k" => Mime::ImageHej2k,
+    "image/hsj2" => Mime::ImageHsj2,
+    "image/jls" => Mime::ImageJls,
+    "image/jp2" => Mime::ImageJp2,
+    "image/jpeg" => Mime::ImageJpeg,
+    "image/jph" => Mime::ImageJph,
+    "image/jphc" => Mime::ImageJphc,
+    "image/jpm" => Mime::ImageJpm,
+    "image/jpx" => Mime::ImageJpx,
+    "image/jxr" => Mime::ImageJxr,
+    "image/jxrA" => Mime::ImageJxra,
+    "image/jxrS" => Mime::ImageJxrs,
+    "image/jxs" => Mime::ImageJxs,
+    "image/jxsc" => Mime::ImageJxsc,
+    "image/jxsi" => Mime::ImageJxsi,
+    "image/jxss" => Mime::ImageJxss,
+    "image/ktx" => Mime::ImageKtx,
+    "image/ktx2" => Mime::ImageKtx2,
+    "image/naplps" => Mime::ImageNaplps,
+    "image/png" => Mime::ImagePng,
+    "image/prs.btif" => Mime::ImagePrsBtif,
+    "image/prs.pti" => Mime::ImagePrsPti,
+    "image/pwg-raster" => Mime::ImagePwgRaster,
+    "image/svg+xml" => Mime::ImageSvgXml,
+    "image/t38" => Mime::ImageT38,
+    "image/tiff" => Mime::ImageTiff,
+    "image/tiff-fx" => Mime::ImageTiffFx,
+    "image/vnd.adobe.photoshop" => Mime::ImageVndAdobePhotoshop,
+    "image/vnd.airzip.accelerator.azv" => Mime::ImageVndAirzipAcceleratorAzv,
+    "image/vnd.cns.inf2" => Mime::ImageVndCnsInf2,
+    "image/vnd.dece.graphic" => Mime::ImageVndDeceGraphic,
+    "image/vnd.djvu" => Mime::ImageVndDjvu,
+    "image/vnd.dwg" => Mime::ImageVndDwg,
+    "image/vnd.dxf" => Mime::ImageVndDxf,
+    "image/vnd.dvb.subtitle" => Mime::ImageVndDvbSubtitle,
+    "image/vnd.fastbidsheet" => Mime::ImageVndFastbidsheet,
+    "image/vnd.fpx" => Mime::ImageVndFpx,
+    "image/vnd.fst" => Mime::ImageVndFst,
+    "image/vnd.fujixerox.edmics-mmr" => Mime::ImageVndFujixeroxEdmicsMmr,
+    "image/vnd.fujixerox.edmics-rlc" => Mime::ImageVndFujixeroxEdmicsRlc,
+    "image/vnd.globalgraphics.pgb" => Mime::ImageVndGlobalgraphicsPgb,
+    "image/vnd.microsoft.icon" => Mime::ImageVndMicrosoftIcon,
+    "image/vnd.mix" => Mime::ImageVndMix,
+    "image/vnd.ms-modi" => Mime::ImageVndMsModi,
+    "image/vnd.mozilla.apng" => Mime::ImageVndMozillaApng,
+    "image/vnd.net-fpx" => Mime::ImageVndNetFpx,
+    "image/vnd.pco.b16" => Mime::ImageVndPcoB16,
+    "image/vnd.radiance" => Mime::ImageVndRadiance,
+    "image/vnd.sealed.png" => Mime::ImageVndSealedPng,
+    "image/vnd.sealedmedia.softseal.gif" => Mime::ImageVndSealedmediaSoftsealGif,
+    "image/vnd.sealedmedia.softseal.jpg" => Mime::ImageVndSealedmediaSoftsealJpg,
+    "image/vnd.svf" => Mime::ImageVndSvf,
+    "image/vnd.tencent.tap" => Mime::ImageVndTencentTap,
+    "image/vnd.valve.source.texture" => Mime::ImageVndValveSourceTexture,
+    "image/vnd.wap.wbmp" => Mime::ImageVndWapWbmp,
+    "image/vnd.xiff" => Mime::ImageVndXiff,
+    "image/vnd.zbrush.pcx" => Mime::ImageVndZbrushPcx,
+    "image/webp" => Mime::ImageWebp,
+    "image/wmf" => Mime::ImageWmf,
+    "message/bhttp" => Mime::MessageBhttp,
+    "message/CPIM" => Mime::MessageCpim,
+    "message/delivery-status" => Mime::MessageDeliveryStatus,
+    "message/disposition-notification" => Mime::MessageDispositionNotification,
+    "message/example" => Mime::MessageExample,
+    "message/feedback-report" => Mime::MessageFeedbackReport,
+    "message/global" => Mime::MessageGlobal,
+    "message/global-delivery-status" => Mime::MessageGlobalDeliveryStatus,
+    "message/global-disposition-notification" => Mime::MessageGlobalDispositionNotification,
+    "message/global-headers" => Mime::MessageGlobalHeaders,
+    "message/http" => Mime::MessageHttp,
+    "message/imdn+xml" => Mime::MessageImdnXml,
+    "message/mls" => Mime::MessageMls,
+    "message/ohttp-req" => Mime::MessageOhttpReq,
+    "message/ohttp-res" => Mime::MessageOhttpRes,
+    "message/sip" => Mime::MessageSip,
+    "message/sipfrag" => Mime::MessageSipfrag,
+    "message/tracking-status" => Mime::MessageTrackingStatus,
+    "message/vnd.wfa.wsc" => Mime::MessageVndWfaWsc,
+    "model/3mf" => Mime::Model3mf,
+    "model/e57" => Mime::ModelE57,
+    "model/example" => Mime::ModelExample,
+    "model/gltf-binary" => Mime::ModelGltfBinary,
+    "model/gltf+json" => Mime::ModelGltfJson,
+    "model/JT" => Mime::ModelJt,
+    "model/iges" => Mime::ModelIges,
+    "model/mtl" => Mime::ModelMtl,
+    "model/obj" => Mime::ModelObj,
+    "model/prc" => Mime::ModelPrc,
+    "model/step" => Mime::ModelStep,
+    "model/step+xml" => Mime::ModelStepXml,
+    "model/step+zip" => Mime::ModelStepZip,
+    "model/step-xml+zip" => Mime::ModelStepXmlZip,
+    "model/stl" => Mime::ModelStl,
+    "model/u3d" => Mime::ModelU3d,
+    "model/vnd.bary" => Mime::ModelVndBary,
+    "model/vnd.cld" => Mime::ModelVndCld,
+    "model/vnd.collada+xml" => Mime::ModelVndColladaXml,
+    "model/vnd.dwf" => Mime::ModelVndDwf,
+    "model/vnd.flatland.3dml" => Mime::ModelVndFlatland3dml,
+    "model/vnd.gdl" => Mime::ModelVndGdl,
+    "model/vnd.gs-gdl" => Mime::ModelVndGsGdl,
+    "model/vnd.gtw" => Mime::ModelVndGtw,
+    "model/vnd.moml+xml" => Mime::ModelVndMomlXml,
+    "model/vnd.mts" => Mime::ModelVndMts,
+    "model/vnd.opengex" => Mime::ModelVndOpengex,
+    "model/vnd.parasolid.transmit.binary" => Mime::ModelVndParasolidTransmitBinary,
+    "model/vnd.parasolid.transmit.text" => Mime::ModelVndParasolidTransmitText,
+    "model/vnd.pytha.pyox" => Mime::ModelVndPythaPyox,
+    "model/vnd.rosette.annotated-data-model" => Mime::ModelVndRosetteAnnotatedDataModel,
+    "model/vnd.sap.vds" => Mime::ModelVndSapVds,
+    "model/vnd.usda" => Mime::ModelVndUsda,
+    "model/vnd.usdz+zip" => Mime::ModelVndUsdzZip,
+    "model/vnd.valve.source.compiled-map" => Mime::ModelVndValveSourceCompiledMap,
+    "model/vnd.vtu" => Mime::ModelVndVtu,
+    "model/x3d-vrml" => Mime::ModelX3dVrml,
+    "model/x3d+fastinfoset" => Mime::ModelX3dFastinfoset,
+    "model/x3d+xml" => Mime::ModelX3dXml,
+    "multipart/appledouble" => Mime::MultipartAppledouble,
+    "multipart/byteranges" => Mime::MultipartByteranges,
+    "multipart/encrypted" => Mime::MultipartEncrypted,
+    "multipart/example" => Mime::MultipartExample,
+    "multipart/form-data" => Mime::MultipartFormData,
+    "multipart/header-set" => Mime::MultipartHeaderSet,
+    "multipart/multilingual" => Mime::MultipartMultilingual,
+    "multipart/related" => Mime::MultipartRelated,
+    "multipart/report" => Mime::MultipartReport,
+    "multipart/signed" => Mime::MultipartSigned,
+    "multipart/vnd.bint.med-plus" => Mime::MultipartVndBintMedPlus,
+    "multipart/voice-message" => Mime::MultipartVoiceMessage,
+    "multipart/x-mixed-replace" => Mime::MultipartXMixedReplace,
+    "text/1d-interleaved-parityfec" => Mime::Text1dInterleavedParityfec,
+    "text/cache-manifest" => Mime::TextCacheManifest,
+    "text/calendar" => Mime::TextCalendar,
+    "text/cql" => Mime::TextCql,
+    "text/cql-expression" => Mime::TextCqlExpression,
+    "text/cql-identifier" => Mime::TextCqlIdentifier,
+    "text/css" => Mime::TextCss,
+    "text/csv" => Mime::TextCsv,
+    "text/csv-schema" => Mime::TextCsvSchema,
+    "text/dns" => Mime::TextDns,
+    "text/encaprtp" => Mime::TextEncaprtp,
+    "text/example" => Mime::TextExample,
+    "text/fhirpath" => Mime::TextFhirpath,
+    "text/flexfec" => Mime::TextFlexfec,
+    "text/fwdred" => Mime::TextFwdred,
+    "text/gff3" => Mime::TextGff3,
+    "text/grammar-ref-list" => Mime::TextGrammarRefList,
+    "text/hl7v2" => Mime::TextHl7v2,
+    "text/html" => Mime::TextHtml,
+    "text/javascript" => Mime::TextJavascript,
+    "text/jcr-cnd" => Mime::TextJcrCnd,
+    "text/markdown" => Mime::TextMarkdown,
+    "text/mizar" => Mime::TextMizar,
+    "text/n3" => Mime::TextN3,
+    "text/parameters" => Mime::TextParameters,
+    "text/parityfec" => Mime::TextParityfec,
+    "text/plain" => Mime::TextPlain,
+    "text/provenance-notation" => Mime::TextProvenanceNotation,
+    "text/prs.fallenstein.rst" => Mime::TextPrsFallensteinRst,
+    "text/prs.lines.tag" => Mime::TextPrsLinesTag,
+    "text/prs.prop.logic" => Mime::TextPrsPropLogic,
+    "text/raptorfec" => Mime::TextRaptorfec,
+    "text/RED" => Mime::TextRed,
+    "text/rfc822-headers" => Mime::TextRfc822Headers,
+    "text/rtf" => Mime::TextRtf,
+    "text/rtp-enc-aescm128" => Mime::TextRtpEncAescm128,
+    "text/rtploopback" => Mime::TextRtploopback,
+    "text/rtx" => Mime::TextRtx,
+    "text/SGML" => Mime::TextSgml,
+    "text/shaclc" => Mime::TextShaclc,
+    "text/shex" => Mime::TextShex,
+    "text/spdx" => Mime::TextSpdx,
+    "text/strings" => Mime::TextStrings,
+    "text/t140" => Mime::TextT140,
+    "text/tab-separated-values" => Mime::TextTabSeparatedValues,
+    "text/troff" => Mime::TextTroff,
+    "text/turtle" => Mime::TextTurtle,
+    "text/ulpfec" => Mime::TextUlpfec,
+    "text/uri-list" => Mime::TextUriList,
+    "text/vcard" => Mime::TextVcard,
+    "text/vnd.a" => Mime::TextVndA,
+    "text/vnd.abc" => Mime::TextVndAbc,
+    "text/vnd.ascii-art" => Mime::TextVndAsciiArt,
+    "text/vnd.curl" => Mime::TextVndCurl,
+    "text/vnd.debian.copyright" => Mime::TextVndDebianCopyright,
+    "text/vnd.DMClientScript" => Mime::TextVndDmclientscript,
+    "text/vnd.dvb.subtitle" => Mime::TextVndDvbSubtitle,
+    "text/vnd.esmertec.theme-descriptor" => Mime::TextVndEsmertecThemeDescriptor,
+    "text/vnd.exchangeable" => Mime::TextVndExchangeable,
+    "text/vnd.familysearch.gedcom" => Mime::TextVndFamilysearchGedcom,
+    "text/vnd.ficlab.flt" => Mime::TextVndFiclabFlt,
+    "text/vnd.fly" => Mime::TextVndFly,
+    "text/vnd.fmi.flexstor" => Mime::TextVndFmiFlexstor,
+    "text/vnd.gml" => Mime::TextVndGml,
+    "text/vnd.graphviz" => Mime::TextVndGraphviz,
+    "text/vnd.hans" => Mime::TextVndHans,
+    "text/vnd.hgl" => Mime::TextVndHgl,
+    "text/vnd.in3d.3dml" => Mime::TextVndIn3d3dml,
+    "text/vnd.in3d.spot" => Mime::TextVndIn3dSpot,
+    "text/vnd.IPTC.NewsML" => Mime::TextVndIptcNewsml,
+    "text/vnd.IPTC.NITF" => Mime::TextVndIptcNitf,
+    "text/vnd.latex-z" => Mime::TextVndLatexZ,
+    "text/vnd.motorola.reflex" => Mime::TextVndMotorolaReflex,
+    "text/vnd.ms-mediapackage" => Mime::TextVndMsMediapackage,
+    "text/vnd.net2phone.commcenter.command" => Mime::TextVndNet2phoneCommcenterCommand,
+    "text/vnd.radisys.msml-basic-layout" => Mime::TextVndRadisysMsmlBasicLayout,
+    "text/vnd.senx.warpscript" => Mime::TextVndSenxWarpscript,
+    "text/vnd.sun.j2me.app-descriptor" => Mime::TextVndSunJ2meAppDescriptor,
+    "text/vnd.sosi" => Mime::TextVndSosi,
+    "text/vnd.trolltech.linguist" => Mime::TextVndTrolltechLinguist,
+    "text/vnd.wap.si" => Mime::TextVndWapSi,
+    "text/vnd.wap.sl" => Mime::TextVndWapSl,
+    "text/vnd.wap.wml" => Mime::TextVndWapWml,
+    "text/vnd.wap.wmlscript" => Mime::TextVndWapWmlscript,
+    "text/vtt" => Mime::TextVtt,
+    "text/wgsl" => Mime::TextWgsl,
+    "text/xml" => Mime::TextXml,
+    "text/xml-external-parsed-entity" => Mime::TextXmlExternalParsedEntity,
+    "video/1d-interleaved-parityfec" => Mime::Video1dInterleavedParityfec,
+    "video/3gpp" => Mime::Video3gpp,
+    "video/3gpp2" => Mime::Video3gpp2,
+    "video/3gpp-tt" => Mime::Video3gppTt,
+    "video/AV1" => Mime::VideoAv1,
+    "video/BMPEG" => Mime::VideoBmpeg,
+    "video/BT656" => Mime::VideoBt656,
+    "video/CelB" => Mime::VideoCelb,
+    "video/DV" => Mime::VideoDv,
+    "video/encaprtp" => Mime::VideoEncaprtp,
+    "video/example" => Mime::VideoExample,
+    "video/FFV1" => Mime::VideoFfv1,
+    "video/flexfec" => Mime::VideoFlexfec,
+    "video/H261" => Mime::VideoH261,
+    "video/H263" => Mime::VideoH263,
+    "video/H263-1998" => Mime::VideoH2631998,
+    "video/H263-2000" => Mime::VideoH2632000,
+    "video/H264" => Mime::VideoH264,
+    "video/H264-RCDO" => Mime::VideoH264Rcdo,
+    "video/H264-SVC" => Mime::VideoH264Svc,
+    "video/H265" => Mime::VideoH265,
+    "video/H266" => Mime::VideoH266,
+    "video/iso.segment" => Mime::VideoIsoSegment,
+    "video/JPEG" => Mime::VideoJpeg,
+    "video/jpeg2000" => Mime::VideoJpeg2000,
+    "video/jxsv" => Mime::VideoJxsv,
+    "video/mj2" => Mime::VideoMj2,
+    "video/MP1S" => Mime::VideoMp1s,
+    "video/MP2P" => Mime::VideoMp2p,
+    "video/MP2T" => Mime::VideoMp2t,
+    "video/mp4" => Mime::VideoMp4,
+    "video/MP4V-ES" => Mime::VideoMp4vEs,
+    "video/MPV" => Mime::VideoMpv,
+    "video/mpeg4-generic" => Mime::VideoMpeg4Generic,
+    "video/nv" => Mime::VideoNv,
+    "video/ogg" => Mime::VideoOgg,
+    "video/parityfec" => Mime::VideoParityfec,
+    "video/pointer" => Mime::VideoPointer,
+    "video/quicktime" => Mime::VideoQuicktime,
+    "video/raptorfec" => Mime::VideoRaptorfec,
+    "video/raw" => Mime::VideoRaw,
+    "video/rtp-enc-aescm128" => Mime::VideoRtpEncAescm128,
+    "video/rtploopback" => Mime::VideoRtploopback,
+    "video/rtx" => Mime::VideoRtx,
+    "video/scip" => Mime::VideoScip,
+    "video/smpte291" => Mime::VideoSmpte291,
+    "video/SMPTE292M" => Mime::VideoSmpte292m,
+    "video/ulpfec" => Mime::VideoUlpfec,
+    "video/vc1" => Mime::VideoVc1,
+    "video/vc2" => Mime::VideoVc2,
+    "video/vnd.CCTV" => Mime::VideoVndCctv,
+    "video/vnd.dece.hd" => Mime::VideoVndDeceHd,
+    "video/vnd.dece.mobile" => Mime::VideoVndDeceMobile,
+    "video/vnd.dece.mp4" => Mime::VideoVndDeceMp4,
+    "video/vnd.dece.pd" => Mime::VideoVndDecePd,
+    "video/vnd.dece.sd" => Mime::VideoVndDeceSd,
+    "video/vnd.dece.video" => Mime::VideoVndDeceVideo,
+    "video/vnd.directv.mpeg" => Mime::VideoVndDirectvMpeg,
+    "video/vnd.directv.mpeg-tts" => Mime::VideoVndDirectvMpegTts,
+    "video/vnd.dlna.mpeg-tts" => Mime::VideoVndDlnaMpegTts,
+    "video/vnd.dvb.file" => Mime::VideoVndDvbFile,
+    "video/vnd.fvt" => Mime::VideoVndFvt,
+    "video/vnd.hns.video" => Mime::VideoVndHnsVideo,
+    "video/vnd.iptvforum.1dparityfec-1010" => Mime::VideoVndIptvforum1dparityfec1010,
+    "video/vnd.iptvforum.1dparityfec-2005" => Mime::VideoVndIptvforum1dparityfec2005,
+    "video/vnd.iptvforum.2dparityfec-1010" => Mime::VideoVndIptvforum2dparityfec1010,
+    "video/vnd.iptvforum.2dparityfec-2005" => Mime::VideoVndIptvforum2dparityfec2005,
+    "video/vnd.iptvforum.ttsavc" => Mime::VideoVndIptvforumTtsavc,
+    "video/vnd.iptvforum.ttsmpeg2" => Mime::VideoVndIptvforumTtsmpeg2,
+    "video/vnd.motorola.video" => Mime::VideoVndMotorolaVideo,
+    "video/vnd.motorola.videop" => Mime::VideoVndMotorolaVideop,
+    "video/vnd.mpegurl" => Mime::VideoVndMpegurl,
+    "video/vnd.ms-playready.media.pyv" => Mime::VideoVndMsPlayreadyMediaPyv,
+    "video/vnd.nokia.interleaved-multimedia" => Mime::VideoVndNokiaInterleavedMultimedia,
+    "video/vnd.nokia.mp4vr" => Mime::VideoVndNokiaMp4vr,
+    "video/vnd.nokia.videovoip" => Mime::VideoVndNokiaVideovoip,
+    "video/vnd.objectvideo" => Mime::VideoVndObjectvideo,
+    "video/vnd.radgamettools.bink" => Mime::VideoVndRadgamettoolsBink,
+    "video/vnd.radgamettools.smacker" => Mime::VideoVndRadgamettoolsSmacker,
+    "video/vnd.sealed.mpeg1" => Mime::VideoVndSealedMpeg1,
+    "video/vnd.sealed.mpeg4" => Mime::VideoVndSealedMpeg4,
+    "video/vnd.sealed.swf" => Mime::VideoVndSealedSwf,
+    "video/vnd.sealedmedia.softseal.mov" => Mime::VideoVndSealedmediaSoftsealMov,
+    "video/vnd.uvvu.mp4" => Mime::VideoVndUvvuMp4,
+    "video/vnd.youtube.yt" => Mime::VideoVndYoutubeYt,
+    "video/vnd.vivo" => Mime::VideoVndVivo,
+    "video/VP8" => Mime::VideoVp8,
+    "video/VP9" => Mime::VideoVp9,
+};