diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RustServerCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RustServerCodegen.java
index 8db58ea2add8867af2fc2f06154a751911315e34..b866f71569b73e0eb9542bc3fa0fbc6db29857ad 100644
--- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RustServerCodegen.java
+++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RustServerCodegen.java
@@ -227,6 +227,7 @@ public class RustServerCodegen extends DefaultCodegen implements CodegenConfig {
         supportingFiles.add(new SupportingFile("gitignore", "", ".gitignore"));
         supportingFiles.add(new SupportingFile("lib.mustache", "src", "lib.rs"));
         supportingFiles.add(new SupportingFile("models.mustache", "src", "models.rs"));
+        supportingFiles.add(new SupportingFile("header.mustache", "src", "header.rs"));
         supportingFiles.add(new SupportingFile("server-mod.mustache", "src/server", "mod.rs"));
         supportingFiles.add(new SupportingFile("server-context.mustache", "src/server", "context.rs"));
         supportingFiles.add(new SupportingFile("client-mod.mustache", "src/client", "mod.rs"));
diff --git a/modules/openapi-generator/src/main/resources/rust-server/client-mod.mustache b/modules/openapi-generator/src/main/resources/rust-server/client-mod.mustache
index 8b7b2ecea995e9687e251a81676be44eadfb88f0..6b911492f90d4b38e56a9fc9c9e9c0d8e980f51a 100644
--- a/modules/openapi-generator/src/main/resources/rust-server/client-mod.mustache
+++ b/modules/openapi-generator/src/main/resources/rust-server/client-mod.mustache
@@ -48,6 +48,7 @@ use {Api{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}},
 
 use mimetypes;
 use models;
+use header;
 
 define_encode_set! {
     /// This encode set is used for object IDs
@@ -528,12 +529,12 @@ impl<C, F> Api<C> for Client<F> where
 {{#required}}
         request.headers_mut().append(
             HeaderName::from_static("{{{nameInLowerCase}}}"),
-            swagger::IntoHeaderValue(param_{{{paramName}}}.clone()).into());
+            header::IntoHeaderValue(param_{{{paramName}}}.clone()).into());
 {{/required}}
 {{^required}}
         param_{{{paramName}}}.map(|value| request.headers_mut().append(
             HeaderName::from_static("{{{nameInLowerCase}}}"),
-            swagger::IntoHeaderValue(value.clone()).into()));
+            header::IntoHeaderValue(value.clone()).into()));
 {{/required}}
 {{/isMapContainer}}
 {{#isMapContainer}}
@@ -595,7 +596,7 @@ impl<C, F> Api<C> for Client<F> where
                             {
                                body: body,
     {{/-first}}
-                               {{{name}}}: (*Into::<swagger::IntoHeaderValue<{{{dataType}}}>>::into(response_{{{name}}})).clone(),
+                               {{{name}}}: (*Into::<header::IntoHeaderValue<{{{dataType}}}>>::into(response_{{{name}}})).clone(),
     {{#-last}}
                             }
     {{/-last}}
@@ -609,7 +610,7 @@ impl<C, F> Api<C> for Client<F> where
   {{#-first}}
                             {
   {{/-first}}
-                              {{{name}}}: (*Into::<swagger::IntoHeaderValue<{{{dataType}}}>>::into(response_{{{name}}})).clone(),
+                              {{{name}}}: (*Into::<header::IntoHeaderValue<{{{dataType}}}>>::into(response_{{{name}}})).clone(),
   {{#-last}}
                             }
   {{/-last}}
diff --git a/modules/openapi-generator/src/main/resources/rust-server/header.mustache b/modules/openapi-generator/src/main/resources/rust-server/header.mustache
new file mode 100644
index 0000000000000000000000000000000000000000..d67419356f7f8f7f9e417bf4c1f3ce1e3c611743
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/rust-server/header.mustache
@@ -0,0 +1,99 @@
+use chrono::{DateTime, Utc};
+use hyper::header::HeaderValue;
+use std::fmt;
+use std::ops::Deref;
+
+/// A struct to allow homogeneous conversion into a HeaderValue. We can't
+/// implement the From/Into trait on HeaderValue because we don't own
+/// either of the types.
+#[derive(Debug, Clone)]
+pub struct IntoHeaderValue<T>(pub T);
+
+// Generic implementations
+
+impl<T> Deref for IntoHeaderValue<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &self.0
+    }
+}
+
+// Derive for each From<T> in hyper::header::HeaderValue
+
+macro_rules! ihv_generate {
+    ($t:ident) => {
+        impl From<HeaderValue> for IntoHeaderValue<$t> {
+            fn from(hdr_value: HeaderValue) -> Self {
+                IntoHeaderValue(hdr_value.to_str().unwrap().parse::<$t>().unwrap())
+            }
+        }
+
+        impl From<IntoHeaderValue<$t>> for HeaderValue {
+            fn from(hdr_value: IntoHeaderValue<$t>) -> Self {
+                hdr_value.0.into()
+            }
+        }
+    };
+}
+
+ihv_generate!(u64);
+ihv_generate!(i64);
+ihv_generate!(i16);
+ihv_generate!(u16);
+ihv_generate!(u32);
+ihv_generate!(usize);
+ihv_generate!(isize);
+ihv_generate!(i32);
+
+// Custom derivations
+
+impl From<HeaderValue> for IntoHeaderValue<Vec<String>> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(
+            hdr_value
+                .to_str()
+                .unwrap()
+                .split(',')
+                .filter_map(|x| match x.trim() {
+                    "" => None,
+                    y => Some(y.to_string()),
+                })
+                .collect(),
+        )
+    }
+}
+
+impl From<IntoHeaderValue<Vec<String>>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<Vec<String>>) -> Self {
+        HeaderValue::from_str(&hdr_value.0.join(", ")).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<String> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(hdr_value.to_str().unwrap().to_string())
+    }
+}
+
+impl From<IntoHeaderValue<String>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<String>) -> Self {
+        HeaderValue::from_str(&hdr_value.0).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<DateTime<Utc>> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(
+            DateTime::parse_from_rfc3339(hdr_value.to_str().unwrap())
+                .unwrap()
+                .with_timezone(&Utc),
+        )
+    }
+}
+
+impl From<IntoHeaderValue<DateTime<Utc>>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<DateTime<Utc>>) -> Self {
+        HeaderValue::from_str(hdr_value.0.to_rfc3339().as_str()).unwrap()
+    }
+}
diff --git a/modules/openapi-generator/src/main/resources/rust-server/lib.mustache b/modules/openapi-generator/src/main/resources/rust-server/lib.mustache
index 56f67e937fcaefabf498b11fc9b22b30e11cdc74..802905b23e77603dec39a21f6672a775516fc29a 100644
--- a/modules/openapi-generator/src/main/resources/rust-server/lib.mustache
+++ b/modules/openapi-generator/src/main/resources/rust-server/lib.mustache
@@ -178,3 +178,4 @@ pub mod server;
 pub use self::server::Service;
 
 pub mod models;
+pub mod header;
diff --git a/modules/openapi-generator/src/main/resources/rust-server/models.mustache b/modules/openapi-generator/src/main/resources/rust-server/models.mustache
index d05c7f7d5efaff0145b9817dd901abd72948d64a..74b81b82b88f822624391131b0d66f38cc451156 100644
--- a/modules/openapi-generator/src/main/resources/rust-server/models.mustache
+++ b/modules/openapi-generator/src/main/resources/rust-server/models.mustache
@@ -13,10 +13,13 @@ use std::collections::HashMap;
 {{/usesXml}}
 use models;
 use swagger;
