diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -50,48 +50,59 @@
     
     - use `setHeader` to add any required headers to requests
 
+* Model Inheritance
+
 * Default Parameter Values
 
 * Enum Parameters
 
+
 This is beta software; other cases may not be supported.
 
-### Codegen "config option" parameters
+### Codegen "additional properties" parameters
 
 These options allow some customization of the code generation process.
 
-**haskell-http-client specific options:**
+**haskell-http-client additional properties:**
 
-| OPTION                          | DESCRIPTION                                                                                                                   | DEFAULT  | ACTUAL                              |
-| ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- | -------- | ----------------------------------- |
+| OPTION                          | DESCRIPTION                                                                                                                   | DEFAULT  | ACTUAL                                |
+| ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- | -------- | ------------------------------------- |
 | allowFromJsonNulls              | allow JSON Null during model decoding from JSON                                                                               | true     | true              |
 | allowToJsonNulls                | allow emitting JSON Null during model encoding to JSON                                                                        | false    | false                |
-| dateFormat                      | format string used to parse/render a date                                                                                     | %Y-%m-%d |                       |
+| dateFormat                      | format string used to parse/render a date                                                                                     | %Y-%m-%d | %Y-%m-%d                      |
 | dateTimeFormat                  | format string used to parse/render a datetime. (Defaults to [formatISO8601Millis][1] when not provided)                       |          |                   |
 | generateFormUrlEncodedInstances | Generate FromForm/ToForm instances for models used by x-www-form-urlencoded operations (model fields must be primitive types) | true     | true |
 | generateLenses                  | Generate Lens optics for Models                                                                                               | true     | true                  |
 | generateModelConstructors       | Generate smart constructors (only supply required fields) for models                                                          | true     | true       |
 | modelDeriving                   | Additional classes to include in the deriving() clause of Models                                                              |          |                    |
+| strictFields                    | Add strictness annotations to all model fields                                                                                | true     | true                  |
 
 [1]: https://www.stackage.org/haddock/lts-9.0/iso8601-time-0.1.4/Data-Time-ISO8601.html#v:formatISO8601Millis
 
+An example setting _strictFields_ and _dateTimeFormat_:
+
+```
+java -jar swagger-codegen-cli.jar generate -i petstore.yaml -l haskell-http-client -o output/haskell-http-client -DstrictFields=true -DdateTimeFormat="%Y-%m-%dT%H:%M:%S%Q%z"
+```
+
 View the full list of Codegen "config option" parameters with the command:
 
 ```
-java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar config-help -l haskell-http-client
+java -jar swagger-codegen-cli.jar config-help -l haskell-http-client
 ```
 
+
 ### Example SwaggerPetstore Haddock documentation 
 
 An example of the generated haddock documentation targeting the server http://petstore.swagger.io/ (SwaggerPetstore) can be found [here][2]
 
-[2]: https://jonschoning.github.io/swaggerpetstore-haskell-http-client/
+[2]: https://hackage.haskell.org/package/swagger-petstore
 
 ### Example SwaggerPetstore App
 
 An example application using the auto-generated haskell-http-client bindings for the server http://petstore.swagger.io/ can be found [here][3]
 
-[3]: https://github.com/jonschoning/swagger-codegen/tree/haskell-http-client/samples/client/petstore/haskell-http-client/example-app
+[3]: https://github.com/swagger-api/swagger-codegen/tree/c7d145a4ba3c0627e04ece9eb97e354ac91be821/samples/client/petstore/haskell-http-client/example-app
 
 ### Usage Notes
 
@@ -103,22 +114,23 @@
 | SwaggerPetstore.API       | construct requetss                                  |
 | SwaggerPetstore.Model     | describes models                                    |
 | SwaggerPetstore.MimeTypes | encoding/decoding MIME types (content-types/accept) |
-| SwaggerPetstore.Lens      | lenses & traversals for model fields                |
+| SwaggerPetstore.Lens      | lenses for model fields                             |
 
 This library adds type safety around what swagger specifies as
 Produces and Consumes for each Operation (e.g. the list of MIME types an
 Operation can Produce (using 'accept' headers) and Consume (using 'content-type' headers).
 
 For example, if there is an Operation named _addFoo_, there will be a
-data type generated named _AddFoo_ (note the capitalization) which
-describes additional constraints and actions on the _addFoo_
-operation, which can be viewed in GHCi or via the Haddocks.
+data type generated named _AddFoo_ (note the capitalization), which
+describes additional constraints and actions on the _addFoo_ operation
+via its typeclass instances. These typeclass instances can be viewed
+in GHCi or via the Haddocks.
 
 * requried parameters are included as function arguments to _addFoo_
 * optional non-body parameters are included by using  `applyOptionalParam`
 * optional body parameters are set by using  `setBodyParam`
 
-Example for pretend _addFoo_ operation: 
+Example code generated for pretend _addFoo_ operation: 
 
 ```haskell
 data AddFoo 	
diff --git a/lib/SwaggerPetstore/API.hs b/lib/SwaggerPetstore/API.hs
--- a/lib/SwaggerPetstore/API.hs
+++ b/lib/SwaggerPetstore/API.hs
@@ -11,13 +11,15 @@
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE ConstraintKinds #-}
 {-# LANGUAGE InstanceSigs #-}
-{-# OPTIONS_GHC -fno-warn-unused-binds -fno-warn-unused-imports #-}
+{-# LANGUAGE NamedFieldPuns #-}
+{-# OPTIONS_GHC -fno-warn-name-shadowing -fno-warn-unused-binds -fno-warn-unused-imports #-}
 
 module SwaggerPetstore.API where
 
 
 import SwaggerPetstore.Model as M
 import SwaggerPetstore.MimeTypes
+import SwaggerPetstore.Lens
 
 import qualified Data.Aeson as A
 import Data.Aeson (Value)
@@ -52,6 +54,8 @@
 import qualified GHC.Base as P (Alternative)
 import qualified Control.Arrow as P (left)
 
+import qualified Lens.Micro as L
+
 import Data.Monoid ((<>))
 import Data.Function ((&))
 import Data.Set (Set)
@@ -676,11 +680,26 @@
 -- | Represents a request. The "req" type variable is the request type. The "res" type variable is the response type.
 data SwaggerPetstoreRequest req contentType res = SwaggerPetstoreRequest
   { rMethod  :: NH.Method   -- ^ Method of SwaggerPetstoreRequest
-  , urlPath :: [BCL.ByteString] -- ^ Endpoint of SwaggerPetstoreRequest
-  , params   :: Params -- ^ params of SwaggerPetstoreRequest
+  , rUrlPath :: [BCL.ByteString] -- ^ Endpoint of SwaggerPetstoreRequest
+  , rParams   :: Params -- ^ params of SwaggerPetstoreRequest
   }
   deriving (P.Show)
 
+-- | 'rMethod' Lens
+rMethodL :: Lens_' (SwaggerPetstoreRequest req contentType res) NH.Method
+rMethodL f SwaggerPetstoreRequest{..} = (\rMethod -> SwaggerPetstoreRequest { rMethod, ..} ) <$> f rMethod
+{-# INLINE rMethodL #-}
+
+-- | 'rUrlPath' Lens
+rUrlPathL :: Lens_' (SwaggerPetstoreRequest req contentType res) [BCL.ByteString]
+rUrlPathL f SwaggerPetstoreRequest{..} = (\rUrlPath -> SwaggerPetstoreRequest { rUrlPath, ..} ) <$> f rUrlPath
+{-# INLINE rUrlPathL #-}
+
+-- | 'rParams' Lens
+rParamsL :: Lens_' (SwaggerPetstoreRequest req contentType res) Params
+rParamsL f SwaggerPetstoreRequest{..} = (\rParams -> SwaggerPetstoreRequest { rParams, ..} ) <$> f rParams
+{-# INLINE rParamsL #-}
+
 -- | Request Params
 data Params = Params
   { paramsQuery :: NH.Query
@@ -689,6 +708,21 @@
   }
   deriving (P.Show)
 
+-- | 'paramsQuery' Lens
+paramsQueryL :: Lens_' Params NH.Query
+paramsQueryL f Params{..} = (\paramsQuery -> Params { paramsQuery, ..} ) <$> f paramsQuery
+{-# INLINE paramsQueryL #-}
+
+-- | 'paramsHeaders' Lens
+paramsHeadersL :: Lens_' Params NH.RequestHeaders
+paramsHeadersL f Params{..} = (\paramsHeaders -> Params { paramsHeaders, ..} ) <$> f paramsHeaders
+{-# INLINE paramsHeadersL #-}
+
+-- | 'paramsBody' Lens
+paramsBodyL :: Lens_' Params ParamBody
+paramsBodyL f Params{..} = (\paramsBody -> Params { paramsBody, ..} ) <$> f paramsBody
+{-# INLINE paramsBodyL #-}
+
 -- | Request Body
 data ParamBody
   = ParamBodyNone
@@ -709,15 +743,18 @@
 _mkParams = Params [] [] ParamBodyNone
 
 setHeader :: SwaggerPetstoreRequest req contentType res -> [NH.Header] -> SwaggerPetstoreRequest req contentType res
-setHeader req header = 
-    let _params = params (req `removeHeader` P.fmap P.fst header)
-    in req { params = _params { paramsHeaders = header P.++ paramsHeaders _params } }
+setHeader req header =
+  req `removeHeader` P.fmap P.fst header &
+  L.over (rParamsL . paramsHeadersL) (header P.++)
 
 removeHeader :: SwaggerPetstoreRequest req contentType res -> [NH.HeaderName] -> SwaggerPetstoreRequest req contentType res
-removeHeader req header = 
-    let _params = params req
-    in req { params = _params { paramsHeaders = [h | h <- paramsHeaders _params, cifst h `P.notElem` P.fmap CI.mk header] } }
-  where cifst = CI.mk . P.fst
+removeHeader req header =
+  req &
+  L.over
+    (rParamsL . paramsHeadersL)
+    (P.filter (\h -> cifst h `P.notElem` P.fmap CI.mk header))
+  where
+    cifst = CI.mk . P.fst
 
 
 _setContentTypeHeader :: forall req contentType res. MimeType contentType => SwaggerPetstoreRequest req contentType res -> SwaggerPetstoreRequest req contentType res
@@ -734,35 +771,34 @@
 
 _setQuery :: SwaggerPetstoreRequest req contentType res -> [NH.QueryItem] -> SwaggerPetstoreRequest req contentType res
 _setQuery req query = 
-    let _params = params req 
-    in req { params = _params { paramsQuery = query P.++ [q | q <- paramsQuery _params, cifst q `P.notElem` P.fmap cifst query] } }
-  where cifst = CI.mk . P.fst
+  req &
+  L.over
+    (rParamsL . paramsQueryL)
+    ((query P.++) . P.filter (\q -> cifst q `P.notElem` P.fmap cifst query))
+  where
+    cifst = CI.mk . P.fst
 
 _addForm :: SwaggerPetstoreRequest req contentType res -> WH.Form -> SwaggerPetstoreRequest req contentType res
 _addForm req newform = 
-    let _params = params req
-        form = case paramsBody _params of
+    let form = case paramsBody (rParams req) of
             ParamBodyFormUrlEncoded _form -> _form
             _ -> mempty
-    in req { params = _params { paramsBody = ParamBodyFormUrlEncoded (newform <> form) } }
+    in req & L.set (rParamsL . paramsBodyL) (ParamBodyFormUrlEncoded (newform <> form))
 
 _addMultiFormPart :: SwaggerPetstoreRequest req contentType res -> NH.Part -> SwaggerPetstoreRequest req contentType res
 _addMultiFormPart req newpart = 
-    let _params = params req
-        parts = case paramsBody _params of
+    let parts = case paramsBody (rParams req) of
             ParamBodyMultipartFormData _parts -> _parts
             _ -> []
-    in req { params = _params { paramsBody = ParamBodyMultipartFormData (newpart : parts) } }
+    in req & L.set (rParamsL . paramsBodyL) (ParamBodyMultipartFormData (newpart : parts))
 
 _setBodyBS :: SwaggerPetstoreRequest req contentType res -> B.ByteString -> SwaggerPetstoreRequest req contentType res
 _setBodyBS req body = 
-    let _params = params req
-    in req { params = _params { paramsBody = ParamBodyB body } }
+    req & L.set (rParamsL . paramsBodyL) (ParamBodyB body)
 
 _setBodyLBS :: SwaggerPetstoreRequest req contentType res -> BL.ByteString -> SwaggerPetstoreRequest req contentType res
 _setBodyLBS req body = 
-    let _params = params req
-    in req { params = _params { paramsBody = ParamBodyBL body } }
+    req & L.set (rParamsL . paramsBodyL) (ParamBodyBL body)
 
 
 -- ** Params Utils
diff --git a/lib/SwaggerPetstore/Client.hs b/lib/SwaggerPetstore/Client.hs
--- a/lib/SwaggerPetstore/Client.hs
+++ b/lib/SwaggerPetstore/Client.hs
@@ -225,15 +225,15 @@
   -> accept -- ^ "accept" 'MimeType'
   -> IO (InitRequest req contentType res accept) -- ^ initialized request
 _toInitRequest config req0 accept = do
-  parsedReq <- NH.parseRequest $ BCL.unpack $ BCL.append (configHost config) (BCL.concat (urlPath req0))
+  parsedReq <- NH.parseRequest $ BCL.unpack $ BCL.append (configHost config) (BCL.concat (rUrlPath req0))
   let req1 = _setAcceptHeader req0 accept & _setContentTypeHeader
-      reqHeaders = ("User-Agent", WH.toHeader (configUserAgent config)) : paramsHeaders (params req1)
-      reqQuery = NH.renderQuery True (paramsQuery (params req1))
+      reqHeaders = ("User-Agent", WH.toHeader (configUserAgent config)) : paramsHeaders (rParams req1)
+      reqQuery = NH.renderQuery True (paramsQuery (rParams req1))
       pReq = parsedReq { NH.method = (rMethod req1)
                        , NH.requestHeaders = reqHeaders
                        , NH.queryString = reqQuery
                        }
-  outReq <- case paramsBody (params req1) of
+  outReq <- case paramsBody (rParams req1) of
     ParamBodyNone -> pure (pReq { NH.requestBody = mempty })
     ParamBodyB bs -> pure (pReq { NH.requestBody = NH.RequestBodyBS bs })
     ParamBodyBL bl -> pure (pReq { NH.requestBody = NH.RequestBodyLBS bl })
diff --git a/lib/SwaggerPetstore/Lens.hs b/lib/SwaggerPetstore/Lens.hs
--- a/lib/SwaggerPetstore/Lens.hs
+++ b/lib/SwaggerPetstore/Lens.hs
@@ -29,174 +29,165 @@
 
 -- * Type Aliases
 
-type Traversal_' s a = Traversal_ s s a a
-type Traversal_ s t a b = forall (f :: * -> *). Applicative f => (a -> f b) -> s -> f t
 type Lens_' s a = Lens_ s s a a
 type Lens_ s t a b = forall (f :: * -> *). Functor f => (a -> f b) -> s -> f t
 
 
 -- * ApiResponse
 
--- | 'apiResponseCode' Traversal
-apiResponseCodeT :: Traversal_' ApiResponse Int
-apiResponseCodeT f s = _mtraversal apiResponseCode (\b -> s { apiResponseCode = Just b}) f s
-{-# INLINE apiResponseCodeT #-}
+-- | 'apiResponseCode' Lens
+apiResponseCodeL :: Lens_' ApiResponse (Maybe Int)
+apiResponseCodeL f ApiResponse{..} = (\apiResponseCode -> ApiResponse { apiResponseCode, ..} ) <$> f apiResponseCode
+{-# INLINE apiResponseCodeL #-}
 
--- | 'apiResponseType' Traversal
-apiResponseTypeT :: Traversal_' ApiResponse Text
-apiResponseTypeT f s = _mtraversal apiResponseType (\b -> s { apiResponseType = Just b}) f s
-{-# INLINE apiResponseTypeT #-}
+-- | 'apiResponseType' Lens
+apiResponseTypeL :: Lens_' ApiResponse (Maybe Text)
+apiResponseTypeL f ApiResponse{..} = (\apiResponseType -> ApiResponse { apiResponseType, ..} ) <$> f apiResponseType
+{-# INLINE apiResponseTypeL #-}
 
--- | 'apiResponseMessage' Traversal
-apiResponseMessageT :: Traversal_' ApiResponse Text
-apiResponseMessageT f s = _mtraversal apiResponseMessage (\b -> s { apiResponseMessage = Just b}) f s
-{-# INLINE apiResponseMessageT #-}
+-- | 'apiResponseMessage' Lens
+apiResponseMessageL :: Lens_' ApiResponse (Maybe Text)
+apiResponseMessageL f ApiResponse{..} = (\apiResponseMessage -> ApiResponse { apiResponseMessage, ..} ) <$> f apiResponseMessage
+{-# INLINE apiResponseMessageL #-}
 
 
 
 -- * Category
 
--- | 'categoryId' Traversal
-categoryIdT :: Traversal_' Category Integer
-categoryIdT f s = _mtraversal categoryId (\b -> s { categoryId = Just b}) f s
-{-# INLINE categoryIdT #-}
+-- | 'categoryId' Lens
+categoryIdL :: Lens_' Category (Maybe Integer)
+categoryIdL f Category{..} = (\categoryId -> Category { categoryId, ..} ) <$> f categoryId
+{-# INLINE categoryIdL #-}
 
--- | 'categoryName' Traversal
-categoryNameT :: Traversal_' Category Text
-categoryNameT f s = _mtraversal categoryName (\b -> s { categoryName = Just b}) f s
-{-# INLINE categoryNameT #-}
+-- | 'categoryName' Lens
+categoryNameL :: Lens_' Category (Maybe Text)
+categoryNameL f Category{..} = (\categoryName -> Category { categoryName, ..} ) <$> f categoryName
+{-# INLINE categoryNameL #-}
 
 
 
 -- * Order
 
--- | 'orderId' Traversal
-orderIdT :: Traversal_' Order Integer
-orderIdT f s = _mtraversal orderId (\b -> s { orderId = Just b}) f s
-{-# INLINE orderIdT #-}
+-- | 'orderId' Lens
+orderIdL :: Lens_' Order (Maybe Integer)
+orderIdL f Order{..} = (\orderId -> Order { orderId, ..} ) <$> f orderId
+{-# INLINE orderIdL #-}
 
--- | 'orderPetId' Traversal
-orderPetIdT :: Traversal_' Order Integer
-orderPetIdT f s = _mtraversal orderPetId (\b -> s { orderPetId = Just b}) f s
-{-# INLINE orderPetIdT #-}
+-- | 'orderPetId' Lens
+orderPetIdL :: Lens_' Order (Maybe Integer)
+orderPetIdL f Order{..} = (\orderPetId -> Order { orderPetId, ..} ) <$> f orderPetId
+{-# INLINE orderPetIdL #-}
 
--- | 'orderQuantity' Traversal
-orderQuantityT :: Traversal_' Order Int
-orderQuantityT f s = _mtraversal orderQuantity (\b -> s { orderQuantity = Just b}) f s
-{-# INLINE orderQuantityT #-}
+-- | 'orderQuantity' Lens
+orderQuantityL :: Lens_' Order (Maybe Int)
+orderQuantityL f Order{..} = (\orderQuantity -> Order { orderQuantity, ..} ) <$> f orderQuantity
+{-# INLINE orderQuantityL #-}
 
--- | 'orderShipDate' Traversal
-orderShipDateT :: Traversal_' Order UTCTime
-orderShipDateT f s = _mtraversal orderShipDate (\b -> s { orderShipDate = Just b}) f s
-{-# INLINE orderShipDateT #-}
+-- | 'orderShipDate' Lens
+orderShipDateL :: Lens_' Order (Maybe UTCTime)
+orderShipDateL f Order{..} = (\orderShipDate -> Order { orderShipDate, ..} ) <$> f orderShipDate
+{-# INLINE orderShipDateL #-}
 
--- | 'orderStatus' Traversal
-orderStatusT :: Traversal_' Order Text
-orderStatusT f s = _mtraversal orderStatus (\b -> s { orderStatus = Just b}) f s
-{-# INLINE orderStatusT #-}
+-- | 'orderStatus' Lens
+orderStatusL :: Lens_' Order (Maybe Text)
+orderStatusL f Order{..} = (\orderStatus -> Order { orderStatus, ..} ) <$> f orderStatus
+{-# INLINE orderStatusL #-}
 
--- | 'orderComplete' Traversal
-orderCompleteT :: Traversal_' Order Bool
-orderCompleteT f s = _mtraversal orderComplete (\b -> s { orderComplete = Just b}) f s
-{-# INLINE orderCompleteT #-}
+-- | 'orderComplete' Lens
+orderCompleteL :: Lens_' Order (Maybe Bool)
+orderCompleteL f Order{..} = (\orderComplete -> Order { orderComplete, ..} ) <$> f orderComplete
+{-# INLINE orderCompleteL #-}
 
 
 
 -- * Pet
 
--- | 'petId' Traversal
-petIdT :: Traversal_' Pet Integer
-petIdT f s = _mtraversal petId (\b -> s { petId = Just b}) f s
-{-# INLINE petIdT #-}
+-- | 'petId' Lens
+petIdL :: Lens_' Pet (Maybe Integer)
+petIdL f Pet{..} = (\petId -> Pet { petId, ..} ) <$> f petId
+{-# INLINE petIdL #-}
 
--- | 'petCategory' Traversal
-petCategoryT :: Traversal_' Pet Category
-petCategoryT f s = _mtraversal petCategory (\b -> s { petCategory = Just b}) f s
-{-# INLINE petCategoryT #-}
+-- | 'petCategory' Lens
+petCategoryL :: Lens_' Pet (Maybe Category)
+petCategoryL f Pet{..} = (\petCategory -> Pet { petCategory, ..} ) <$> f petCategory
+{-# INLINE petCategoryL #-}
 
 -- | 'petName' Lens
-petNameL :: Lens_' Pet Text
+petNameL :: Lens_' Pet (Text)
 petNameL f Pet{..} = (\petName -> Pet { petName, ..} ) <$> f petName
 {-# INLINE petNameL #-}
 
 -- | 'petPhotoUrls' Lens
-petPhotoUrlsL :: Lens_' Pet [Text]
+petPhotoUrlsL :: Lens_' Pet ([Text])
 petPhotoUrlsL f Pet{..} = (\petPhotoUrls -> Pet { petPhotoUrls, ..} ) <$> f petPhotoUrls
 {-# INLINE petPhotoUrlsL #-}
 
--- | 'petTags' Traversal
-petTagsT :: Traversal_' Pet [Tag]
-petTagsT f s = _mtraversal petTags (\b -> s { petTags = Just b}) f s
-{-# INLINE petTagsT #-}
+-- | 'petTags' Lens
+petTagsL :: Lens_' Pet (Maybe [Tag])
+petTagsL f Pet{..} = (\petTags -> Pet { petTags, ..} ) <$> f petTags
+{-# INLINE petTagsL #-}
 
--- | 'petStatus' Traversal
-petStatusT :: Traversal_' Pet Text
-petStatusT f s = _mtraversal petStatus (\b -> s { petStatus = Just b}) f s
-{-# INLINE petStatusT #-}
+-- | 'petStatus' Lens
+petStatusL :: Lens_' Pet (Maybe Text)
+petStatusL f Pet{..} = (\petStatus -> Pet { petStatus, ..} ) <$> f petStatus
+{-# INLINE petStatusL #-}
 
 
 
 -- * Tag
 
--- | 'tagId' Traversal
-tagIdT :: Traversal_' Tag Integer
-tagIdT f s = _mtraversal tagId (\b -> s { tagId = Just b}) f s
-{-# INLINE tagIdT #-}
+-- | 'tagId' Lens
+tagIdL :: Lens_' Tag (Maybe Integer)
+tagIdL f Tag{..} = (\tagId -> Tag { tagId, ..} ) <$> f tagId
+{-# INLINE tagIdL #-}
 
--- | 'tagName' Traversal
-tagNameT :: Traversal_' Tag Text
-tagNameT f s = _mtraversal tagName (\b -> s { tagName = Just b}) f s
-{-# INLINE tagNameT #-}
+-- | 'tagName' Lens
+tagNameL :: Lens_' Tag (Maybe Text)
+tagNameL f Tag{..} = (\tagName -> Tag { tagName, ..} ) <$> f tagName
+{-# INLINE tagNameL #-}
 
 
 
 -- * User
 
--- | 'userId' Traversal
-userIdT :: Traversal_' User Integer
-userIdT f s = _mtraversal userId (\b -> s { userId = Just b}) f s
-{-# INLINE userIdT #-}
-
--- | 'userUsername' Traversal
-userUsernameT :: Traversal_' User Text
-userUsernameT f s = _mtraversal userUsername (\b -> s { userUsername = Just b}) f s
-{-# INLINE userUsernameT #-}
-
--- | 'userFirstName' Traversal
-userFirstNameT :: Traversal_' User Text
-userFirstNameT f s = _mtraversal userFirstName (\b -> s { userFirstName = Just b}) f s
-{-# INLINE userFirstNameT #-}
+-- | 'userId' Lens
+userIdL :: Lens_' User (Maybe Integer)
+userIdL f User{..} = (\userId -> User { userId, ..} ) <$> f userId
+{-# INLINE userIdL #-}
 
--- | 'userLastName' Traversal
-userLastNameT :: Traversal_' User Text
-userLastNameT f s = _mtraversal userLastName (\b -> s { userLastName = Just b}) f s
-{-# INLINE userLastNameT #-}
+-- | 'userUsername' Lens
+userUsernameL :: Lens_' User (Maybe Text)
+userUsernameL f User{..} = (\userUsername -> User { userUsername, ..} ) <$> f userUsername
+{-# INLINE userUsernameL #-}
 
--- | 'userEmail' Traversal
-userEmailT :: Traversal_' User Text
-userEmailT f s = _mtraversal userEmail (\b -> s { userEmail = Just b}) f s
-{-# INLINE userEmailT #-}
+-- | 'userFirstName' Lens
+userFirstNameL :: Lens_' User (Maybe Text)
+userFirstNameL f User{..} = (\userFirstName -> User { userFirstName, ..} ) <$> f userFirstName
+{-# INLINE userFirstNameL #-}
 
--- | 'userPassword' Traversal
-userPasswordT :: Traversal_' User Text
-userPasswordT f s = _mtraversal userPassword (\b -> s { userPassword = Just b}) f s
-{-# INLINE userPasswordT #-}
+-- | 'userLastName' Lens
+userLastNameL :: Lens_' User (Maybe Text)
+userLastNameL f User{..} = (\userLastName -> User { userLastName, ..} ) <$> f userLastName
+{-# INLINE userLastNameL #-}
 
--- | 'userPhone' Traversal
-userPhoneT :: Traversal_' User Text
-userPhoneT f s = _mtraversal userPhone (\b -> s { userPhone = Just b}) f s
-{-# INLINE userPhoneT #-}
+-- | 'userEmail' Lens
+userEmailL :: Lens_' User (Maybe Text)
+userEmailL f User{..} = (\userEmail -> User { userEmail, ..} ) <$> f userEmail
+{-# INLINE userEmailL #-}
 
--- | 'userUserStatus' Traversal
-userUserStatusT :: Traversal_' User Int
-userUserStatusT f s = _mtraversal userUserStatus (\b -> s { userUserStatus = Just b}) f s
-{-# INLINE userUserStatusT #-}
+-- | 'userPassword' Lens
+userPasswordL :: Lens_' User (Maybe Text)
+userPasswordL f User{..} = (\userPassword -> User { userPassword, ..} ) <$> f userPassword
+{-# INLINE userPasswordL #-}
 
+-- | 'userPhone' Lens
+userPhoneL :: Lens_' User (Maybe Text)
+userPhoneL f User{..} = (\userPhone -> User { userPhone, ..} ) <$> f userPhone
+{-# INLINE userPhoneL #-}
 
+-- | 'userUserStatus' Lens
+userUserStatusL :: Lens_' User (Maybe Int)
+userUserStatusL f User{..} = (\userUserStatus -> User { userUserStatus, ..} ) <$> f userUserStatus
+{-# INLINE userUserStatusL #-}
 
 
--- * Helpers
-
-_mtraversal :: Applicative f => (b -> Maybe t) -> (a -> b) -> (t -> f a) -> b -> f b
-_mtraversal x fsb f s = maybe (pure s) (\a -> fsb <$> f a) (x s)
-{-# INLINE _mtraversal #-}
diff --git a/lib/SwaggerPetstore/Model.hs b/lib/SwaggerPetstore/Model.hs
--- a/lib/SwaggerPetstore/Model.hs
+++ b/lib/SwaggerPetstore/Model.hs
@@ -2,7 +2,6 @@
 Module : SwaggerPetstore.Model
 -}
 
-{-# LANGUAGE DeriveAnyClass #-}
 {-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE DeriveFoldable #-}
 {-# LANGUAGE DeriveGeneric #-}
@@ -53,9 +52,9 @@
 -- 
 -- Describes the result of uploading an image resource
 data ApiResponse = ApiResponse
-  { apiResponseCode :: Maybe Int -- ^ "code"
-  , apiResponseType :: Maybe Text -- ^ "type"
-  , apiResponseMessage :: Maybe Text -- ^ "message"
+  { apiResponseCode :: !(Maybe Int) -- ^ "code"
+  , apiResponseType :: !(Maybe Text) -- ^ "type"
+  , apiResponseMessage :: !(Maybe Text) -- ^ "message"
   } deriving (P.Show,P.Eq,P.Typeable)
 
 instance A.FromJSON ApiResponse where
@@ -92,8 +91,8 @@
 -- 
 -- A category for a pet
 data Category = Category
-  { categoryId :: Maybe Integer -- ^ "id"
-  , categoryName :: Maybe Text -- ^ "name"
+  { categoryId :: !(Maybe Integer) -- ^ "id"
+  , categoryName :: !(Maybe Text) -- ^ "name"
   } deriving (P.Show,P.Eq,P.Typeable)
 
 instance A.FromJSON Category where
@@ -127,12 +126,12 @@
 -- 
 -- An order for a pets from the pet store
 data Order = Order
-  { orderId :: Maybe Integer -- ^ "id"
-  , orderPetId :: Maybe Integer -- ^ "petId"
-  , orderQuantity :: Maybe Int -- ^ "quantity"
-  , orderShipDate :: Maybe UTCTime -- ^ "shipDate"
-  , orderStatus :: Maybe Text -- ^ "status" - Order Status
-  , orderComplete :: Maybe Bool -- ^ "complete"
+  { orderId :: !(Maybe Integer) -- ^ "id"
+  , orderPetId :: !(Maybe Integer) -- ^ "petId"
+  , orderQuantity :: !(Maybe Int) -- ^ "quantity"
+  , orderShipDate :: !(Maybe UTCTime) -- ^ "shipDate"
+  , orderStatus :: !(Maybe Text) -- ^ "status" - Order Status
+  , orderComplete :: !(Maybe Bool) -- ^ "complete"
   } deriving (P.Show,P.Eq,P.Typeable)
 
 instance A.FromJSON Order where
@@ -178,12 +177,12 @@
 -- 
 -- A pet for sale in the pet store
 data Pet = Pet
-  { petId :: Maybe Integer -- ^ "id"
-  , petCategory :: Maybe Category -- ^ "category"
-  , petName :: Text -- ^ /Required/ "name"
-  , petPhotoUrls :: [Text] -- ^ /Required/ "photoUrls"
-  , petTags :: Maybe [Tag] -- ^ "tags"
-  , petStatus :: Maybe Text -- ^ "status" - pet status in the store
+  { petId :: !(Maybe Integer) -- ^ "id"
+  , petCategory :: !(Maybe Category) -- ^ "category"
+  , petName :: !(Text) -- ^ /Required/ "name"
+  , petPhotoUrls :: !([Text]) -- ^ /Required/ "photoUrls"
+  , petTags :: !(Maybe [Tag]) -- ^ "tags"
+  , petStatus :: !(Maybe Text) -- ^ "status" - pet status in the store
   } deriving (P.Show,P.Eq,P.Typeable)
 
 instance A.FromJSON Pet where
@@ -231,8 +230,8 @@
 -- 
 -- A tag for a pet
 data Tag = Tag
-  { tagId :: Maybe Integer -- ^ "id"
-  , tagName :: Maybe Text -- ^ "name"
+  { tagId :: !(Maybe Integer) -- ^ "id"
+  , tagName :: !(Maybe Text) -- ^ "name"
   } deriving (P.Show,P.Eq,P.Typeable)
 
 instance A.FromJSON Tag where
@@ -266,14 +265,14 @@
 -- 
 -- A User who is purchasing from the pet store
 data User = User
-  { userId :: Maybe Integer -- ^ "id"
-  , userUsername :: Maybe Text -- ^ "username"
-  , userFirstName :: Maybe Text -- ^ "firstName"
-  , userLastName :: Maybe Text -- ^ "lastName"
-  , userEmail :: Maybe Text -- ^ "email"
-  , userPassword :: Maybe Text -- ^ "password"
-  , userPhone :: Maybe Text -- ^ "phone"
-  , userUserStatus :: Maybe Int -- ^ "userStatus" - User Status
+  { userId :: !(Maybe Integer) -- ^ "id"
+  , userUsername :: !(Maybe Text) -- ^ "username"
+  , userFirstName :: !(Maybe Text) -- ^ "firstName"
+  , userLastName :: !(Maybe Text) -- ^ "lastName"
+  , userEmail :: !(Maybe Text) -- ^ "email"
+  , userPassword :: !(Maybe Text) -- ^ "password"
+  , userPhone :: !(Maybe Text) -- ^ "phone"
+  , userUserStatus :: !(Maybe Int) -- ^ "userStatus" - User Status
   } deriving (P.Show,P.Eq,P.Typeable)
 
 instance A.FromJSON User where
@@ -365,14 +364,14 @@
 
 -- * Date Formatting
 
--- | @TI.parseTimeM True TI.defaultTimeLocale ""@
+-- | @TI.parseTimeM True TI.defaultTimeLocale "%Y-%m-%d"@
 _readDate :: (TI.ParseTime t, Monad m) => String -> m t
 _readDate =
-  TI.parseTimeM True TI.defaultTimeLocale ""
+  TI.parseTimeM True TI.defaultTimeLocale "%Y-%m-%d"
 {-# INLINE _readDate #-}
 
--- | @TI.formatTime TI.defaultTimeLocale ""@
+-- | @TI.formatTime TI.defaultTimeLocale "%Y-%m-%d"@
 _showDate :: TI.FormatTime t => t -> String
 _showDate =
-  TI.formatTime TI.defaultTimeLocale ""
+  TI.formatTime TI.defaultTimeLocale "%Y-%m-%d"
 {-# INLINE _showDate #-}
diff --git a/swagger-petstore.cabal b/swagger-petstore.cabal
--- a/swagger-petstore.cabal
+++ b/swagger-petstore.cabal
@@ -3,7 +3,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           swagger-petstore
-version:        0.0.1.0
+version:        0.0.1.1
 synopsis:       Auto-generated swagger-petstore API Client
 description:    .
                 Client library for calling the swagger-petstore API based on http-client.
@@ -33,7 +33,7 @@
 library
   hs-source-dirs:
       lib
-  ghc-options: -Wall
+  ghc-options: -Wall -funbox-strict-fields
   build-depends:
       base >=4.7 && <5.0
     , transformers >=0.4.0.0
@@ -57,6 +57,7 @@
     , monad-logger >=0.3 && <0.4
     , safe-exceptions <0.2
     , case-insensitive
+    , microlens >= 0.4.3 && <0.5
   exposed-modules:
       SwaggerPetstore
       SwaggerPetstore.API
@@ -73,7 +74,7 @@
   main-is: Test.hs
   hs-source-dirs:
       tests
-  ghc-options: -fno-warn-orphans
+  ghc-options: -Wall -fno-warn-orphans
   build-depends:
       base >=4.7 && <5.0
     , transformers >=0.4.0.0
diff --git a/tests/Instances.hs b/tests/Instances.hs
--- a/tests/Instances.hs
+++ b/tests/Instances.hs
@@ -1,3 +1,5 @@
+{-# OPTIONS_GHC -fno-warn-unused-imports #-}
+
 module Instances where
 
 import Data.Text (Text, pack)
diff --git a/tests/PropMime.hs b/tests/PropMime.hs
--- a/tests/PropMime.hs
+++ b/tests/PropMime.hs
@@ -1,6 +1,7 @@
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE ConstraintKinds #-}
+{-# OPTIONS_GHC -fno-warn-unused-imports #-}
 
 module PropMime where