+use hyper::header::HeaderValue;
 use std::string::ParseError;
 {{#apiUsesUuid}}
 use uuid;
 {{/apiUsesUuid}}
+use std::str::FromStr;
+use header::IntoHeaderValue;
 
 {{#models}}{{#model}}
 {{#description}}/// {{{description}}}
@@ -99,7 +102,22 @@ impl ::std::ops::DerefMut for {{{classname}}} {
     }
 }
 
-{{/dataType}}{{^dataType}}{{#arrayModelType}}{{#vendorExtensions}}{{#itemXmlName}}// Utility function for wrapping list elements when serializing xml
+{{/dataType}}{{^dataType}}
+// Methods for converting between IntoHeaderValue<{{{classname}}}> and HeaderValue
+
+impl From<IntoHeaderValue<{{{classname}}}>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<{{{classname}}}>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<{{{classname}}}> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue({{{classname}}}::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
+{{#arrayModelType}}{{#vendorExtensions}}{{#itemXmlName}}// Utility function for wrapping list elements when serializing xml
 #[allow(non_snake_case)]
 fn wrap_in_{{{itemXmlName}}}<S>(item: &Vec<{{{arrayModelType}}}>, serializer: S) -> Result<S::Ok, S::Error>
 where
diff --git a/modules/openapi-generator/src/main/resources/rust-server/server-mod.mustache b/modules/openapi-generator/src/main/resources/rust-server/server-mod.mustache
index bea189c3c7c0809f6cd973559cec451f5e913738..d4512f011b4db31c775138dd29035ded606e0ee6 100644
--- a/modules/openapi-generator/src/main/resources/rust-server/server-mod.mustache
+++ b/modules/openapi-generator/src/main/resources/rust-server/server-mod.mustache
@@ -40,6 +40,7 @@ use {Api{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}},
 
 #[allow(unused_imports)]
 use models;
+use header;
 
 pub mod context;
 
@@ -225,7 +226,7 @@ where
 
   {{#required}}
                 let param_{{{paramName}}} = match param_{{{paramName}}})) {
-                    Some(v) => Some(swagger::IntoHeaderValue::<{{{dataType}}}>::from(v)).0),
+                    Some(v) => Some(header::IntoHeaderValue::<{{{dataType}}}>::from(v)).0),
                     None => return Box::new(future::ok(Response::builder()
                                         .status(StatusCode::BAD_REQUEST)
                                         .body(Body::from("Missing or invalid required header {{{baseName}}}"))
@@ -234,7 +235,7 @@ where
   {{/required}}
   {{^required}}
                 let param_{{{paramName}}} = param_{{{paramName}}}.map(|p| {
-                        swagger::IntoHeaderValue::<{{{dataType}}}>::from((*p).clone()).0
+                        header::IntoHeaderValue::<{{{dataType}}}>::from((*p).clone()).0
                 });
   {{/required}}
 {{/headerParams}}
@@ -596,7 +597,7 @@ where
 {{#headers}}
                                                     response.headers_mut().insert(
                                                         HeaderName::from_static("{{{nameInLowerCase}}}"),
-                                                        swagger::IntoHeaderValue({{name}}).into()
+                                                        header::IntoHeaderValue({{name}}).into()
                                                     );
 {{/headers}}
 {{#produces}}{{#-first}}{{#dataType}}
diff --git a/modules/openapi-generator/src/test/resources/3_0/rust-server/openapi-v3.yaml b/modules/openapi-generator/src/test/resources/3_0/rust-server/openapi-v3.yaml
index d67a47a893024928902b0f9cd56bc453060bf466..e4d2be8fdd2ca618d1340be0c47a5c790cd27b4a 100644
--- a/modules/openapi-generator/src/test/resources/3_0/rust-server/openapi-v3.yaml
+++ b/modules/openapi-generator/src/test/resources/3_0/rust-server/openapi-v3.yaml
@@ -178,6 +178,9 @@ paths:
             Success-Info:
               schema:
                 type: String
+            Object-Header:
+              schema:
+                $ref: "#/components/schemas/ObjectHeader"
         '412':
           description: Precondition Failed
           headers:
@@ -187,6 +190,17 @@ paths:
             Failure-Info:
               schema:
                 type: String
+  /mandatory-request-header:
+    get:
+      parameters:
+        - name: X-Header
+          in: header
+          required: true
+          schema:
+            type: string
+      responses:
+        '200':
+          description: Success
 
 components:
   securitySchemes:
@@ -282,3 +296,16 @@ components:
         $ref: '#/components/schemas/MyID'
     MyID:
       type: integer
+    ObjectHeader:
+      type: object
+      required:
+        - requiredObjectHeader
+      properties:
+        requiredObjectHeader:
+          $ref: '#/components/schemas/RequiredObjectHeader'
+        optionalObjectHeader:
+          $ref: '#/components/schemas/OptionalObjectHeader'
+    RequiredObjectHeader:
+      type: boolean
+    OptionalObjectHeader:
+      type: integer
diff --git a/samples/server/petstore/rust-server/output/multipart-v3/src/client/mod.rs b/samples/server/petstore/rust-server/output/multipart-v3/src/client/mod.rs
index 73f323958e39fbb32d0f94add81b175a80b4ab0e..427d1225b1fe7d95f093b208d27362d63ffa71c6 100644
--- a/samples/server/petstore/rust-server/output/multipart-v3/src/client/mod.rs
+++ b/samples/server/petstore/rust-server/output/multipart-v3/src/client/mod.rs
@@ -39,6 +39,7 @@ use {Api,
 
 use mimetypes;
 use models;
+use header;
 
 define_encode_set! {
     /// This encode set is used for object IDs
diff --git a/samples/server/petstore/rust-server/output/multipart-v3/src/header.rs b/samples/server/petstore/rust-server/output/multipart-v3/src/header.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d67419356f7f8f7f9e417bf4c1f3ce1e3c611743
--- /dev/null
+++ b/samples/server/petstore/rust-server/output/multipart-v3/src/header.rs
@@ -0,0 +1,99 @@
+use chrono::{DateTime, Utc};
+use hyper::header::HeaderValue;
+use std::fmt;
+use std::ops::Deref;
+
+/// A struct to allow homogeneous conversion into a HeaderValue. We can't
+/// implement the From/Into trait on HeaderValue because we don't own
+/// either of the types.
+#[derive(Debug, Clone)]
+pub struct IntoHeaderValue<T>(pub T);
+
+// Generic implementations
+
+impl<T> Deref for IntoHeaderValue<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &self.0
+    }
+}
+
+// Derive for each From<T> in hyper::header::HeaderValue
+
+macro_rules! ihv_generate {
+    ($t:ident) => {
+        impl From<HeaderValue> for IntoHeaderValue<$t> {
+            fn from(hdr_value: HeaderValue) -> Self {
+                IntoHeaderValue(hdr_value.to_str().unwrap().parse::<$t>().unwrap())
+            }
+        }
+
+        impl From<IntoHeaderValue<$t>> for HeaderValue {
+            fn from(hdr_value: IntoHeaderValue<$t>) -> Self {
+                hdr_value.0.into()
+            }
+        }
+    };
+}
+
+ihv_generate!(u64);
+ihv_generate!(i64);
+ihv_generate!(i16);
+ihv_generate!(u16);
+ihv_generate!(u32);
+ihv_generate!(usize);
+ihv_generate!(isize);
+ihv_generate!(i32);
+
+// Custom derivations
+
+impl From<HeaderValue> for IntoHeaderValue<Vec<String>> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(
+            hdr_value
+                .to_str()
+                .unwrap()
+                .split(',')
+                .filter_map(|x| match x.trim() {
+                    "" => None,
+                    y => Some(y.to_string()),
+                })
+                .collect(),
+        )
+    }
+}
+
+impl From<IntoHeaderValue<Vec<String>>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<Vec<String>>) -> Self {
+        HeaderValue::from_str(&hdr_value.0.join(", ")).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<String> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(hdr_value.to_str().unwrap().to_string())
+    }
+}
+
+impl From<IntoHeaderValue<String>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<String>) -> Self {
+        HeaderValue::from_str(&hdr_value.0).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<DateTime<Utc>> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(
+            DateTime::parse_from_rfc3339(hdr_value.to_str().unwrap())
+                .unwrap()
+                .with_timezone(&Utc),
+        )
+    }
+}
+
+impl From<IntoHeaderValue<DateTime<Utc>>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<DateTime<Utc>>) -> Self {
+        HeaderValue::from_str(hdr_value.0.to_rfc3339().as_str()).unwrap()
+    }
+}
diff --git a/samples/server/petstore/rust-server/output/multipart-v3/src/lib.rs b/samples/server/petstore/rust-server/output/multipart-v3/src/lib.rs
index 5a537443398dc23529ae4e98b4141f1ab7a11b1e..9fb1870c89a467704b48aed070466c9f6c8284a6 100644
--- a/samples/server/petstore/rust-server/output/multipart-v3/src/lib.rs
+++ b/samples/server/petstore/rust-server/output/multipart-v3/src/lib.rs
@@ -159,3 +159,4 @@ pub mod server;
 pub use self::server::Service;
 
 pub mod models;
+pub mod header;
diff --git a/samples/server/petstore/rust-server/output/multipart-v3/src/models.rs b/samples/server/petstore/rust-server/output/multipart-v3/src/models.rs
index da2eb016dac61da54df5e153db282527ddcd2d20..b6817f39324187670728abfae4ea6f4107e96fbc 100644
--- a/samples/server/petstore/rust-server/output/multipart-v3/src/models.rs
+++ b/samples/server/petstore/rust-server/output/multipart-v3/src/models.rs
@@ -5,9 +5,27 @@ use serde::ser::Serializer;
 use std::collections::HashMap;
 use models;
 use swagger;
+use hyper::header::HeaderValue;
 use std::string::ParseError;
+use std::str::FromStr;
+use header::IntoHeaderValue;
 
 
+
+// Methods for converting between IntoHeaderValue<MultipartRelatedRequest> and HeaderValue
+
+impl From<IntoHeaderValue<MultipartRelatedRequest>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<MultipartRelatedRequest>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<MultipartRelatedRequest> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(MultipartRelatedRequest::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct MultipartRelatedRequest {
@@ -35,6 +53,21 @@ impl MultipartRelatedRequest {
 }
 
 
+
+// Methods for converting between IntoHeaderValue<MultipartRequest> and HeaderValue
+
+impl From<IntoHeaderValue<MultipartRequest>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<MultipartRequest>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<MultipartRequest> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(MultipartRequest::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct MultipartRequest {
@@ -66,6 +99,21 @@ impl MultipartRequest {
 }
 
 
+
+// Methods for converting between IntoHeaderValue<MultipartRequestObjectField> and HeaderValue
+
+impl From<IntoHeaderValue<MultipartRequestObjectField>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<MultipartRequestObjectField>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<MultipartRequestObjectField> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(MultipartRequestObjectField::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct MultipartRequestObjectField {
diff --git a/samples/server/petstore/rust-server/output/multipart-v3/src/server/mod.rs b/samples/server/petstore/rust-server/output/multipart-v3/src/server/mod.rs
index 2661285ce7a03267e96069a32f223af85467dca7..a3df258532f39e14189a5df97f445f0915d00a82 100644
--- a/samples/server/petstore/rust-server/output/multipart-v3/src/server/mod.rs
+++ b/samples/server/petstore/rust-server/output/multipart-v3/src/server/mod.rs
@@ -31,6 +31,7 @@ use {Api,
 
 #[allow(unused_imports)]
 use models;
+use header;
 
 pub mod context;
 
diff --git a/samples/server/petstore/rust-server/output/openapi-v3/README.md b/samples/server/petstore/rust-server/output/openapi-v3/README.md
index 4e5bf34fbbfa696e7c705b4aa76abbbc1adef284..5ba22fbbed7078608a5307bd067a1e9cae1d35c8 100644
--- a/samples/server/petstore/rust-server/output/openapi-v3/README.md
+++ b/samples/server/petstore/rust-server/output/openapi-v3/README.md
@@ -61,6 +61,7 @@ cargo run --example server
 To run a client, follow one of the following simple steps:
 
 ```
+cargo run --example client MandatoryRequestHeaderGet
 cargo run --example client MultigetGet
 cargo run --example client MultipleAuthSchemeGet
 cargo run --example client ReadonlyAuthSchemeGet
@@ -105,6 +106,7 @@ All URIs are relative to *http://localhost*
 
 Method | HTTP request | Description
 ------------- | ------------- | -------------
+[****](docs/default_api.md#) | **GET** /mandatory-request-header | 
 [****](docs/default_api.md#) | **GET** /multiget | Get some stuff.
 [****](docs/default_api.md#) | **GET** /multiple_auth_scheme | 
 [****](docs/default_api.md#) | **GET** /readonly_auth_scheme | 
@@ -128,7 +130,10 @@ Method | HTTP request | Description
  - [InlineResponse201](docs/InlineResponse201.md)
  - [MyId](docs/MyId.md)
  - [MyIdList](docs/MyIdList.md)
+ - [ObjectHeader](docs/ObjectHeader.md)
  - [ObjectWithArrayOfObjects](docs/ObjectWithArrayOfObjects.md)
+ - [OptionalObjectHeader](docs/OptionalObjectHeader.md)
+ - [RequiredObjectHeader](docs/RequiredObjectHeader.md)
  - [StringObject](docs/StringObject.md)
  - [UuidObject](docs/UuidObject.md)
  - [XmlArray](docs/XmlArray.md)
diff --git a/samples/server/petstore/rust-server/output/openapi-v3/api/openapi.yaml b/samples/server/petstore/rust-server/output/openapi-v3/api/openapi.yaml
index cc86611971e9356d30a1387c698fcaf9482686d9..2496380a4f6191a4ab6e582c3d8b2741c46f43ee 100644
--- a/samples/server/petstore/rust-server/output/openapi-v3/api/openapi.yaml
+++ b/samples/server/petstore/rust-server/output/openapi-v3/api/openapi.yaml
@@ -165,6 +165,11 @@ paths:
               schema:
                 type: String
               style: simple
+            Object-Header:
+              explode: false
+              schema:
+                $ref: '#/components/schemas/ObjectHeader'
+              style: simple
         "412":
           description: Precondition Failed
           headers:
@@ -178,6 +183,19 @@ paths:
               schema:
                 type: String
               style: simple
+  /mandatory-request-header:
+    get:
+      parameters:
+      - explode: false
+        in: header
+        name: X-Header
+        required: true
+        schema:
+          type: string
+        style: simple
+      responses:
+        "200":
+          description: Success
 components:
   schemas:
     EnumWithStarObject:
@@ -264,6 +282,19 @@ components:
       type: array
     MyID:
       type: integer
+    ObjectHeader:
+      properties:
+        requiredObjectHeader:
+          type: boolean
+        optionalObjectHeader:
+          type: integer
+      required:
+      - requiredObjectHeader
+      type: object
+    RequiredObjectHeader:
+      type: boolean
+    OptionalObjectHeader:
+      type: integer
     inline_response_201:
       properties:
         foo:
diff --git a/samples/server/petstore/rust-server/output/openapi-v3/docs/ObjectHeader.md b/samples/server/petstore/rust-server/output/openapi-v3/docs/ObjectHeader.md
new file mode 100644
index 0000000000000000000000000000000000000000..a685cde3a4bb79e40c474f6ac258f34c220c955c
--- /dev/null
+++ b/samples/server/petstore/rust-server/output/openapi-v3/docs/ObjectHeader.md
@@ -0,0 +1,11 @@
+# ObjectHeader
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**required_object_header** | **bool** |  | 
+**optional_object_header** | **isize** |  | [optional] [default to None]
+
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/samples/server/petstore/rust-server/output/openapi-v3/docs/OptionalObjectField.md b/samples/server/petstore/rust-server/output/openapi-v3/docs/OptionalObjectField.md
new file mode 100644
index 0000000000000000000000000000000000000000..ca9a24aa636bb9c6a9e3fb5d22d54b80f787a099
--- /dev/null
+++ b/samples/server/petstore/rust-server/output/openapi-v3/docs/OptionalObjectField.md
@@ -0,0 +1,9 @@
+# OptionalObjectField
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/samples/server/petstore/rust-server/output/openapi-v3/docs/OptionalObjectHeader.md b/samples/server/petstore/rust-server/output/openapi-v3/docs/OptionalObjectHeader.md
new file mode 100644
index 0000000000000000000000000000000000000000..892c56b99189bb080ddcb01b509f1ad699147d8b
--- /dev/null
+++ b/samples/server/petstore/rust-server/output/openapi-v3/docs/OptionalObjectHeader.md
@@ -0,0 +1,9 @@
+# OptionalObjectHeader
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/samples/server/petstore/rust-server/output/openapi-v3/docs/RequiredObjectField.md b/samples/server/petstore/rust-server/output/openapi-v3/docs/RequiredObjectField.md
new file mode 100644
index 0000000000000000000000000000000000000000..a5b1551993f9a15518c84a7d3a3b42ad63246c8b
--- /dev/null
+++ b/samples/server/petstore/rust-server/output/openapi-v3/docs/RequiredObjectField.md
@@ -0,0 +1,9 @@
+# RequiredObjectField
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/samples/server/petstore/rust-server/output/openapi-v3/docs/RequiredObjectHeader.md b/samples/server/petstore/rust-server/output/openapi-v3/docs/RequiredObjectHeader.md
new file mode 100644
index 0000000000000000000000000000000000000000..2cc642196fd8853f4ec354200065df36e6707bbb
--- /dev/null
+++ b/samples/server/petstore/rust-server/output/openapi-v3/docs/RequiredObjectHeader.md
@@ -0,0 +1,9 @@
+# RequiredObjectHeader
+
+## Properties
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/samples/server/petstore/rust-server/output/openapi-v3/docs/default_api.md b/samples/server/petstore/rust-server/output/openapi-v3/docs/default_api.md
index 1322f64383878d317894331673739ec86da4ed00..199c7159ea15ef1331b22cb838edf643478dc6f9 100644
--- a/samples/server/petstore/rust-server/output/openapi-v3/docs/default_api.md
+++ b/samples/server/petstore/rust-server/output/openapi-v3/docs/default_api.md
@@ -4,6 +4,7 @@ All URIs are relative to *http://localhost*
 
 Method | HTTP request | Description
 ------------- | ------------- | -------------
+****](default_api.md#) | **GET** /mandatory-request-header | 
 ****](default_api.md#) | **GET** /multiget | Get some stuff.
 ****](default_api.md#) | **GET** /multiple_auth_scheme | 
 ****](default_api.md#) | **GET** /readonly_auth_scheme | 
@@ -17,6 +18,31 @@ Method | HTTP request | Description
 ****](default_api.md#) | **PUT** /xml | 
 
 
+# ****
+> (x_header)
+
+
+### Required Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+  **x_header** | **String**|  | 
+
+### Return type
+
+ (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
 # ****
 > models::AnotherXmlObject ()
 Get some stuff.
diff --git a/samples/server/petstore/rust-server/output/openapi-v3/examples/client.rs b/samples/server/petstore/rust-server/output/openapi-v3/examples/client.rs
index bad25cce506886c66a78edd6e48cf4878b2517d0..ceac44d1f9980a939035baf14b545ca240cb5cd1 100644
--- a/samples/server/petstore/rust-server/output/openapi-v3/examples/client.rs
+++ b/samples/server/petstore/rust-server/output/openapi-v3/examples/client.rs
@@ -14,6 +14,7 @@ use futures::{Future, future, Stream, stream};
 #[allow(unused_imports)]
 use openapi_v3::{Api, ApiNoContext, Client, ContextWrapperExt,
                       ApiError,
+                      MandatoryRequestHeaderGetResponse,
                       MultigetGetResponse,
                       MultipleAuthSchemeGetResponse,
                       ReadonlyAuthSchemeGetResponse,
@@ -34,6 +35,8 @@ fn main() {
             .help("Sets the operation to run")
             .possible_values(&[
 
+                "MandatoryRequestHeaderGet",
+
                 "MultigetGet",
 
                 "MultipleAuthSchemeGet",
@@ -100,6 +103,14 @@ fn main() {
 
     match matches.value_of("operation") {
 
+        Some("MandatoryRequestHeaderGet") => {
+            let mut rt = tokio::runtime::Runtime::new().unwrap();
+            let result = rt.block_on(client.mandatory_request_header_get(
+                  "x_header_example".to_string()
+            ));
+            println!("{:?} (X-Span-ID: {:?})", result, (client.context() as &dyn Has<XSpanIdString>).get().clone());
+        },
+
         Some("MultigetGet") => {
             let mut rt = tokio::runtime::Runtime::new().unwrap();
             let result = rt.block_on(client.multiget_get(
diff --git a/samples/server/petstore/rust-server/output/openapi-v3/examples/server_lib/mod.rs b/samples/server/petstore/rust-server/output/openapi-v3/examples/server_lib/mod.rs
index 15bb1f7ecf0b3d31d825f6379fc9a9fadb9134dd..598b18affe2b1f91dc879a9daf71b6439365bcba 100644
--- a/samples/server/petstore/rust-server/output/openapi-v3/examples/server_lib/mod.rs
+++ b/samples/server/petstore/rust-server/output/openapi-v3/examples/server_lib/mod.rs
@@ -17,6 +17,7 @@ use swagger;
 use swagger::{Has, XSpanIdString};
 
 use openapi_v3::{Api, ApiError,
+                      MandatoryRequestHeaderGetResponse,
                       MultigetGetResponse,
                       MultipleAuthSchemeGetResponse,
                       ReadonlyAuthSchemeGetResponse,
@@ -44,6 +45,13 @@ impl<C> Server<C> {
 
 impl<C> Api<C> for Server<C> where C: Has<XSpanIdString>{
 
+
+    fn mandatory_request_header_get(&self, x_header: String, context: &C) -> Box<Future<Item=MandatoryRequestHeaderGetResponse, Error=ApiError> + Send> {
+        let context = context.clone();
+        println!("mandatory_request_header_get(\"{}\") - X-Span-ID: {:?}", x_header, context.get().0.clone());
+        Box::new(futures::failed("Generic failure".into()))
+    }
+
     /// Get some stuff.
     fn multiget_get(&self, context: &C) -> Box<Future<Item=MultigetGetResponse, Error=ApiError> + Send> {
         let context = context.clone();
diff --git a/samples/server/petstore/rust-server/output/openapi-v3/src/client/mod.rs b/samples/server/petstore/rust-server/output/openapi-v3/src/client/mod.rs
index c642551b48b734d42032e1720f82d81d439411f6..83912b21cfd16be589c6bc6902567ba9f29fe747 100644
--- a/samples/server/petstore/rust-server/output/openapi-v3/src/client/mod.rs
+++ b/samples/server/petstore/rust-server/output/openapi-v3/src/client/mod.rs
@@ -29,6 +29,7 @@ use uuid;
 use serde_xml_rs;
 
 use {Api,
+     MandatoryRequestHeaderGetResponse,
      MultigetGetResponse,
      MultipleAuthSchemeGetResponse,
      ReadonlyAuthSchemeGetResponse,
@@ -44,6 +45,7 @@ use {Api,
 
 use mimetypes;
 use models;
+use header;
 
 define_encode_set! {
     /// This encode set is used for object IDs
@@ -205,6 +207,82 @@ impl<C, F> Api<C> for Client<F> where
     F: Future<Item=Response<Body>, Error=hyper::Error> + Send + 'static
 {
 
+    fn mandatory_request_header_get(&self, param_x_header: String, context: &C) -> Box<dyn Future<Item=MandatoryRequestHeaderGetResponse, Error=ApiError> + Send> {
+        let mut uri = format!(
+            "{}/mandatory-request-header",
+            self.base_path
+        );
+
+        // Query parameters
+        let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
+        let query_string_str = query_string.finish();
+        if !query_string_str.is_empty() {
+            uri += "?";
+            uri += &query_string_str;
+        }
+
+        let uri = match Uri::from_str(&uri) {
+            Ok(uri) => uri,
+            Err(err) => return Box::new(future::err(ApiError(format!("Unable to build URI: {}", err)))),
+        };
+
+        let mut request = match hyper::Request::builder()
+            .method("GET")
+            .uri(uri)
+            .body(Body::empty()) {
+                Ok(req) => req,
+                Err(e) => return Box::new(future::err(ApiError(format!("Unable to create request: {}", e))))
+        };
+
+
+        let header = HeaderValue::from_str((context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str());
+        request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
+            Ok(h) => h,
+            Err(e) => return Box::new(future::err(ApiError(format!("Unable to create X-Span ID header value: {}", e))))
+        });
+
+
+        // Header parameters
+        request.headers_mut().append(
+            HeaderName::from_static("x-header"),
+            header::IntoHeaderValue(param_x_header.clone()).into());
+
+        Box::new(self.client_service.request(request)
+                             .map_err(|e| ApiError(format!("No response received: {}", e)))
+                             .and_then(|mut response| {
+            match response.status().as_u16() {
+                200 => {
+                    let body = response.into_body();
+                    Box::new(
+                        future::ok(
+                            MandatoryRequestHeaderGetResponse::Success
+                        )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                },
+                code => {
+                    let headers = response.headers().clone();
+                    Box::new(response.into_body()
+                            .take(100)
+                            .concat2()
+                            .then(move |body|
+                                future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
+                                    code,
+                                    headers,
+                                    match body {
+                                        Ok(ref body) => match str::from_utf8(body) {
+                                            Ok(body) => Cow::from(body),
+                                            Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
+                                        },
+                                        Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
+                                    })))
+                            )
+                    ) as Box<dyn Future<Item=_, Error=_> + Send>
+                }
+            }
+        }))
+
+    }
+
     fn multiget_get(&self, context: &C) -> Box<dyn Future<Item=MultigetGetResponse, Error=ApiError> + Send> {
         let mut uri = format!(
             "{}/multiget",
@@ -701,6 +779,10 @@ impl<C, F> Api<C> for Client<F> where
                         Some(response_success_info) => response_success_info.clone(),
                         None => return Box::new(future::err(ApiError(String::from("Required response header Success-Info for response 200 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
                     };
+                    let response_object_header = match response.headers().get(HeaderName::from_static("object-header")) {
+                        Some(response_object_header) => response_object_header.clone(),
+                        None => return Box::new(future::err(ApiError(String::from("Required response header Object-Header for response 200 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
+                    };
                     let body = response.into_body();
                     Box::new(
                         body
@@ -718,7 +800,8 @@ impl<C, F> Api<C> for Client<F> where
                             ResponsesWithHeadersGetResponse::Success
                             {
                                body: body,
-                               success_info: (*Into::<swagger::IntoHeaderValue<String>>::into(response_success_info)).clone(),
+                               success_info: (*Into::<header::IntoHeaderValue<String>>::into(response_success_info)).clone(),
+                               object_header: (*Into::<header::IntoHeaderValue<models::ObjectHeader>>::into(response_object_header)).clone(),
                             }
                         })
                     ) as Box<dyn Future<Item=_, Error=_> + Send>
@@ -737,8 +820,8 @@ impl<C, F> Api<C> for Client<F> where
                         future::ok(
                             ResponsesWithHeadersGetResponse::PreconditionFailed
                             {
-                              further_info: (*Into::<swagger::IntoHeaderValue<String>>::into(response_further_info)).clone(),
-                              failure_info: (*Into::<swagger::IntoHeaderValue<String>>::into(response_failure_info)).clone(),
+                              further_info: (*Into::<header::IntoHeaderValue<String>>::into(response_further_info)).clone(),
+                              failure_info: (*Into::<header::IntoHeaderValue<String>>::into(response_failure_info)).clone(),
                             }
                         )
                     ) as Box<dyn Future<Item=_, Error=_> + Send>
diff --git a/samples/server/petstore/rust-server/output/openapi-v3/src/header.rs b/samples/server/petstore/rust-server/output/openapi-v3/src/header.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d67419356f7f8f7f9e417bf4c1f3ce1e3c611743
--- /dev/null
+++ b/samples/server/petstore/rust-server/output/openapi-v3/src/header.rs
@@ -0,0 +1,99 @@
+use chrono::{DateTime, Utc};
+use hyper::header::HeaderValue;
+use std::fmt;
+use std::ops::Deref;
+
+/// A struct to allow homogeneous conversion into a HeaderValue. We can't
+/// implement the From/Into trait on HeaderValue because we don't own
+/// either of the types.
+#[derive(Debug, Clone)]
+pub struct IntoHeaderValue<T>(pub T);
+
+// Generic implementations
+
+impl<T> Deref for IntoHeaderValue<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &self.0
+    }
+}
+
+// Derive for each From<T> in hyper::header::HeaderValue
+
+macro_rules! ihv_generate {
+    ($t:ident) => {
+        impl From<HeaderValue> for IntoHeaderValue<$t> {
+            fn from(hdr_value: HeaderValue) -> Self {
+                IntoHeaderValue(hdr_value.to_str().unwrap().parse::<$t>().unwrap())
+            }
+        }
+
+        impl From<IntoHeaderValue<$t>> for HeaderValue {
+            fn from(hdr_value: IntoHeaderValue<$t>) -> Self {
+                hdr_value.0.into()
+            }
+        }
+    };
+}
+
+ihv_generate!(u64);
+ihv_generate!(i64);
+ihv_generate!(i16);
+ihv_generate!(u16);
+ihv_generate!(u32);
+ihv_generate!(usize);
+ihv_generate!(isize);
+ihv_generate!(i32);
+
+// Custom derivations
+
+impl From<HeaderValue> for IntoHeaderValue<Vec<String>> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(
+            hdr_value
+                .to_str()
+                .unwrap()
+                .split(',')
+                .filter_map(|x| match x.trim() {
+                    "" => None,
+                    y => Some(y.to_string()),
+                })
+                .collect(),
+        )
+    }
+}
+
+impl From<IntoHeaderValue<Vec<String>>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<Vec<String>>) -> Self {
+        HeaderValue::from_str(&hdr_value.0.join(", ")).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<String> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(hdr_value.to_str().unwrap().to_string())
+    }
+}
+
+impl From<IntoHeaderValue<String>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<String>) -> Self {
+        HeaderValue::from_str(&hdr_value.0).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<DateTime<Utc>> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(
+            DateTime::parse_from_rfc3339(hdr_value.to_str().unwrap())
+                .unwrap()
+                .with_timezone(&Utc),
+        )
+    }
+}
+
+impl From<IntoHeaderValue<DateTime<Utc>>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<DateTime<Utc>>) -> Self {
+        HeaderValue::from_str(hdr_value.0.to_rfc3339().as_str()).unwrap()
+    }
+}
diff --git a/samples/server/petstore/rust-server/output/openapi-v3/src/lib.rs b/samples/server/petstore/rust-server/output/openapi-v3/src/lib.rs
index 1e965834ce006925e99416651e4b9040ea420a78..8b6355d2c8035b796a9d6948fd6e9285a1807fee 100644
--- a/samples/server/petstore/rust-server/output/openapi-v3/src/lib.rs
+++ b/samples/server/petstore/rust-server/output/openapi-v3/src/lib.rs
@@ -74,6 +74,12 @@ pub const BASE_PATH: &'static str = "";
 pub const API_VERSION: &'static str = "1.0.7";
 
 
+#[derive(Debug, PartialEq)]
+pub enum MandatoryRequestHeaderGetResponse {
+    /// Success
+    Success
+}
+
 #[derive(Debug, PartialEq)]
 pub enum MultigetGetResponse {
     /// JSON rsp
@@ -130,6 +136,7 @@ pub enum ResponsesWithHeadersGetResponse {
     {
         body: String,
         success_info: String,
+        object_header: models::ObjectHeader,
     }
     ,
     /// Precondition Failed
@@ -196,6 +203,9 @@ pub enum XmlPutResponse {
 /// API
 pub trait Api<C> {
 
+
+    fn mandatory_request_header_get(&self, x_header: String, context: &C) -> Box<dyn Future<Item=MandatoryRequestHeaderGetResponse, Error=ApiError> + Send>;
+
     /// Get some stuff.
     fn multiget_get(&self, context: &C) -> Box<dyn Future<Item=MultigetGetResponse, Error=ApiError> + Send>;
 
@@ -234,6 +244,9 @@ pub trait Api<C> {
 /// API without a `Context`
 pub trait ApiNoContext {
 
+
+    fn mandatory_request_header_get(&self, x_header: String) -> Box<dyn Future<Item=MandatoryRequestHeaderGetResponse, Error=ApiError> + Send>;
+
     /// Get some stuff.
     fn multiget_get(&self) -> Box<dyn Future<Item=MultigetGetResponse, Error=ApiError> + Send>;
 
@@ -283,6 +296,11 @@ impl<'a, T: Api<C> + Sized, C> ContextWrapperExt<'a, C> for T {
 
 impl<'a, T: Api<C>, C> ApiNoContext for ContextWrapper<'a, T, C> {
 
+
+    fn mandatory_request_header_get(&self, x_header: String) -> Box<dyn Future<Item=MandatoryRequestHeaderGetResponse, Error=ApiError> + Send> {
+        self.api().mandatory_request_header_get(x_header, &self.context())
+    }
+
     /// Get some stuff.
     fn multiget_get(&self) -> Box<dyn Future<Item=MultigetGetResponse, Error=ApiError> + Send> {
         self.api().multiget_get(&self.context())
@@ -355,3 +373,4 @@ pub mod server;
 pub use self::server::Service;
 
 pub mod models;
+pub mod header;
diff --git a/samples/server/petstore/rust-server/output/openapi-v3/src/models.rs b/samples/server/petstore/rust-server/output/openapi-v3/src/models.rs
index f307404fbeb90296bbd37844a0638aa6f94b04c3..2295f084979aa1d4fa7078c4f8b34b33a082ca60 100644
--- a/samples/server/petstore/rust-server/output/openapi-v3/src/models.rs
+++ b/samples/server/petstore/rust-server/output/openapi-v3/src/models.rs
@@ -6,10 +6,28 @@ use serde::ser::Serializer;
 use std::collections::{HashMap, BTreeMap};
 use models;
 use swagger;
+use hyper::header::HeaderValue;
 use std::string::ParseError;
 use uuid;
+use std::str::FromStr;
+use header::IntoHeaderValue;
 
 
+
+// Methods for converting between IntoHeaderValue<AnotherXmlArray> and HeaderValue
+
+impl From<IntoHeaderValue<AnotherXmlArray>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<AnotherXmlArray>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<AnotherXmlArray> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(AnotherXmlArray::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 // Utility function for wrapping list elements when serializing xml
 #[allow(non_snake_case)]
 fn wrap_in_snake_another_xml_inner<S>(item: &Vec<String>, serializer: S) -> Result<S::Ok, S::Error>
@@ -139,6 +157,21 @@ impl AnotherXmlInner {
 }
 
 /// An XML object
+
+// Methods for converting between IntoHeaderValue<AnotherXmlObject> and HeaderValue
+
+impl From<IntoHeaderValue<AnotherXmlObject>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<AnotherXmlObject>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<AnotherXmlObject> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(AnotherXmlObject::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 #[serde(rename = "snake_another_xml_object")]
@@ -176,6 +209,21 @@ impl AnotherXmlObject {
 }
 
 /// An XML object
+
+// Methods for converting between IntoHeaderValue<DuplicateXmlObject> and HeaderValue
+
+impl From<IntoHeaderValue<DuplicateXmlObject>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<DuplicateXmlObject>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<DuplicateXmlObject> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(DuplicateXmlObject::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 #[serde(rename = "camelDuplicateXmlObject")]
@@ -265,6 +313,21 @@ impl EnumWithStarObject {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<InlineResponse201> and HeaderValue
+
+impl From<IntoHeaderValue<InlineResponse201>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<InlineResponse201>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<InlineResponse201> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(InlineResponse201::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct InlineResponse201 {
@@ -331,6 +394,21 @@ impl MyId {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<MyIdList> and HeaderValue
+
+impl From<IntoHeaderValue<MyIdList>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<MyIdList>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<MyIdList> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(MyIdList::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct MyIdList(Vec<i32>);
@@ -403,6 +481,66 @@ impl MyIdList {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<ObjectHeader> and HeaderValue
+
+impl From<IntoHeaderValue<ObjectHeader>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<ObjectHeader>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<ObjectHeader> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(ObjectHeader::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
+pub struct ObjectHeader {
+    #[serde(rename = "requiredObjectHeader")]
+    pub required_object_header: bool,
+
+    #[serde(rename = "optionalObjectHeader")]
+    #[serde(skip_serializing_if="Option::is_none")]
+    pub optional_object_header: Option<isize>,
+
+}
+
+impl ObjectHeader {
+    pub fn new(required_object_header: bool, ) -> ObjectHeader {
+        ObjectHeader {
+            required_object_header: required_object_header,
+            optional_object_header: None,
+        }
+    }
+}
+
+impl ObjectHeader {
+    /// Helper function to allow us to convert this model to an XML string.
+    /// Will panic if serialisation fails.
+    #[allow(dead_code)]
+    pub(crate) fn to_xml(&self) -> String {
+        serde_xml_rs::to_string(&self).expect("impossible to fail to serialize")
+    }
+}
+
+
+// Methods for converting between IntoHeaderValue<ObjectWithArrayOfObjects> and HeaderValue
+
+impl From<IntoHeaderValue<ObjectWithArrayOfObjects>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<ObjectWithArrayOfObjects>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<ObjectWithArrayOfObjects> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(ObjectWithArrayOfObjects::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct ObjectWithArrayOfObjects {
@@ -429,6 +567,86 @@ impl ObjectWithArrayOfObjects {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
+pub struct OptionalObjectHeader(i32);
+
+impl ::std::convert::From<i32> for OptionalObjectHeader {
+    fn from(x: i32) -> Self {
+        OptionalObjectHeader(x)
+    }
+}
+
+
+impl ::std::convert::From<OptionalObjectHeader> for i32 {
+    fn from(x: OptionalObjectHeader) -> Self {
+        x.0
+    }
+}
+
+impl ::std::ops::Deref for OptionalObjectHeader {
+    type Target = i32;
+    fn deref(&self) -> &i32 {
+        &self.0
+    }
+}
+
+impl ::std::ops::DerefMut for OptionalObjectHeader {
+    fn deref_mut(&mut self) -> &mut i32 {
+        &mut self.0
+    }
+}
+
+
+impl OptionalObjectHeader {
+    /// Helper function to allow us to convert this model to an XML string.
+    /// Will panic if serialisation fails.
+    #[allow(dead_code)]
+    pub(crate) fn to_xml(&self) -> String {
+        serde_xml_rs::to_string(&self).expect("impossible to fail to serialize")
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
+pub struct RequiredObjectHeader(bool);
+
+impl ::std::convert::From<bool> for RequiredObjectHeader {
+    fn from(x: bool) -> Self {
+        RequiredObjectHeader(x)
+    }
+}
+
+
+impl ::std::convert::From<RequiredObjectHeader> for bool {
+    fn from(x: RequiredObjectHeader) -> Self {
+        x.0
+    }
+}
+
+impl ::std::ops::Deref for RequiredObjectHeader {
+    type Target = bool;
+    fn deref(&self) -> &bool {
+        &self.0
+    }
+}
+
+impl ::std::ops::DerefMut for RequiredObjectHeader {
+    fn deref_mut(&mut self) -> &mut bool {
+        &mut self.0
+    }
+}
+
+
+impl RequiredObjectHeader {
+    /// Helper function to allow us to convert this model to an XML string.
+    /// Will panic if serialisation fails.
+    #[allow(dead_code)]
+    pub(crate) fn to_xml(&self) -> String {
+        serde_xml_rs::to_string(&self).expect("impossible to fail to serialize")
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, PartialOrd, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct StringObject(String);
@@ -516,6 +734,21 @@ impl UuidObject {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<XmlArray> and HeaderValue
+
+impl From<IntoHeaderValue<XmlArray>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<XmlArray>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<XmlArray> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(XmlArray::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 // Utility function for wrapping list elements when serializing xml
 #[allow(non_snake_case)]
 fn wrap_in_camelXmlInner<S>(item: &Vec<String>, serializer: S) -> Result<S::Ok, S::Error>
@@ -645,6 +878,21 @@ impl XmlInner {
 }
 
 /// An XML object
+
+// Methods for converting between IntoHeaderValue<XmlObject> and HeaderValue
+
+impl From<IntoHeaderValue<XmlObject>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<XmlObject>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<XmlObject> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(XmlObject::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 #[serde(rename = "camelXmlObject")]
diff --git a/samples/server/petstore/rust-server/output/openapi-v3/src/server/mod.rs b/samples/server/petstore/rust-server/output/openapi-v3/src/server/mod.rs
index 2f5fba31bc40a4b3a035b52549179b7ff4685116..c67f0197d0d4e729d84bedf07ae7d733601f184e 100644
--- a/samples/server/petstore/rust-server/output/openapi-v3/src/server/mod.rs
+++ b/samples/server/petstore/rust-server/output/openapi-v3/src/server/mod.rs
@@ -21,6 +21,7 @@ use mimetypes;
 pub use swagger::auth::Authorization;
 
 use {Api,
+     MandatoryRequestHeaderGetResponse,
      MultigetGetResponse,
      MultipleAuthSchemeGetResponse,
      ReadonlyAuthSchemeGetResponse,
@@ -36,6 +37,7 @@ use {Api,
 
 #[allow(unused_imports)]
 use models;
+use header;
 
 pub mod context;
 
@@ -44,6 +46,7 @@ mod paths {
 
     lazy_static! {
         pub static ref GLOBAL_REGEX_SET: regex::RegexSet = regex::RegexSet::new(vec![
+            r"^/mandatory-request-header$",
             r"^/multiget$",
             r"^/multiple_auth_scheme$",
             r"^/readonly_auth_scheme$",
@@ -56,15 +59,16 @@ mod paths {
         ])
         .expect("Unable to create global regex set");
     }
-    pub static ID_MULTIGET: usize = 0;
-    pub static ID_MULTIPLE_AUTH_SCHEME: usize = 1;
-    pub static ID_READONLY_AUTH_SCHEME: usize = 2;
-    pub static ID_REQUIRED_OCTET_STREAM: usize = 3;
-    pub static ID_RESPONSES_WITH_HEADERS: usize = 4;
-    pub static ID_UUID: usize = 5;
-    pub static ID_XML: usize = 6;
-    pub static ID_XML_EXTRA: usize = 7;
-    pub static ID_XML_OTHER: usize = 8;
+    pub static ID_MANDATORY_REQUEST_HEADER: usize = 0;
+    pub static ID_MULTIGET: usize = 1;
+    pub static ID_MULTIPLE_AUTH_SCHEME: usize = 2;
+    pub static ID_READONLY_AUTH_SCHEME: usize = 3;
+    pub static ID_REQUIRED_OCTET_STREAM: usize = 4;
+    pub static ID_RESPONSES_WITH_HEADERS: usize = 5;
+    pub static ID_UUID: usize = 6;
+    pub static ID_XML: usize = 7;
+    pub static ID_XML_EXTRA: usize = 8;
+    pub static ID_XML_OTHER: usize = 9;
 }
 
 pub struct MakeService<T, RC> {
@@ -143,6 +147,58 @@ where
         // Please update both places if changing how this code is autogenerated.
         match &method {
 
+            // MandatoryRequestHeaderGet - GET /mandatory-request-header
+            &hyper::Method::GET if path.matched(paths::ID_MANDATORY_REQUEST_HEADER) => {
+
+                // Header parameters
+                let param_x_header = headers.get(HeaderName::from_static("x-header"));
+
+                let param_x_header = match param_x_header)) {
+                    Some(v) => Some(header::IntoHeaderValue::<String>::from(v)).0),
+                    None => return Box::new(future::ok(Response::builder()
+                                        .status(StatusCode::BAD_REQUEST)
+                                        .body(Body::from("Missing or invalid required header X-Header"))
+                                        .expect("Unable to create Bad Request response for missing required header X-Header")))
+                };
+                Box::new({
+                        {{
+                                Box::new(
+                                    api_impl.mandatory_request_header_get(
+                                            param_x_header,
+                                        &context
+                                    ).then(move |result| {
+                                        let mut response = Response::new(Body::empty());
+                                        response.headers_mut().insert(
+                                            HeaderName::from_static("x-span-id"),
+                                            HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+                                                .expect("Unable to create X-Span-ID header value"));
+
+
+                                        match result {
+                                            Ok(rsp) => match rsp {
+                                                MandatoryRequestHeaderGetResponse::Success
+
+
+                                                => {
+                                                    *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
+
+                                                },
+                                            },
+                                            Err(_) => {
+                                                // Application code returned an error. This should not happen, as the implementation should
+                                                // return a valid response.
+                                                *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+                                                *response.body_mut() = Body::from("An internal error occurred");
+                                            },
+                                        }
+
+                                        future::ok(response)
+                                    }
+                                ))
+                        }}
+                }) as Self::Future
+            },
+
             // MultigetGet - GET /multiget
             &hyper::Method::GET if path.matched(paths::ID_MULTIGET) => {
                 Box::new({
@@ -510,7 +566,9 @@ where
 
                                                     {
                                                         body,
-                                                        success_info
+                                                        success_info, 
+
+                                                        object_header
                                                     }
 
 
@@ -518,7 +576,11 @@ where
                                                     *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
                                                     response.headers_mut().insert(
                                                         HeaderName::from_static("success-info"),
-                                                        swagger::IntoHeaderValue(success_info).into()
+                                                        header::IntoHeaderValue(success_info).into()
+                                                    );
+                                                    response.headers_mut().insert(
+                                                        HeaderName::from_static("object-header"),
+                                                        header::IntoHeaderValue(object_header).into()
                                                     );
 
                                                     response.headers_mut().insert(
@@ -541,11 +603,11 @@ where
                                                     *response.status_mut() = StatusCode::from_u16(412).expect("Unable to turn 412 into a StatusCode");
                                                     response.headers_mut().insert(
                                                         HeaderName::from_static("further-info"),
-                                                        swagger::IntoHeaderValue(further_info).into()
+                                                        header::IntoHeaderValue(further_info).into()
                                                     );
                                                     response.headers_mut().insert(
                                                         HeaderName::from_static("failure-info"),
-                                                        swagger::IntoHeaderValue(failure_info).into()
+                                                        header::IntoHeaderValue(failure_info).into()
                                                     );
 
                                                 },
@@ -1035,6 +1097,9 @@ impl<T> RequestParser<T> for ApiRequestParser {
         let path = paths::GLOBAL_REGEX_SET.matches(request.uri().path());
         match request.method() {
 
+            // MandatoryRequestHeaderGet - GET /mandatory-request-header
+            &hyper::Method::GET if path.matched(paths::ID_MANDATORY_REQUEST_HEADER) => Ok("MandatoryRequestHeaderGet"),
+
             // MultigetGet - GET /multiget
             &hyper::Method::GET if path.matched(paths::ID_MULTIGET) => Ok("MultigetGet"),
 
diff --git a/samples/server/petstore/rust-server/output/ops-v3/src/client/mod.rs b/samples/server/petstore/rust-server/output/ops-v3/src/client/mod.rs
index baf7cba9275f82f7a8493f309f9780ab2d915fc2..516995086aac8898dfbe6f08b0e7b8e12f8428e6 100644
--- a/samples/server/petstore/rust-server/output/ops-v3/src/client/mod.rs
+++ b/samples/server/petstore/rust-server/output/ops-v3/src/client/mod.rs
@@ -68,6 +68,7 @@ use {Api,
 
 use mimetypes;
 use models;
+use header;
 
 define_encode_set! {
     /// This encode set is used for object IDs
diff --git a/samples/server/petstore/rust-server/output/ops-v3/src/header.rs b/samples/server/petstore/rust-server/output/ops-v3/src/header.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d67419356f7f8f7f9e417bf4c1f3ce1e3c611743
--- /dev/null
+++ b/samples/server/petstore/rust-server/output/ops-v3/src/header.rs
@@ -0,0 +1,99 @@
+use chrono::{DateTime, Utc};
+use hyper::header::HeaderValue;
+use std::fmt;
+use std::ops::Deref;
+
+/// A struct to allow homogeneous conversion into a HeaderValue. We can't
+/// implement the From/Into trait on HeaderValue because we don't own
+/// either of the types.
+#[derive(Debug, Clone)]
+pub struct IntoHeaderValue<T>(pub T);
+
+// Generic implementations
+
+impl<T> Deref for IntoHeaderValue<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &self.0
+    }
+}
+
+// Derive for each From<T> in hyper::header::HeaderValue
+
+macro_rules! ihv_generate {
+    ($t:ident) => {
+        impl From<HeaderValue> for IntoHeaderValue<$t> {
+            fn from(hdr_value: HeaderValue) -> Self {
+                IntoHeaderValue(hdr_value.to_str().unwrap().parse::<$t>().unwrap())
+            }
+        }
+
+        impl From<IntoHeaderValue<$t>> for HeaderValue {
+            fn from(hdr_value: IntoHeaderValue<$t>) -> Self {
+                hdr_value.0.into()
+            }
+        }
+    };
+}
+
+ihv_generate!(u64);
+ihv_generate!(i64);
+ihv_generate!(i16);
+ihv_generate!(u16);
+ihv_generate!(u32);
+ihv_generate!(usize);
+ihv_generate!(isize);
+ihv_generate!(i32);
+
+// Custom derivations
+
+impl From<HeaderValue> for IntoHeaderValue<Vec<String>> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(
+            hdr_value
+                .to_str()
+                .unwrap()
+                .split(',')
+                .filter_map(|x| match x.trim() {
+                    "" => None,
+                    y => Some(y.to_string()),
+                })
+                .collect(),
+        )
+    }
+}
+
+impl From<IntoHeaderValue<Vec<String>>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<Vec<String>>) -> Self {
+        HeaderValue::from_str(&hdr_value.0.join(", ")).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<String> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(hdr_value.to_str().unwrap().to_string())
+    }
+}
+
+impl From<IntoHeaderValue<String>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<String>) -> Self {
+        HeaderValue::from_str(&hdr_value.0).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<DateTime<Utc>> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(
+            DateTime::parse_from_rfc3339(hdr_value.to_str().unwrap())
+                .unwrap()
+                .with_timezone(&Utc),
+        )
+    }
+}
+
+impl From<IntoHeaderValue<DateTime<Utc>>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<DateTime<Utc>>) -> Self {
+        HeaderValue::from_str(hdr_value.0.to_rfc3339().as_str()).unwrap()
+    }
+}
diff --git a/samples/server/petstore/rust-server/output/ops-v3/src/lib.rs b/samples/server/petstore/rust-server/output/ops-v3/src/lib.rs
index cb8b1a1886e71557f1c4b25f704954578d8dabc4..9547cb0c3b3a879466cec5cf382a2f7b2ddbefae 100644
--- a/samples/server/petstore/rust-server/output/ops-v3/src/lib.rs
+++ b/samples/server/petstore/rust-server/output/ops-v3/src/lib.rs
@@ -745,3 +745,4 @@ pub mod server;
 pub use self::server::Service;
 
 pub mod models;
+pub mod header;
diff --git a/samples/server/petstore/rust-server/output/ops-v3/src/models.rs b/samples/server/petstore/rust-server/output/ops-v3/src/models.rs
index 2dad303cc44b0fe40982989ebcceeda7f6b4dc6c..2665d2eecdf436e8e7bb2126b4394e9a611c7399 100644
--- a/samples/server/petstore/rust-server/output/ops-v3/src/models.rs
+++ b/samples/server/petstore/rust-server/output/ops-v3/src/models.rs
@@ -5,5 +5,8 @@ use serde::ser::Serializer;
 use std::collections::HashMap;
 use models;
 use swagger;
+use hyper::header::HeaderValue;
 use std::string::ParseError;
+use std::str::FromStr;
+use header::IntoHeaderValue;
 
diff --git a/samples/server/petstore/rust-server/output/ops-v3/src/server/mod.rs b/samples/server/petstore/rust-server/output/ops-v3/src/server/mod.rs
index a6964835a7449118a03d9a51fdf00c8eba86541f..b34331e0640ac45585aec8bf8193741e9c045a1a 100644
--- a/samples/server/petstore/rust-server/output/ops-v3/src/server/mod.rs
+++ b/samples/server/petstore/rust-server/output/ops-v3/src/server/mod.rs
@@ -60,6 +60,7 @@ use {Api,
 
 #[allow(unused_imports)]
 use models;
+use header;
 
 pub mod context;
 
diff --git a/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/client/mod.rs b/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/client/mod.rs
index 344b27f3935de0c041d53404078099e6426217d4..1bd3669fffa0f4bdf3681f0118fd2cb9dd6b356b 100644
--- a/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/client/mod.rs
+++ b/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/client/mod.rs
@@ -69,6 +69,7 @@ use {Api,
 
 use mimetypes;
 use models;
+use header;
 
 define_encode_set! {
     /// This encode set is used for object IDs
@@ -1125,10 +1126,10 @@ impl<C, F> Api<C> for Client<F> where
         // Header parameters
         param_enum_header_string_array.map(|value| request.headers_mut().append(
             HeaderName::from_static("enum_header_string_array"),
-            swagger::IntoHeaderValue(value.clone()).into()));
+            header::IntoHeaderValue(value.clone()).into()));
         param_enum_header_string.map(|value| request.headers_mut().append(
             HeaderName::from_static("enum_header_string"),
-            swagger::IntoHeaderValue(value.clone()).into()));
+            header::IntoHeaderValue(value.clone()).into()));
 
         Box::new(self.client_service.request(request)
                              .map_err(|e| ApiError(format!("No response received: {}", e)))
@@ -1583,7 +1584,7 @@ impl<C, F> Api<C> for Client<F> where
         // Header parameters
         param_api_key.map(|value| request.headers_mut().append(
             HeaderName::from_static("api_key"),
-            swagger::IntoHeaderValue(value.clone()).into()));
+            header::IntoHeaderValue(value.clone()).into()));
 
         Box::new(self.client_service.request(request)
                              .map_err(|e| ApiError(format!("No response received: {}", e)))
@@ -3181,8 +3182,8 @@ impl<C, F> Api<C> for Client<F> where
                             LoginUserResponse::SuccessfulOperation
                             {
                                body: body,
-                               x_rate_limit: (*Into::<swagger::IntoHeaderValue<i32>>::into(response_x_rate_limit)).clone(),
-                               x_expires_after: (*Into::<swagger::IntoHeaderValue<chrono::DateTime<chrono::Utc>>>::into(response_x_expires_after)).clone(),
+                               x_rate_limit: (*Into::<header::IntoHeaderValue<i32>>::into(response_x_rate_limit)).clone(),
+                               x_expires_after: (*Into::<header::IntoHeaderValue<chrono::DateTime<chrono::Utc>>>::into(response_x_expires_after)).clone(),
                             }
                         })
                     ) as Box<dyn Future<Item=_, Error=_> + Send>
diff --git a/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/header.rs b/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/header.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d67419356f7f8f7f9e417bf4c1f3ce1e3c611743
--- /dev/null
+++ b/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/header.rs
@@ -0,0 +1,99 @@
+use chrono::{DateTime, Utc};
+use hyper::header::HeaderValue;
+use std::fmt;
+use std::ops::Deref;
+
+/// A struct to allow homogeneous conversion into a HeaderValue. We can't
+/// implement the From/Into trait on HeaderValue because we don't own
+/// either of the types.
+#[derive(Debug, Clone)]
+pub struct IntoHeaderValue<T>(pub T);
+
+// Generic implementations
+
+impl<T> Deref for IntoHeaderValue<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &self.0
+    }
+}
+
+// Derive for each From<T> in hyper::header::HeaderValue
+
+macro_rules! ihv_generate {
+    ($t:ident) => {
+        impl From<HeaderValue> for IntoHeaderValue<$t> {
+            fn from(hdr_value: HeaderValue) -> Self {
+                IntoHeaderValue(hdr_value.to_str().unwrap().parse::<$t>().unwrap())
+            }
+        }
+
+        impl From<IntoHeaderValue<$t>> for HeaderValue {
+            fn from(hdr_value: IntoHeaderValue<$t>) -> Self {
+                hdr_value.0.into()
+            }
+        }
+    };
+}
+
+ihv_generate!(u64);
+ihv_generate!(i64);
+ihv_generate!(i16);
+ihv_generate!(u16);
+ihv_generate!(u32);
+ihv_generate!(usize);
+ihv_generate!(isize);
+ihv_generate!(i32);
+
+// Custom derivations
+
+impl From<HeaderValue> for IntoHeaderValue<Vec<String>> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(
+            hdr_value
+                .to_str()
+                .unwrap()
+                .split(',')
+                .filter_map(|x| match x.trim() {
+                    "" => None,
+                    y => Some(y.to_string()),
+                })
+                .collect(),
+        )
+    }
+}
+
+impl From<IntoHeaderValue<Vec<String>>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<Vec<String>>) -> Self {
+        HeaderValue::from_str(&hdr_value.0.join(", ")).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<String> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(hdr_value.to_str().unwrap().to_string())
+    }
+}
+
+impl From<IntoHeaderValue<String>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<String>) -> Self {
+        HeaderValue::from_str(&hdr_value.0).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<DateTime<Utc>> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(
+            DateTime::parse_from_rfc3339(hdr_value.to_str().unwrap())
+                .unwrap()
+                .with_timezone(&Utc),
+        )
+    }
+}
+
+impl From<IntoHeaderValue<DateTime<Utc>>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<DateTime<Utc>>) -> Self {
+        HeaderValue::from_str(hdr_value.0.to_rfc3339().as_str()).unwrap()
+    }
+}
diff --git a/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/lib.rs b/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/lib.rs
index 2e3ceabf98cad4955abcd7f122f62200fd1d19ff..bfbc96b92b4d7ae96766a5097b0c04ea65d49e2a 100644
--- a/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/lib.rs
+++ b/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/lib.rs
@@ -752,3 +752,4 @@ pub mod server;
 pub use self::server::Service;
 
 pub mod models;
+pub mod header;
diff --git a/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/models.rs b/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/models.rs
index 4414c6d7f9bd0aa6a69cc2108d9345c9bdfbbdeb..253f74933cd6148b12a99457d4b06f8dcc102b86 100644
--- a/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/models.rs
+++ b/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/models.rs
@@ -6,10 +6,28 @@ use serde::ser::Serializer;
 use std::collections::{HashMap, BTreeMap};
 use models;
 use swagger;
+use hyper::header::HeaderValue;
 use std::string::ParseError;
 use uuid;
+use std::str::FromStr;
+use header::IntoHeaderValue;
 
 
+
+// Methods for converting between IntoHeaderValue<AdditionalPropertiesClass> and HeaderValue
+
+impl From<IntoHeaderValue<AdditionalPropertiesClass>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<AdditionalPropertiesClass>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<AdditionalPropertiesClass> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(AdditionalPropertiesClass::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct AdditionalPropertiesClass {
@@ -41,6 +59,21 @@ impl AdditionalPropertiesClass {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<Animal> and HeaderValue
+
+impl From<IntoHeaderValue<Animal>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<Animal>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<Animal> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(Animal::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct Animal {
@@ -71,6 +104,21 @@ impl Animal {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<AnimalFarm> and HeaderValue
+
+impl From<IntoHeaderValue<AnimalFarm>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<AnimalFarm>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<AnimalFarm> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(AnimalFarm::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct AnimalFarm(Vec<Animal>);
@@ -143,6 +191,21 @@ impl AnimalFarm {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<ApiResponse> and HeaderValue
+
+impl From<IntoHeaderValue<ApiResponse>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<ApiResponse>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<ApiResponse> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(ApiResponse::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct ApiResponse {
@@ -179,6 +242,21 @@ impl ApiResponse {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<ArrayOfArrayOfNumberOnly> and HeaderValue
+
+impl From<IntoHeaderValue<ArrayOfArrayOfNumberOnly>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<ArrayOfArrayOfNumberOnly>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<ArrayOfArrayOfNumberOnly> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(ArrayOfArrayOfNumberOnly::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct ArrayOfArrayOfNumberOnly {
@@ -205,6 +283,21 @@ impl ArrayOfArrayOfNumberOnly {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<ArrayOfNumberOnly> and HeaderValue
+
+impl From<IntoHeaderValue<ArrayOfNumberOnly>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<ArrayOfNumberOnly>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<ArrayOfNumberOnly> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(ArrayOfNumberOnly::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct ArrayOfNumberOnly {
@@ -231,6 +324,21 @@ impl ArrayOfNumberOnly {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<ArrayTest> and HeaderValue
+
+impl From<IntoHeaderValue<ArrayTest>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<ArrayTest>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<ArrayTest> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(ArrayTest::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct ArrayTest {
@@ -273,6 +381,21 @@ impl ArrayTest {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<Capitalization> and HeaderValue
+
+impl From<IntoHeaderValue<Capitalization>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<Capitalization>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<Capitalization> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(Capitalization::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct Capitalization {
@@ -325,6 +448,21 @@ impl Capitalization {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<Cat> and HeaderValue
+
+impl From<IntoHeaderValue<Cat>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<Cat>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<Cat> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(Cat::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct Cat {
@@ -360,6 +498,21 @@ impl Cat {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<CatAllOf> and HeaderValue
+
+impl From<IntoHeaderValue<CatAllOf>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<CatAllOf>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<CatAllOf> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(CatAllOf::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct CatAllOf {
@@ -386,6 +539,21 @@ impl CatAllOf {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<Category> and HeaderValue
+
+impl From<IntoHeaderValue<Category>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<Category>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<Category> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(Category::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 #[serde(rename = "Category")]
@@ -419,6 +587,21 @@ impl Category {
 }
 
 /// Model for testing model with \"_class\" property
+
+// Methods for converting between IntoHeaderValue<ClassModel> and HeaderValue
+
+impl From<IntoHeaderValue<ClassModel>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<ClassModel>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<ClassModel> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(ClassModel::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct ClassModel {
@@ -445,6 +628,21 @@ impl ClassModel {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<Client> and HeaderValue
+
+impl From<IntoHeaderValue<Client>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<Client>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<Client> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(Client::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct Client {
@@ -471,6 +669,21 @@ impl Client {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<Dog> and HeaderValue
+
+impl From<IntoHeaderValue<Dog>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<Dog>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<Dog> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(Dog::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct Dog {
@@ -506,6 +719,21 @@ impl Dog {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<DogAllOf> and HeaderValue
+
+impl From<IntoHeaderValue<DogAllOf>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<DogAllOf>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<DogAllOf> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(DogAllOf::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct DogAllOf {
@@ -532,6 +760,21 @@ impl DogAllOf {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<EnumArrays> and HeaderValue
+
+impl From<IntoHeaderValue<EnumArrays>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<EnumArrays>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<EnumArrays> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(EnumArrays::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct EnumArrays {
@@ -618,6 +861,21 @@ impl EnumClass {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<EnumTest> and HeaderValue
+
+impl From<IntoHeaderValue<EnumTest>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<EnumTest>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<EnumTest> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(EnumTest::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct EnumTest {
@@ -667,6 +925,21 @@ impl EnumTest {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<FormatTest> and HeaderValue
+
+impl From<IntoHeaderValue<FormatTest>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<FormatTest>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<FormatTest> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(FormatTest::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct FormatTest {
@@ -749,6 +1022,21 @@ impl FormatTest {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<HasOnlyReadOnly> and HeaderValue
+
+impl From<IntoHeaderValue<HasOnlyReadOnly>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<HasOnlyReadOnly>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<HasOnlyReadOnly> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(HasOnlyReadOnly::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct HasOnlyReadOnly {
@@ -780,6 +1068,21 @@ impl HasOnlyReadOnly {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<List> and HeaderValue
+
+impl From<IntoHeaderValue<List>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<List>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<List> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(List::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct List {
@@ -806,6 +1109,21 @@ impl List {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<MapTest> and HeaderValue
+
+impl From<IntoHeaderValue<MapTest>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<MapTest>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<MapTest> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(MapTest::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct MapTest {
@@ -844,6 +1162,21 @@ impl MapTest {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<MixedPropertiesAndAdditionalPropertiesClass> and HeaderValue
+
+impl From<IntoHeaderValue<MixedPropertiesAndAdditionalPropertiesClass>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<MixedPropertiesAndAdditionalPropertiesClass>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<MixedPropertiesAndAdditionalPropertiesClass> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(MixedPropertiesAndAdditionalPropertiesClass::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct MixedPropertiesAndAdditionalPropertiesClass {
@@ -881,6 +1214,21 @@ impl MixedPropertiesAndAdditionalPropertiesClass {
 }
 
 /// Model for testing model name starting with number
+
+// Methods for converting between IntoHeaderValue<Model200Response> and HeaderValue
+
+impl From<IntoHeaderValue<Model200Response>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<Model200Response>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<Model200Response> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(Model200Response::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 #[serde(rename = "Name")]
@@ -914,6 +1262,21 @@ impl Model200Response {
 }
 
 /// Model for testing reserved words
+
+// Methods for converting between IntoHeaderValue<ModelReturn> and HeaderValue
+
+impl From<IntoHeaderValue<ModelReturn>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<ModelReturn>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<ModelReturn> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(ModelReturn::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 #[serde(rename = "Return")]
@@ -942,6 +1305,21 @@ impl ModelReturn {
 }
 
 /// Model for testing model name same as property name
+
+// Methods for converting between IntoHeaderValue<Name> and HeaderValue
+
+impl From<IntoHeaderValue<Name>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<Name>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<Name> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(Name::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 #[serde(rename = "Name")]
@@ -983,6 +1361,21 @@ impl Name {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<NumberOnly> and HeaderValue
+
+impl From<IntoHeaderValue<NumberOnly>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<NumberOnly>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<NumberOnly> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(NumberOnly::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct NumberOnly {
@@ -1009,6 +1402,21 @@ impl NumberOnly {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<Order> and HeaderValue
+
+impl From<IntoHeaderValue<Order>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<Order>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<Order> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(Order::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 #[serde(rename = "Order")]
@@ -1103,6 +1511,21 @@ impl OuterBoolean {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<OuterComposite> and HeaderValue
+
+impl From<IntoHeaderValue<OuterComposite>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<OuterComposite>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<OuterComposite> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(OuterComposite::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct OuterComposite {
@@ -1272,6 +1695,21 @@ impl OuterString {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<Pet> and HeaderValue
+
+impl From<IntoHeaderValue<Pet>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<Pet>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<Pet> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(Pet::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 #[serde(rename = "Pet")]
@@ -1324,6 +1762,21 @@ impl Pet {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<ReadOnlyFirst> and HeaderValue
+
+impl From<IntoHeaderValue<ReadOnlyFirst>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<ReadOnlyFirst>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<ReadOnlyFirst> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(ReadOnlyFirst::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct ReadOnlyFirst {
@@ -1355,6 +1808,21 @@ impl ReadOnlyFirst {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<SpecialModelName> and HeaderValue
+
+impl From<IntoHeaderValue<SpecialModelName>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<SpecialModelName>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<SpecialModelName> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(SpecialModelName::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 #[serde(rename = "$special[model.name]")]
@@ -1382,6 +1850,21 @@ impl SpecialModelName {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<Tag> and HeaderValue
+
+impl From<IntoHeaderValue<Tag>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<Tag>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<Tag> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(Tag::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 #[serde(rename = "Tag")]
@@ -1414,6 +1897,21 @@ impl Tag {
     }
 }
 
+
+// Methods for converting between IntoHeaderValue<User> and HeaderValue
+
+impl From<IntoHeaderValue<User>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<User>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<User> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(User::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 #[serde(rename = "User")]
diff --git a/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/server/mod.rs b/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/server/mod.rs
index 9055d25389dd4dfe05c60526720a26b0d1e33b85..3081bc2373d209d5e0d3cdbd552f6a3c5b4b4e30 100644
--- a/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/server/mod.rs
+++ b/samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/server/mod.rs
@@ -60,6 +60,7 @@ use {Api,
 
 #[allow(unused_imports)]
 use models;
+use header;
 
 pub mod context;
 
@@ -1028,12 +1029,12 @@ Some("callback_example".to_string());
                 let param_enum_header_string_array = headers.get(HeaderName::from_static("enum_header_string_array"));
 
                 let param_enum_header_string_array = param_enum_header_string_array.map(|p| {
-                        swagger::IntoHeaderValue::<Vec<String>>::from((*p).clone()).0
+                        header::IntoHeaderValue::<Vec<String>>::from((*p).clone()).0
                 });
                 let param_enum_header_string = headers.get(HeaderName::from_static("enum_header_string"));
 
                 let param_enum_header_string = param_enum_header_string.map(|p| {
-                        swagger::IntoHeaderValue::<String>::from((*p).clone()).0
+                        header::IntoHeaderValue::<String>::from((*p).clone()).0
                 });
 
                 // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
@@ -1517,7 +1518,7 @@ Some("enum_form_string_example".to_string());
                 let param_api_key = headers.get(HeaderName::from_static("api_key"));
 
                 let param_api_key = param_api_key.map(|p| {
-                        swagger::IntoHeaderValue::<String>::from((*p).clone()).0
+                        header::IntoHeaderValue::<String>::from((*p).clone()).0
                 });
                 Box::new({
                         {{
@@ -3025,11 +3026,11 @@ Some("status_example".to_string());
                                                     *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
                                                     response.headers_mut().insert(
                                                         HeaderName::from_static("x-rate-limit"),
-                                                        swagger::IntoHeaderValue(x_rate_limit).into()
+                                                        header::IntoHeaderValue(x_rate_limit).into()
                                                     );
                                                     response.headers_mut().insert(
                                                         HeaderName::from_static("x-expires-after"),
-                                                        swagger::IntoHeaderValue(x_expires_after).into()
+                                                        header::IntoHeaderValue(x_expires_after).into()
                                                     );
 
                                                     response.headers_mut().insert(
diff --git a/samples/server/petstore/rust-server/output/rust-server-test/src/client/mod.rs b/samples/server/petstore/rust-server/output/rust-server-test/src/client/mod.rs
index 39c5be3b4e5fbfebf163990e308b56a4c2f7a7c2..02d2aa2100ac832298510bf497db0ea73ce98e6b 100644
--- a/samples/server/petstore/rust-server/output/rust-server-test/src/client/mod.rs
+++ b/samples/server/petstore/rust-server/output/rust-server-test/src/client/mod.rs
@@ -36,6 +36,7 @@ use {Api,
 
 use mimetypes;
 use models;
+use header;
 
 define_encode_set! {
     /// This encode set is used for object IDs
diff --git a/samples/server/petstore/rust-server/output/rust-server-test/src/header.rs b/samples/server/petstore/rust-server/output/rust-server-test/src/header.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d67419356f7f8f7f9e417bf4c1f3ce1e3c611743
--- /dev/null
+++ b/samples/server/petstore/rust-server/output/rust-server-test/src/header.rs
@@ -0,0 +1,99 @@
+use chrono::{DateTime, Utc};
+use hyper::header::HeaderValue;
+use std::fmt;
+use std::ops::Deref;
+
+/// A struct to allow homogeneous conversion into a HeaderValue. We can't
+/// implement the From/Into trait on HeaderValue because we don't own
+/// either of the types.
+#[derive(Debug, Clone)]
+pub struct IntoHeaderValue<T>(pub T);
+
+// Generic implementations
+
+impl<T> Deref for IntoHeaderValue<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &self.0
+    }
+}
+
+// Derive for each From<T> in hyper::header::HeaderValue
+
+macro_rules! ihv_generate {
+    ($t:ident) => {
+        impl From<HeaderValue> for IntoHeaderValue<$t> {
+            fn from(hdr_value: HeaderValue) -> Self {
+                IntoHeaderValue(hdr_value.to_str().unwrap().parse::<$t>().unwrap())
+            }
+        }
+
+        impl From<IntoHeaderValue<$t>> for HeaderValue {
+            fn from(hdr_value: IntoHeaderValue<$t>) -> Self {
+                hdr_value.0.into()
+            }
+        }
+    };
+}
+
+ihv_generate!(u64);
+ihv_generate!(i64);
+ihv_generate!(i16);
+ihv_generate!(u16);
+ihv_generate!(u32);
+ihv_generate!(usize);
+ihv_generate!(isize);
+ihv_generate!(i32);
+
+// Custom derivations
+
+impl From<HeaderValue> for IntoHeaderValue<Vec<String>> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(
+            hdr_value
+                .to_str()
+                .unwrap()
+                .split(',')
+                .filter_map(|x| match x.trim() {
+                    "" => None,
+                    y => Some(y.to_string()),
+                })
+                .collect(),
+        )
+    }
+}
+
+impl From<IntoHeaderValue<Vec<String>>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<Vec<String>>) -> Self {
+        HeaderValue::from_str(&hdr_value.0.join(", ")).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<String> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(hdr_value.to_str().unwrap().to_string())
+    }
+}
+
+impl From<IntoHeaderValue<String>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<String>) -> Self {
+        HeaderValue::from_str(&hdr_value.0).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<DateTime<Utc>> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(
+            DateTime::parse_from_rfc3339(hdr_value.to_str().unwrap())
+                .unwrap()
+                .with_timezone(&Utc),
+        )
+    }
+}
+
+impl From<IntoHeaderValue<DateTime<Utc>>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<DateTime<Utc>>) -> Self {
+        HeaderValue::from_str(hdr_value.0.to_rfc3339().as_str()).unwrap()
+    }
+}
diff --git a/samples/server/petstore/rust-server/output/rust-server-test/src/lib.rs b/samples/server/petstore/rust-server/output/rust-server-test/src/lib.rs
index 6bc3ac053c0ac142d380b4bad8da7fc6bcf90bfa..30de7d93617f2df55b0a22ffeb947afc390aff1b 100644
--- a/samples/server/petstore/rust-server/output/rust-server-test/src/lib.rs
+++ b/samples/server/petstore/rust-server/output/rust-server-test/src/lib.rs
@@ -204,3 +204,4 @@ pub mod server;
 pub use self::server::Service;
 
 pub mod models;
+pub mod header;
diff --git a/samples/server/petstore/rust-server/output/rust-server-test/src/models.rs b/samples/server/petstore/rust-server/output/rust-server-test/src/models.rs
index 7d0bf0e196f413b67da3f835947de2b67395dffd..a31f0952eda29d00566632ed88b72a35fd910b8e 100644
--- a/samples/server/petstore/rust-server/output/rust-server-test/src/models.rs
+++ b/samples/server/petstore/rust-server/output/rust-server-test/src/models.rs
@@ -5,9 +5,27 @@ use serde::ser::Serializer;
 use std::collections::HashMap;
 use models;
 use swagger;
+use hyper::header::HeaderValue;
 use std::string::ParseError;
+use std::str::FromStr;
+use header::IntoHeaderValue;
 
 
+
+// Methods for converting between IntoHeaderValue<ANullableContainer> and HeaderValue
+
+impl From<IntoHeaderValue<ANullableContainer>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<ANullableContainer>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<ANullableContainer> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(ANullableContainer::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct ANullableContainer {
@@ -65,6 +83,21 @@ impl ::std::ops::DerefMut for AdditionalPropertiesObject {
 
 
 
+
+// Methods for converting between IntoHeaderValue<InlineObject> and HeaderValue
+
+impl From<IntoHeaderValue<InlineObject>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<InlineObject>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<InlineObject> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(InlineObject::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct InlineObject {
@@ -88,6 +121,21 @@ impl InlineObject {
 
 
 /// An object of objects
+
+// Methods for converting between IntoHeaderValue<ObjectOfObjects> and HeaderValue
+
+impl From<IntoHeaderValue<ObjectOfObjects>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<ObjectOfObjects>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<ObjectOfObjects> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(ObjectOfObjects::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct ObjectOfObjects {
@@ -106,6 +154,21 @@ impl ObjectOfObjects {
 }
 
 
+
+// Methods for converting between IntoHeaderValue<ObjectOfObjectsInner> and HeaderValue
+
+impl From<IntoHeaderValue<ObjectOfObjectsInner>> for HeaderValue {
+    fn from(hdr_value: IntoHeaderValue<ObjectOfObjectsInner>) -> Self {
+        HeaderValue::from_str(&hdr_value.to_string()).unwrap()
+    }
+}
+
+impl From<HeaderValue> for IntoHeaderValue<ObjectOfObjectsInner> {
+    fn from(hdr_value: HeaderValue) -> Self {
+        IntoHeaderValue(ObjectOfObjectsInner::from_str(hdr_value.to_str().unwrap()).unwrap())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "conversion", derive(LabelledGeneric))]
 pub struct ObjectOfObjectsInner {
diff --git a/samples/server/petstore/rust-server/output/rust-server-test/src/server/mod.rs b/samples/server/petstore/rust-server/output/rust-server-test/src/server/mod.rs
index 01eb2099cde3aa4b07a364ae92251b3bd74f905a..ef853042c6618d3d7a970b292294495317b78752 100644
--- a/samples/server/petstore/rust-server/output/rust-server-test/src/server/mod.rs
+++ b/samples/server/petstore/rust-server/output/rust-server-test/src/server/mod.rs
@@ -28,6 +28,7 @@ use {Api,
 
 #[allow(unused_imports)]
 use models;
+use header;
 
 pub mod context;