diff --git a/Aws/Aws.hs b/Aws/Aws.hs
--- a/Aws/Aws.hs
+++ b/Aws/Aws.hs
@@ -263,11 +263,7 @@
                      -> ServiceConfiguration r NormalQuery
                      -> HTTP.Manager
                      -> r
-#if MIN_VERSION_conduit(1, 0, 0)
                      -> C.Producer (ResourceT IO) (Response (ResponseMetadata a) a)
-#else
-                     -> C.GSource (ResourceT IO) (Response (ResponseMetadata a) a)
-#endif
 awsIteratedSource cfg scfg manager req_ = go req_
   where go request = do resp <- lift $ aws cfg scfg manager request
                         C.yield resp
@@ -283,16 +279,8 @@
                      -> ServiceConfiguration r NormalQuery
                      -> HTTP.Manager
                      -> r
-#if MIN_VERSION_conduit(1, 0, 0)
                      -> C.Producer (ResourceT IO) i
-#else
-                     -> C.GSource (ResourceT IO) i
-#endif
 awsIteratedList cfg scfg manager req
   = awsIteratedSource cfg scfg manager req
-#if MIN_VERSION_conduit(1, 0, 0)
     C.=$=
-#else
-    C.>+>
-#endif
     CL.concatMapM (fmap listResponse . readResponseIO)
diff --git a/Aws/Core.hs b/Aws/Core.hs
--- a/Aws/Core.hs
+++ b/Aws/Core.hs
@@ -294,7 +294,8 @@
 
 -- | Request method. Not all request methods are supported by all services.
 data Method
-    = Get       -- ^ GET method. Put all request parameters in a query string and HTTP headers.
+    = Head      -- ^ HEAD method. Put all request parameters in a query string and HTTP headers.
+    | Get       -- ^ GET method. Put all request parameters in a query string and HTTP headers.
     | PostQuery -- ^ POST method. Put all request parameters in a query string and HTTP headers, but send the query string
                 --   as a POST payload
     | Post      -- ^ POST method. Sends a service- and request-specific request body.
@@ -304,6 +305,7 @@
 
 -- | HTTP method associated with a request method.
 httpMethod :: Method -> HTTP.Method
+httpMethod Head      = "HEAD"
 httpMethod Get       = "GET"
 httpMethod PostQuery = "POST"
 httpMethod Post      = "POST"
@@ -356,7 +358,7 @@
       , HTTP.port = sqPort
       , HTTP.path = sqPath
       , HTTP.queryString = HTTP.renderQuery False sqQuery
-      , HTTP.requestHeaders = catMaybes [fmap (\d -> ("Date", fmtRfc822Time d)) sqDate
+      , HTTP.requestHeaders = catMaybes [ checkDate (\d -> ("Date", fmtRfc822Time d)) sqDate
                                         , fmap (\c -> ("Content-Type", c)) contentType
                                         , fmap (\md5 -> ("Content-MD5", Base64.encode $ Serialize.encode md5)) sqContentMd5
                                         , fmap (\auth -> ("Authorization", auth)) sqAuthorization]
@@ -368,15 +370,12 @@
                                             Nothing -> HTTP.RequestBodyBuilder 0 mempty
                                             Just x  -> x
       , HTTP.decompress = HTTP.alwaysDecompress
-#if MIN_VERSION_http_conduit(1, 9, 0)
       , HTTP.checkStatus = \_ _ _ -> Nothing
-#else
-      , HTTP.checkStatus = \_ _ -> Nothing
-#endif
       }
     where contentType = case sqMethod of
                            PostQuery -> Just "application/x-www-form-urlencoded; charset=utf-8"
                            _ -> sqContentType
+          checkDate f mb = maybe (f <$> mb) (const Nothing) $ lookup "date" sqOtherHeaders
 
 -- | Create a URI fro a 'SignedQuery' object.
 --
diff --git a/Aws/Ec2/InstanceMetadata.hs b/Aws/Ec2/InstanceMetadata.hs
new file mode 100644
--- /dev/null
+++ b/Aws/Ec2/InstanceMetadata.hs
@@ -0,0 +1,34 @@
+module Aws.Ec2.InstanceMetadata where
+
+import           Control.Applicative
+import           Control.Exception
+import           Control.Failure
+import           Control.Monad.Trans.Resource
+import qualified Data.ByteString.Lazy as L
+import qualified Data.ByteString.Lazy.Char8 as B8
+import           Data.ByteString.Lazy.UTF8 as BU
+import           Data.Typeable
+import qualified Network.HTTP.Conduit as HTTP
+
+data InstanceMetadataException
+  = MetadataNotFound String
+  deriving (Show, Typeable)
+
+instance Exception InstanceMetadataException
+
+getInstanceMetadata :: HTTP.Manager -> String -> String -> ResIO L.ByteString
+getInstanceMetadata mgr p x = do req <- HTTP.parseUrl ("http://169.254.169.254/" ++ p ++ '/' : x)
+                                 HTTP.responseBody <$> HTTP.httpLbs req mgr
+
+getInstanceMetadataListing :: HTTP.Manager -> String -> ResIO [String]
+getInstanceMetadataListing mgr p = map BU.toString . B8.split '\n' <$> getInstanceMetadata mgr p ""
+
+getInstanceMetadataFirst :: HTTP.Manager -> String -> ResIO L.ByteString
+getInstanceMetadataFirst mgr p = do listing <- getInstanceMetadataListing mgr p
+                                    case listing of
+                                      [] -> failure (MetadataNotFound p)
+                                      (x:_) -> getInstanceMetadata mgr p x
+
+getInstanceMetadataOrFirst :: HTTP.Manager -> String -> Maybe String -> ResIO L.ByteString
+getInstanceMetadataOrFirst mgr p (Just x) = getInstanceMetadata mgr p x
+getInstanceMetadataOrFirst mgr p Nothing = getInstanceMetadataFirst mgr p
diff --git a/Aws/S3/Commands.hs b/Aws/S3/Commands.hs
--- a/Aws/S3/Commands.hs
+++ b/Aws/S3/Commands.hs
@@ -2,9 +2,11 @@
 (
   module Aws.S3.Commands.CopyObject
 , module Aws.S3.Commands.DeleteObject
+, module Aws.S3.Commands.DeleteObjects
 , module Aws.S3.Commands.GetBucket
 , module Aws.S3.Commands.GetObject
 , module Aws.S3.Commands.GetService
+, module Aws.S3.Commands.HeadObject
 , module Aws.S3.Commands.PutBucket
 , module Aws.S3.Commands.PutObject
 )
@@ -12,8 +14,10 @@
 
 import Aws.S3.Commands.CopyObject
 import Aws.S3.Commands.DeleteObject
+import Aws.S3.Commands.DeleteObjects
 import Aws.S3.Commands.GetBucket
 import Aws.S3.Commands.GetObject
 import Aws.S3.Commands.GetService
+import Aws.S3.Commands.HeadObject
 import Aws.S3.Commands.PutBucket
 import Aws.S3.Commands.PutObject
diff --git a/Aws/S3/Commands/DeleteObjects.hs b/Aws/S3/Commands/DeleteObjects.hs
new file mode 100644
--- /dev/null
+++ b/Aws/S3/Commands/DeleteObjects.hs
@@ -0,0 +1,126 @@
+module Aws.S3.Commands.DeleteObjects where
+
+import           Aws.Core
+import           Aws.S3.Core
+import qualified Data.Map             as M
+import           Data.Maybe
+import qualified Data.Text            as T
+import qualified Data.Text.Encoding   as T
+import qualified Network.HTTP.Conduit as HTTP
+import qualified Network.HTTP.Types   as HTTP
+import qualified Text.XML             as XML
+import qualified Text.XML.Cursor      as Cu
+import           Text.XML.Cursor      (($/), (&|))
+import qualified Crypto.Classes       as C (hash)
+import qualified Data.ByteString.Char8 as B
+import           Data.ByteString.Char8 ({- IsString -})
+import           Control.Applicative     ((<$>))
+
+data DeleteObjects
+    = DeleteObjects {
+        dosBucket  :: Bucket
+      , dosObjects :: [(Object, Maybe T.Text)] -- snd is an optional versionId
+      , dosQuiet   :: Bool
+      , dosMultiFactorAuthentication :: Maybe T.Text
+      }
+    deriving (Show)
+
+-- simple use case: neither mfa, nor version specified, quiet
+deleteObjects :: Bucket -> [T.Text] -> DeleteObjects
+deleteObjects bucket objs =
+    DeleteObjects {
+            dosBucket  = bucket
+          , dosObjects = zip objs $ repeat Nothing
+          , dosQuiet   = True
+          , dosMultiFactorAuthentication = Nothing
+          }
+
+data DeleteObjectsResponse
+    = DeleteObjectsResponse {
+        dorDeleted :: [DORDeleted]
+      , dorErrors  :: [DORErrors]
+      }
+    deriving (Show)
+
+--omitting DeleteMarker because it appears superfluous
+data DORDeleted
+    = DORDeleted {
+        ddKey                   :: T.Text
+      , ddVersionId             :: Maybe T.Text
+      , ddDeleteMarkerVersionId :: Maybe T.Text
+      }
+    deriving (Show)
+
+data DORErrors
+    = DORErrors {
+        deKey     :: T.Text
+      , deCode    :: T.Text
+      , deMessage :: T.Text
+      }
+    deriving (Show)
+
+-- | ServiceConfiguration: 'S3Configuration'
+instance SignQuery DeleteObjects where
+    type ServiceConfiguration DeleteObjects = S3Configuration
+
+    signQuery DeleteObjects {..} = s3SignQuery S3Query
+      {
+        s3QMethod       = Post
+      , s3QBucket       = Just $ T.encodeUtf8 dosBucket
+      , s3QSubresources = HTTP.toQuery [("delete" :: B.ByteString, Nothing :: Maybe B.ByteString)]
+      , s3QQuery        = []
+      , s3QContentType  = Nothing
+      , s3QContentMd5   = Just $ C.hash dosBody
+      , s3QObject       = Nothing
+      , s3QAmzHeaders   = maybeToList $ (("x-amz-mfa", ) . T.encodeUtf8) <$> dosMultiFactorAuthentication
+      , s3QOtherHeaders = []
+      , s3QRequestBody  = Just $ HTTP.RequestBodyLBS dosBody
+      }
+        where dosBody = XML.renderLBS XML.def XML.Document {
+                    XML.documentPrologue = XML.Prologue [] Nothing []
+                  , XML.documentRoot = root
+                  , XML.documentEpilogue = []
+                  }
+              root = XML.Element {
+                    XML.elementName = "Delete"
+                  , XML.elementAttributes = M.empty
+                  , XML.elementNodes = quietNode dosQuiet : (objectNode <$> dosObjects)
+                  }
+              objectNode (obj, mbVersion) = XML.NodeElement XML.Element {
+                    XML.elementName = "Object"
+                  , XML.elementAttributes = M.empty
+                  , XML.elementNodes = keyNode obj : maybeToList (versionNode <$> mbVersion)
+                  }
+              versionNode = toNode "VersionId"
+              keyNode     = toNode "Key"
+              quietNode b = toNode "Quiet" $ if b then "true" else "false"
+              toNode name content = XML.NodeElement XML.Element {
+                    XML.elementName = name
+                  , XML.elementAttributes = M.empty
+                  , XML.elementNodes = [XML.NodeContent content]
+                  }
+
+instance ResponseConsumer DeleteObjects DeleteObjectsResponse where
+    type ResponseMetadata DeleteObjectsResponse = S3Metadata
+
+    responseConsumer _ = s3XmlResponseConsumer parse
+        where parse cursor = do
+                  dorDeleted <- sequence $ cursor $/ Cu.laxElement "Deleted" &| parseDeleted
+                  dorErrors  <- sequence $ cursor $/ Cu.laxElement "Error" &| parseErrors
+                  return DeleteObjectsResponse {..}
+              parseDeleted c = do
+                  ddKey <- force "Missing Key" $ c $/ elContent "Key"
+                  let ddVersionId = listToMaybe $ c $/ elContent "VersionId"
+                      ddDeleteMarkerVersionId = listToMaybe $ c $/ elContent "DeleteMarkerVersionId"
+                  return DORDeleted {..}
+              parseErrors c = do
+                  deKey     <- force "Missing Key" $ c $/ elContent "Key"
+                  deCode    <- force "Missing Code" $ c $/ elContent "Code"
+                  deMessage <- force "Missing Message" $ c $/ elContent "Message"
+                  return DORErrors {..}
+
+instance Transaction DeleteObjects DeleteObjectsResponse
+
+instance AsMemoryResponse DeleteObjectsResponse where
+    type MemoryResponse DeleteObjectsResponse = DeleteObjectsResponse
+    loadToMemory = return
diff --git a/Aws/S3/Commands/GetBucket.hs b/Aws/S3/Commands/GetBucket.hs
--- a/Aws/S3/Commands/GetBucket.hs
+++ b/Aws/S3/Commands/GetBucket.hs
@@ -43,6 +43,7 @@
       , gbrPrefix         :: Maybe T.Text
       , gbrContents       :: [ObjectInfo]
       , gbrCommonPrefixes :: [T.Text]
+      , gbrIsTruncated    :: Bool
       }
     deriving (Show)
 
@@ -76,6 +77,7 @@
                        let delimiter = listToMaybe $ cursor $/ elContent "Delimiter"
                        let marker = listToMaybe $ cursor $/ elContent "Marker"
                        maxKeys <- Data.Traversable.sequence . listToMaybe $ cursor $/ elContent "MaxKeys" &| textReadInt
+                       let truncated = maybe True (/= "false") $ listToMaybe $ cursor $/ elContent "IsTruncated"
                        let prefix = listToMaybe $ cursor $/ elContent "Prefix"
                        contents <- sequence $ cursor $/ Cu.laxElement "Contents" &| parseObjectInfo
                        let commonPrefixes = cursor $/ Cu.laxElement "CommonPrefixes" &// Cu.content
@@ -87,6 +89,7 @@
                                               , gbrPrefix         = prefix
                                               , gbrContents       = contents
                                               , gbrCommonPrefixes = commonPrefixes
+                                              , gbrIsTruncated    = truncated
                                               }
 
 instance Transaction GetBucket GetBucketResponse
diff --git a/Aws/S3/Commands/GetObject.hs b/Aws/S3/Commands/GetObject.hs
--- a/Aws/S3/Commands/GetObject.hs
+++ b/Aws/S3/Commands/GetObject.hs
@@ -9,6 +9,7 @@
 import qualified Data.ByteString.Char8 as B8
 import qualified Data.ByteString.Lazy  as L
 import qualified Data.Conduit          as C
+import           Data.Maybe
 import qualified Data.Text             as T
 import qualified Data.Text.Encoding    as T
 import qualified Network.HTTP.Conduit  as HTTP
@@ -25,11 +26,12 @@
       , goResponseCacheControl :: Maybe T.Text
       , goResponseContentDisposition :: Maybe T.Text
       , goResponseContentEncoding :: Maybe T.Text
+      , goResponseContentRange :: Maybe (Int,Int)
       }
   deriving (Show)
 
 getObject :: Bucket -> T.Text -> GetObject
-getObject b o = GetObject b o Nothing Nothing Nothing Nothing Nothing Nothing Nothing
+getObject b o = GetObject b o Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing
 
 data GetObjectResponse
     = GetObjectResponse {
@@ -50,21 +52,23 @@
                                  , s3QObject = Just $ T.encodeUtf8 goObjectName
                                  , s3QSubresources = HTTP.toQuery [
                                                        ("versionId" :: B8.ByteString,) <$> goVersionId
+                                                     , ("response-content-type" :: B8.ByteString,) <$> goResponseContentType
+                                                     , ("response-content-language",) <$> goResponseContentLanguage
+                                                     , ("response-expires",) <$> goResponseExpires
+                                                     , ("response-cache-control",) <$> goResponseCacheControl
+                                                     , ("response-content-disposition",) <$> goResponseContentDisposition
+                                                     , ("response-content-encoding",) <$> goResponseContentEncoding
                                                      ]
-                                 , s3QQuery = HTTP.toQuery [
-                                                ("response-content-type" :: B8.ByteString,) <$> goResponseContentType
-                                              , ("response-content-language",) <$> goResponseContentLanguage
-                                              , ("response-expires",) <$> goResponseExpires
-                                              , ("response-cache-control",) <$> goResponseCacheControl
-                                              , ("response-content-disposition",) <$> goResponseContentDisposition
-                                              , ("response-content-encoding",) <$> goResponseContentEncoding
-                                              ]
+                                 , s3QQuery = []
                                  , s3QContentType = Nothing
                                  , s3QContentMd5 = Nothing
                                  , s3QAmzHeaders = []
-                                 , s3QOtherHeaders = []
+                                 , s3QOtherHeaders = catMaybes [
+                                                       decodeRange <$> goResponseContentRange
+                                                     ]
                                  , s3QRequestBody = Nothing
                                  }
+      where decodeRange (pos,len) = ("range",B8.concat $ ["bytes=", B8.pack (show pos), "-", B8.pack (show len)])
 
 instance ResponseConsumer GetObject GetObjectResponse where
     type ResponseMetadata GetObjectResponse = S3Metadata
diff --git a/Aws/S3/Commands/HeadObject.hs b/Aws/S3/Commands/HeadObject.hs
new file mode 100644
--- /dev/null
+++ b/Aws/S3/Commands/HeadObject.hs
@@ -0,0 +1,61 @@
+module Aws.S3.Commands.HeadObject
+where
+
+import           Aws.Core
+import           Aws.S3.Core
+import           Control.Applicative
+import           Data.ByteString.Char8 ({- IsString -})
+import qualified Data.ByteString.Char8 as B8
+import qualified Data.Text             as T
+import qualified Data.Text.Encoding    as T
+import qualified Network.HTTP.Conduit  as HTTP
+import qualified Network.HTTP.Types    as HTTP
+
+data HeadObject
+    = HeadObject {
+        hoBucket :: Bucket
+      , hoObjectName :: Object
+      , hoVersionId :: Maybe T.Text
+      }
+  deriving (Show)
+
+headObject :: Bucket -> T.Text -> HeadObject
+headObject b o = HeadObject b o Nothing
+
+data HeadObjectResponse
+    = HeadObjectResponse {
+        horMetadata :: ObjectMetadata
+      }
+
+data HeadObjectMemoryResponse
+    = HeadObjectMemoryResponse ObjectMetadata
+    deriving (Show)
+
+-- | ServiceConfiguration: 'S3Configuration'
+instance SignQuery HeadObject where
+    type ServiceConfiguration HeadObject = S3Configuration
+    signQuery HeadObject {..} = s3SignQuery S3Query {
+                                   s3QMethod = Head
+                                 , s3QBucket = Just $ T.encodeUtf8 hoBucket
+                                 , s3QObject = Just $ T.encodeUtf8 hoObjectName
+                                 , s3QSubresources = HTTP.toQuery [
+                                                       ("versionId" :: B8.ByteString,) <$> hoVersionId
+                                                     ]
+                                 , s3QQuery = []
+                                 , s3QContentType = Nothing
+                                 , s3QContentMd5 = Nothing
+                                 , s3QAmzHeaders = []
+                                 , s3QOtherHeaders = []
+                                 , s3QRequestBody = Nothing
+                                 }
+
+instance ResponseConsumer HeadObject HeadObjectResponse where
+    type ResponseMetadata HeadObjectResponse = S3Metadata
+    responseConsumer HeadObject{..} _ resp
+        = HeadObjectResponse <$> parseObjectMetadata (HTTP.responseHeaders resp)
+
+instance Transaction HeadObject HeadObjectResponse
+
+instance AsMemoryResponse HeadObjectResponse where
+    type MemoryResponse HeadObjectResponse = HeadObjectMemoryResponse
+    loadToMemory (HeadObjectResponse om) = return (HeadObjectMemoryResponse om)
diff --git a/Aws/S3/Commands/PutObject.hs b/Aws/S3/Commands/PutObject.hs
--- a/Aws/S3/Commands/PutObject.hs
+++ b/Aws/S3/Commands/PutObject.hs
@@ -26,14 +26,15 @@
   poExpires :: Maybe Int,
   poAcl :: Maybe CannedAcl,
   poStorageClass :: Maybe StorageClass,
+  poWebsiteRedirectLocation :: Maybe T.Text,
   poRequestBody  :: HTTP.RequestBody (C.ResourceT IO),
   poMetadata :: [(T.Text,T.Text)]
 }
 
 putObject :: Bucket -> T.Text -> HTTP.RequestBody (C.ResourceT IO) -> PutObject
-putObject bucket obj body = PutObject obj bucket Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing body []
+putObject bucket obj body = PutObject obj bucket Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing body []
 
-data PutObjectResponse 
+data PutObjectResponse
   = PutObjectResponse {
       porVersionId :: Maybe T.Text
     }
@@ -52,6 +53,7 @@
                                , s3QAmzHeaders = map (second T.encodeUtf8) $ catMaybes [
                                               ("x-amz-acl",) <$> writeCannedAcl <$> poAcl
                                             , ("x-amz-storage-class",) <$> writeStorageClass <$> poStorageClass
+                                            , ("x-amz-website-redirect-location",) <$> poWebsiteRedirectLocation
                                             ] ++ map( \x -> (CI.mk . T.encodeUtf8 $ T.concat ["x-amz-meta-", fst x], snd x)) poMetadata
                                , s3QOtherHeaders = map (second T.encodeUtf8) $ catMaybes [
                                               ("Expires",) . T.pack . show <$> poExpires
diff --git a/Aws/S3/Core.hs b/Aws/S3/Core.hs
--- a/Aws/S3/Core.hs
+++ b/Aws/S3/Core.hs
@@ -70,6 +70,9 @@
 s3EndpointUsWest :: B.ByteString
 s3EndpointUsWest = "s3-us-west-1.amazonaws.com"
 
+s3EndpointUsWest2 :: B.ByteString
+s3EndpointUsWest2 = "s3-us-west-2.amazonaws.com"
+
 s3EndpointEu :: B.ByteString
 s3EndpointEu = "s3-eu-west-1.amazonaws.com"
 
@@ -403,9 +406,10 @@
 
 type LocationConstraint = T.Text
 
-locationUsClassic, locationUsWest, locationEu, locationApSouthEast, locationApNorthEast :: LocationConstraint
+locationUsClassic, locationUsWest, locationUsWest2, locationEu, locationApSouthEast, locationApNorthEast :: LocationConstraint
 locationUsClassic = ""
 locationUsWest = "us-west-1"
+locationUsWest2 = "us-west-2"
 locationEu = "EU"
 locationApSouthEast = "ap-southeast-1"
 locationApNorthEast = "ap-northeast-1"
diff --git a/Aws/Ses/Commands.hs b/Aws/Ses/Commands.hs
--- a/Aws/Ses/Commands.hs
+++ b/Aws/Ses/Commands.hs
@@ -1,5 +1,27 @@
 module Aws.Ses.Commands
     ( module Aws.Ses.Commands.SendRawEmail
+    , module Aws.Ses.Commands.ListIdentities
+    , module Aws.Ses.Commands.VerifyEmailIdentity
+    , module Aws.Ses.Commands.VerifyDomainIdentity
+    , module Aws.Ses.Commands.VerifyDomainDkim
+    , module Aws.Ses.Commands.DeleteIdentity
+    , module Aws.Ses.Commands.GetIdentityDkimAttributes
+    , module Aws.Ses.Commands.GetIdentityNotificationAttributes
+    , module Aws.Ses.Commands.GetIdentityVerificationAttributes
+    , module Aws.Ses.Commands.SetIdentityNotificationTopic
+    , module Aws.Ses.Commands.SetIdentityDkimEnabled
+    , module Aws.Ses.Commands.SetIdentityFeedbackForwardingEnabled
     ) where
 
 import Aws.Ses.Commands.SendRawEmail
+import Aws.Ses.Commands.ListIdentities
+import Aws.Ses.Commands.VerifyEmailIdentity
+import Aws.Ses.Commands.VerifyDomainIdentity
+import Aws.Ses.Commands.VerifyDomainDkim
+import Aws.Ses.Commands.DeleteIdentity
+import Aws.Ses.Commands.GetIdentityDkimAttributes
+import Aws.Ses.Commands.GetIdentityNotificationAttributes
+import Aws.Ses.Commands.GetIdentityVerificationAttributes
+import Aws.Ses.Commands.SetIdentityNotificationTopic
+import Aws.Ses.Commands.SetIdentityDkimEnabled
+import Aws.Ses.Commands.SetIdentityFeedbackForwardingEnabled
diff --git a/Aws/Ses/Commands/DeleteIdentity.hs b/Aws/Ses/Commands/DeleteIdentity.hs
new file mode 100644
--- /dev/null
+++ b/Aws/Ses/Commands/DeleteIdentity.hs
@@ -0,0 +1,39 @@
+module Aws.Ses.Commands.DeleteIdentity
+    ( DeleteIdentity(..)
+    , DeleteIdentityResponse(..)
+    ) where
+
+import Data.Text (Text)
+import Data.Text.Encoding as T (encodeUtf8)
+import Data.Typeable
+import Aws.Core
+import Aws.Ses.Core
+
+-- | Delete an email address or domain
+data DeleteIdentity  = DeleteIdentity Text
+    deriving (Eq, Ord, Show, Typeable)
+
+-- | ServiceConfiguration: 'SesConfiguration'
+instance SignQuery DeleteIdentity where
+    type ServiceConfiguration DeleteIdentity = SesConfiguration
+    signQuery (DeleteIdentity identity) =
+        sesSignQuery [ ("Action", "DeleteIdentity")
+                     , ("Identity", T.encodeUtf8 identity)
+                     ]
+
+-- | The response sent back by Amazon SES after a
+-- 'DeleteIdentity' command.
+data DeleteIdentityResponse = DeleteIdentityResponse
+    deriving (Eq, Ord, Show, Typeable)
+
+
+instance ResponseConsumer DeleteIdentity DeleteIdentityResponse where
+    type ResponseMetadata DeleteIdentityResponse = SesMetadata
+    responseConsumer _ = sesResponseConsumer $ \_ -> return DeleteIdentityResponse
+
+
+instance Transaction DeleteIdentity DeleteIdentityResponse where
+
+instance AsMemoryResponse DeleteIdentityResponse where
+    type MemoryResponse DeleteIdentityResponse = DeleteIdentityResponse
+    loadToMemory = return
diff --git a/Aws/Ses/Commands/GetIdentityDkimAttributes.hs b/Aws/Ses/Commands/GetIdentityDkimAttributes.hs
new file mode 100644
--- /dev/null
+++ b/Aws/Ses/Commands/GetIdentityDkimAttributes.hs
@@ -0,0 +1,63 @@
+module Aws.Ses.Commands.GetIdentityDkimAttributes
+    ( GetIdentityDkimAttributes(..)
+    , GetIdentityDkimAttributesResponse(..)
+    , IdentityDkimAttributes(..)
+    ) where
+
+import           Control.Applicative   ((<$>))
+import qualified Data.ByteString.Char8 as BS
+import           Data.Text             (Text)
+import           Data.Text             as T (toCaseFold)
+import           Data.Text.Encoding    as T (encodeUtf8)
+import           Data.Typeable
+import           Text.XML.Cursor       (laxElement, ($/), ($//), (&/), (&|))
+
+import           Aws.Core
+import           Aws.Ses.Core
+
+-- | Get notification settings for the given identities.
+data GetIdentityDkimAttributes = GetIdentityDkimAttributes [Text]
+    deriving (Eq, Ord, Show, Typeable)
+
+-- | ServiceConfiguration: 'SesConfiguration'
+instance SignQuery GetIdentityDkimAttributes where
+    type ServiceConfiguration GetIdentityDkimAttributes = SesConfiguration
+    signQuery (GetIdentityDkimAttributes identities) =
+        sesSignQuery $ ("Action", "GetIdentityDkimAttributes")
+                     : zip (enumMember <$> [1..]) (T.encodeUtf8 <$> identities)
+            where enumMember (n :: Int) = BS.append "Identities.member." (BS.pack $ show n)
+
+
+data IdentityDkimAttributes =
+    IdentityDkimAttributes
+      { idIdentity                :: Text
+      , idDkimEnabled             :: Bool
+      , idDkimTokens              :: [Text]
+      , idDkimVerirficationStatus :: Text }
+    deriving (Eq, Ord, Show, Typeable)
+
+-- | The response sent back by Amazon SES after a
+-- 'GetIdentityDkimAttributes' command.
+data GetIdentityDkimAttributesResponse =
+    GetIdentityDkimAttributesResponse [IdentityDkimAttributes]
+    deriving (Eq, Ord, Show, Typeable)
+
+instance ResponseConsumer GetIdentityDkimAttributes GetIdentityDkimAttributesResponse where
+    type ResponseMetadata GetIdentityDkimAttributesResponse = SesMetadata
+    responseConsumer _ = sesResponseConsumer $ \cursor -> do
+        let buildAttr e = do
+              idIdentity <- force "Missing Key" $ e $/ elContent "key"
+              enabled <- force "Missing DkimEnabled" $ e $// elContent "DkimEnabled"
+              idDkimVerirficationStatus <- force "Missing status" $
+                                           e $// elContent "DkimVerificationStatus"
+              let idDkimEnabled = T.toCaseFold enabled == T.toCaseFold "true"
+                  idDkimTokens = e $// laxElement "DkimTokens" &/ elContent "member"
+              return IdentityDkimAttributes{..}
+        attributes <- sequence $ cursor $// laxElement "entry" &| buildAttr
+        return $ GetIdentityDkimAttributesResponse attributes
+
+instance Transaction GetIdentityDkimAttributes GetIdentityDkimAttributesResponse where
+
+instance AsMemoryResponse GetIdentityDkimAttributesResponse where
+    type MemoryResponse GetIdentityDkimAttributesResponse = GetIdentityDkimAttributesResponse
+    loadToMemory = return
diff --git a/Aws/Ses/Commands/GetIdentityNotificationAttributes.hs b/Aws/Ses/Commands/GetIdentityNotificationAttributes.hs
new file mode 100644
--- /dev/null
+++ b/Aws/Ses/Commands/GetIdentityNotificationAttributes.hs
@@ -0,0 +1,64 @@
+module Aws.Ses.Commands.GetIdentityNotificationAttributes
+    ( GetIdentityNotificationAttributes(..)
+    , GetIdentityNotificationAttributesResponse(..)
+    , IdentityNotificationAttributes(..)
+    ) where
+
+import Data.Text (Text)
+import qualified Data.ByteString.Char8 as BS
+import Control.Applicative ((<$>))
+import Data.Text.Encoding as T (encodeUtf8)
+import Data.Text as T (toCaseFold)
+import Data.Typeable
+import Text.XML.Cursor (($//), ($/), (&|), laxElement)
+
+import Aws.Core
+import Aws.Ses.Core
+
+-- | Get notification settings for the given identities.
+data GetIdentityNotificationAttributes = GetIdentityNotificationAttributes [Text]
+    deriving (Eq, Ord, Show, Typeable)
+
+-- | ServiceConfiguration: 'SesConfiguration'
+instance SignQuery GetIdentityNotificationAttributes where
+    type ServiceConfiguration GetIdentityNotificationAttributes = SesConfiguration
+    signQuery (GetIdentityNotificationAttributes identities) =
+        sesSignQuery $ ("Action", "GetIdentityNotificationAttributes")
+                     : zip (enumMember <$> [1..]) (T.encodeUtf8 <$> identities)
+            where enumMember (n :: Int) = BS.append "Identities.member." (BS.pack $ show n)
+
+data IdentityNotificationAttributes = IdentityNotificationAttributes
+    { inIdentity          :: Text
+    , inBounceTopic       :: Maybe Text
+    , inComplaintTopic    :: Maybe Text
+    , inForwardingEnabled :: Bool
+    }
+    deriving (Eq, Ord, Show, Typeable)
+
+-- | The response sent back by Amazon SES after a
+-- 'GetIdentityNotificationAttributes' command.
+data GetIdentityNotificationAttributesResponse =
+    GetIdentityNotificationAttributesResponse [IdentityNotificationAttributes]
+    deriving (Eq, Ord, Show, Typeable)
+
+instance ResponseConsumer GetIdentityNotificationAttributes GetIdentityNotificationAttributesResponse where
+    type ResponseMetadata GetIdentityNotificationAttributesResponse = SesMetadata
+    responseConsumer _ = sesResponseConsumer $ \cursor -> do
+        let buildAttr e = do
+              inIdentity <- force "Missing Key" $ e $/ elContent "key"
+              fwdText <- force "Missing ForwardingEnabled" $ e $// elContent "ForwardingEnabled"
+              let inBounceTopic       = headOrNothing (e $// elContent "BounceTopic")
+                  inComplaintTopic    = headOrNothing (e $// elContent "ComplaintTopic")
+                  inForwardingEnabled = T.toCaseFold fwdText == T.toCaseFold "true"
+              return IdentityNotificationAttributes{..}
+        attributes <- sequence $ cursor $// laxElement "entry" &| buildAttr
+        return $ GetIdentityNotificationAttributesResponse attributes
+      where
+        headOrNothing (x:_) = Just x
+        headOrNothing    _  = Nothing
+
+instance Transaction GetIdentityNotificationAttributes GetIdentityNotificationAttributesResponse where
+
+instance AsMemoryResponse GetIdentityNotificationAttributesResponse where
+    type MemoryResponse GetIdentityNotificationAttributesResponse = GetIdentityNotificationAttributesResponse
+    loadToMemory = return
diff --git a/Aws/Ses/Commands/GetIdentityVerificationAttributes.hs b/Aws/Ses/Commands/GetIdentityVerificationAttributes.hs
new file mode 100644
--- /dev/null
+++ b/Aws/Ses/Commands/GetIdentityVerificationAttributes.hs
@@ -0,0 +1,64 @@
+module Aws.Ses.Commands.GetIdentityVerificationAttributes
+    ( GetIdentityVerificationAttributes(..)
+    , GetIdentityVerificationAttributesResponse(..)
+    , IdentityVerificationAttributes(..)
+    ) where
+
+import Data.Text (Text)
+import qualified Data.ByteString.Char8 as BS
+import Data.Maybe (listToMaybe)
+import Control.Applicative ((<$>))
+import Data.Text.Encoding as T (encodeUtf8)
+import Data.Typeable
+import Text.XML.Cursor (($//), ($/), (&|), laxElement)
+
+import Aws.Core
+import Aws.Ses.Core
+
+-- | Get verification status for a list of email addresses and/or domains
+data GetIdentityVerificationAttributes = GetIdentityVerificationAttributes [Text]
+    deriving (Eq, Ord, Show, Typeable)
+
+
+-- | ServiceConfiguration: 'SesConfiguration'
+instance SignQuery GetIdentityVerificationAttributes where
+    type ServiceConfiguration GetIdentityVerificationAttributes = SesConfiguration
+    signQuery (GetIdentityVerificationAttributes identities) =
+        sesSignQuery $ ("Action", "GetIdentityVerificationAttributes")
+                     : zip (enumMember <$> [1..]) (T.encodeUtf8 <$> identities)
+            where enumMember (n :: Int) = BS.append "Identities.member." (BS.pack $ show n)
+
+data IdentityVerificationAttributes = IdentityVerificationAttributes
+    { ivIdentity :: Text
+    , ivVerificationStatus :: Text
+    , ivVerificationToken :: Maybe Text
+    }
+    deriving (Eq, Ord, Show, Typeable)
+
+
+-- | The response sent back by Amazon SES after a
+-- 'GetIdentityVerificationAttributes' command.
+data GetIdentityVerificationAttributesResponse =
+    GetIdentityVerificationAttributesResponse [IdentityVerificationAttributes]
+    deriving (Eq, Ord, Show, Typeable)
+
+
+instance ResponseConsumer GetIdentityVerificationAttributes GetIdentityVerificationAttributesResponse where
+    type ResponseMetadata GetIdentityVerificationAttributesResponse = SesMetadata
+    responseConsumer _ =
+      sesResponseConsumer $ \cursor -> do
+         let buildAttr e = do
+               ivIdentity <- force "Missing Key" $ e $/ elContent "key"
+               ivVerificationStatus <- force "Missing Verification Status" $ e
+                   $// elContent "VerificationStatus"
+               let ivVerificationToken = listToMaybe $ e $// elContent "VerificationToken"
+               return IdentityVerificationAttributes {..}
+         attributes <- sequence $ cursor $// laxElement "entry" &| buildAttr
+         return $ GetIdentityVerificationAttributesResponse attributes
+
+
+instance Transaction GetIdentityVerificationAttributes GetIdentityVerificationAttributesResponse where
+
+instance AsMemoryResponse GetIdentityVerificationAttributesResponse where
+    type MemoryResponse GetIdentityVerificationAttributesResponse = GetIdentityVerificationAttributesResponse
+    loadToMemory = return
diff --git a/Aws/Ses/Commands/ListIdentities.hs b/Aws/Ses/Commands/ListIdentities.hs
new file mode 100644
--- /dev/null
+++ b/Aws/Ses/Commands/ListIdentities.hs
@@ -0,0 +1,63 @@
+module Aws.Ses.Commands.ListIdentities
+    ( ListIdentities(..)
+    , ListIdentitiesResponse(..)
+    , IdentityType(..)
+    ) where
+
+import Data.Text (Text)
+import  qualified Data.ByteString.Char8 as BS
+import Data.Maybe (catMaybes)
+import Control.Applicative ((<$>))
+import Data.Text.Encoding as T (encodeUtf8)
+import Data.Typeable
+import Text.XML.Cursor (($//), (&/), laxElement)
+
+import Aws.Core
+import Aws.Ses.Core
+
+-- | List email addresses and/or domains
+data ListIdentities =
+    ListIdentities
+      { liIdentityType :: Maybe IdentityType
+      , liMaxItems :: Maybe Int -- valid range is 1..100
+      , liNextToken :: Maybe Text
+      }
+    deriving (Eq, Ord, Show, Typeable)
+
+data IdentityType = EmailAddress | Domain
+    deriving (Eq, Ord, Show, Typeable)
+
+-- | ServiceConfiguration: 'SesConfiguration'
+instance SignQuery ListIdentities where
+    type ServiceConfiguration ListIdentities = SesConfiguration
+    signQuery ListIdentities {..} =
+        let it = case liIdentityType of
+                     Just EmailAddress -> Just "EmailAddress"
+                     Just Domain -> Just "Domain"
+                     Nothing -> Nothing
+        in sesSignQuery $ ("Action", "ListIdentities")
+                          : catMaybes
+                          [ ("IdentityType",) <$> it
+                          , ("MaxItems",) . BS.pack . show <$> liMaxItems
+                          , ("NextToken",) . T.encodeUtf8 <$> liNextToken
+                          ]
+
+-- | The response sent back by Amazon SES after a
+-- 'ListIdentities' command.
+data ListIdentitiesResponse = ListIdentitiesResponse [Text]
+    deriving (Eq, Ord, Show, Typeable)
+
+
+instance ResponseConsumer ListIdentities ListIdentitiesResponse where
+    type ResponseMetadata ListIdentitiesResponse = SesMetadata
+    responseConsumer _ =
+      sesResponseConsumer $ \cursor -> do
+         let ids = cursor $// laxElement "Identities" &/ elContent "member"
+         return $ ListIdentitiesResponse ids
+
+
+instance Transaction ListIdentities ListIdentitiesResponse where
+
+instance AsMemoryResponse ListIdentitiesResponse where
+    type MemoryResponse ListIdentitiesResponse = ListIdentitiesResponse
+    loadToMemory = return
diff --git a/Aws/Ses/Commands/SendRawEmail.hs b/Aws/Ses/Commands/SendRawEmail.hs
--- a/Aws/Ses/Commands/SendRawEmail.hs
+++ b/Aws/Ses/Commands/SendRawEmail.hs
@@ -5,7 +5,10 @@
 
 import Data.Text (Text)
 import Data.Typeable
+import Control.Applicative ((<$>))
+import qualified Data.ByteString.Char8 as BS
 import Text.XML.Cursor (($//))
+import qualified Data.Text.Encoding as T
 
 import Aws.Core
 import Aws.Ses.Core
@@ -13,7 +16,7 @@
 -- | Send a raw e-mail message.
 data SendRawEmail =
     SendRawEmail
-      { srmDestinations :: Maybe Destination
+      { srmDestinations :: [EmailAddress]
       , srmRawMessage   :: RawMessage
       , srmSource       :: Maybe Sender
       }
@@ -24,10 +27,14 @@
     type ServiceConfiguration SendRawEmail = SesConfiguration
     signQuery SendRawEmail {..} =
         sesSignQuery $ ("Action", "SendRawEmail") :
-                       concat [ sesAsQuery srmDestinations
+                       concat [ destinations
                               , sesAsQuery srmRawMessage
                               , sesAsQuery srmSource
                               ]
+      where
+        destinations = zip (enumMember   <$> ([1..] :: [Int]))
+                           (T.encodeUtf8 <$>  srmDestinations)
+        enumMember   = BS.append "Destinations.member." . BS.pack . show
 
 -- | The response sent back by Amazon SES after a
 -- 'SendRawEmail' command.
diff --git a/Aws/Ses/Commands/SetIdentityDkimEnabled.hs b/Aws/Ses/Commands/SetIdentityDkimEnabled.hs
new file mode 100644
--- /dev/null
+++ b/Aws/Ses/Commands/SetIdentityDkimEnabled.hs
@@ -0,0 +1,41 @@
+module Aws.Ses.Commands.SetIdentityDkimEnabled
+    ( SetIdentityDkimEnabled(..)
+    , SetIdentityDkimEnabledResponse(..)
+    ) where
+
+import           Aws.Core
+import           Aws.Ses.Core
+import           Data.Text          (Text)
+import           Data.Text.Encoding as T
+import           Data.Typeable
+
+-- | Change whether bounces and complaints for the given identity will be
+-- DKIM signed.
+data SetIdentityDkimEnabled = SetIdentityDkimEnabled
+      { sdDkimEnabled :: Bool
+      , sdIdentity    :: Text
+      }
+    deriving (Eq, Ord, Show, Typeable)
+
+-- | ServiceConfiguration: 'SesConfiguration'
+instance SignQuery SetIdentityDkimEnabled where
+    type ServiceConfiguration SetIdentityDkimEnabled = SesConfiguration
+    signQuery SetIdentityDkimEnabled{..} =
+        sesSignQuery [ ("Action",   "SetIdentityDkimEnabled")
+                     , ("Identity",  T.encodeUtf8 sdIdentity)
+                     , ("DkimEnabled", awsBool sdDkimEnabled)
+                     ]
+
+-- | The response sent back by SES after the 'SetIdentityDkimEnabled' command.
+data SetIdentityDkimEnabledResponse = SetIdentityDkimEnabledResponse
+    deriving (Eq, Ord, Show, Typeable)
+
+instance ResponseConsumer SetIdentityDkimEnabled SetIdentityDkimEnabledResponse where
+    type ResponseMetadata SetIdentityDkimEnabledResponse = SesMetadata
+    responseConsumer _ = sesResponseConsumer $ \_ -> return SetIdentityDkimEnabledResponse
+
+instance Transaction SetIdentityDkimEnabled SetIdentityDkimEnabledResponse
+
+instance AsMemoryResponse SetIdentityDkimEnabledResponse where
+    type MemoryResponse SetIdentityDkimEnabledResponse = SetIdentityDkimEnabledResponse
+    loadToMemory = return
diff --git a/Aws/Ses/Commands/SetIdentityFeedbackForwardingEnabled.hs b/Aws/Ses/Commands/SetIdentityFeedbackForwardingEnabled.hs
new file mode 100644
--- /dev/null
+++ b/Aws/Ses/Commands/SetIdentityFeedbackForwardingEnabled.hs
@@ -0,0 +1,43 @@
+module Aws.Ses.Commands.SetIdentityFeedbackForwardingEnabled
+    ( SetIdentityFeedbackForwardingEnabled(..)
+    , SetIdentityFeedbackForwardingEnabledResponse(..)
+    ) where
+
+import Data.Text (Text)
+import Data.Text.Encoding as T (encodeUtf8)
+import Data.Typeable
+import Aws.Core
+import Aws.Ses.Core
+
+-- | Change whether bounces and complaints for the given identity will be
+-- forwarded as email.
+data SetIdentityFeedbackForwardingEnabled =
+    SetIdentityFeedbackForwardingEnabled
+      { sffForwardingEnabled :: Bool
+      , sffIdentity          :: Text
+      }
+    deriving (Eq, Ord, Show, Typeable)
+
+-- | ServiceConfiguration: 'SesConfiguration'
+instance SignQuery SetIdentityFeedbackForwardingEnabled where
+    type ServiceConfiguration SetIdentityFeedbackForwardingEnabled = SesConfiguration
+    signQuery SetIdentityFeedbackForwardingEnabled{..} =
+        sesSignQuery [ ("Action",  "SetIdentityFeedbackForwardingEnabled")
+                     , ("Identity",              T.encodeUtf8 sffIdentity)
+                     , ("ForwardingEnabled", awsBool sffForwardingEnabled)
+                     ]
+
+-- | The response sent back by SES after the
+-- 'SetIdentityFeedbackForwardingEnabled' command.
+data SetIdentityFeedbackForwardingEnabledResponse = SetIdentityFeedbackForwardingEnabledResponse
+    deriving (Eq, Ord, Show, Typeable)
+
+instance ResponseConsumer SetIdentityFeedbackForwardingEnabled SetIdentityFeedbackForwardingEnabledResponse where
+    type ResponseMetadata SetIdentityFeedbackForwardingEnabledResponse = SesMetadata
+    responseConsumer _ = sesResponseConsumer $ \_ -> return SetIdentityFeedbackForwardingEnabledResponse 
+
+instance Transaction SetIdentityFeedbackForwardingEnabled SetIdentityFeedbackForwardingEnabledResponse
+
+instance AsMemoryResponse SetIdentityFeedbackForwardingEnabledResponse where
+    type MemoryResponse SetIdentityFeedbackForwardingEnabledResponse = SetIdentityFeedbackForwardingEnabledResponse
+    loadToMemory = return
diff --git a/Aws/Ses/Commands/SetIdentityNotificationTopic.hs b/Aws/Ses/Commands/SetIdentityNotificationTopic.hs
new file mode 100644
--- /dev/null
+++ b/Aws/Ses/Commands/SetIdentityNotificationTopic.hs
@@ -0,0 +1,57 @@
+module Aws.Ses.Commands.SetIdentityNotificationTopic
+    ( SetIdentityNotificationTopic(..)
+    , SetIdentityNotificationTopicResponse(..)
+    , NotificationType(..)
+    ) where
+
+import Data.Text (Text)
+import Control.Applicative ((<$>))
+import Data.Maybe (maybeToList)
+import Data.Text.Encoding as T (encodeUtf8)
+import Data.Typeable
+import Aws.Core
+import Aws.Ses.Core
+
+data NotificationType = Bounce | Complaint
+    deriving (Eq, Ord, Show, Typeable)
+
+-- | Change or remove the Amazon SNS notification topic to which notification
+-- of the given type are published.
+data SetIdentityNotificationTopic =
+    SetIdentityNotificationTopic
+      { sntIdentity         :: Text
+      -- ^ The identity for which the SNS topic will be changed.
+      , sntNotificationType :: NotificationType
+      -- ^ The type of notifications that will be published to the topic.
+      , sntSnsTopic         :: Maybe Text
+      -- ^ @Just@ the ARN of the SNS topic or @Nothing@ to unset the topic.
+      }
+    deriving (Eq, Ord, Show, Typeable)
+
+-- | ServiceConfiguration: 'SesConfiguration'
+instance SignQuery SetIdentityNotificationTopic where
+    type ServiceConfiguration SetIdentityNotificationTopic = SesConfiguration
+    signQuery SetIdentityNotificationTopic{..} =
+        let notificationType = case sntNotificationType of
+                                  Bounce    -> "Bounce"
+                                  Complaint -> "Complaint"
+            snsTopic = ("SnsTopic",) . T.encodeUtf8 <$> sntSnsTopic
+        in sesSignQuery $ [ ("Action", "SetIdentityNotificationTopic")
+                          , ("Identity",     T.encodeUtf8 sntIdentity)
+                          , ("NotificationType",     notificationType)
+                          ] ++ maybeToList snsTopic
+
+-- | The response sent back by SES after the 'SetIdentityNotificationTopic'
+-- command.
+data SetIdentityNotificationTopicResponse = SetIdentityNotificationTopicResponse
+    deriving (Eq, Ord, Show, Typeable)
+
+instance ResponseConsumer SetIdentityNotificationTopic SetIdentityNotificationTopicResponse where
+    type ResponseMetadata SetIdentityNotificationTopicResponse = SesMetadata
+    responseConsumer _ = sesResponseConsumer $ \_ -> return SetIdentityNotificationTopicResponse 
+
+instance Transaction SetIdentityNotificationTopic SetIdentityNotificationTopicResponse
+
+instance AsMemoryResponse SetIdentityNotificationTopicResponse where
+    type MemoryResponse SetIdentityNotificationTopicResponse = SetIdentityNotificationTopicResponse
+    loadToMemory = return
diff --git a/Aws/Ses/Commands/VerifyDomainDkim.hs b/Aws/Ses/Commands/VerifyDomainDkim.hs
new file mode 100644
--- /dev/null
+++ b/Aws/Ses/Commands/VerifyDomainDkim.hs
@@ -0,0 +1,40 @@
+module Aws.Ses.Commands.VerifyDomainDkim
+    ( VerifyDomainDkim(..)
+    , VerifyDomainDkimResponse(..)
+    ) where
+
+import Data.Text (Text)
+import Data.Text.Encoding as T (encodeUtf8)
+import Data.Typeable
+import Aws.Core
+import Aws.Ses.Core
+import Text.XML.Cursor (($//), laxElement, (&/))
+
+-- | Verify ownership of a domain.
+data VerifyDomainDkim  = VerifyDomainDkim Text
+    deriving (Eq, Ord, Show, Typeable)
+
+-- | ServiceConfiguration: 'SesConfiguration'
+instance SignQuery VerifyDomainDkim where
+    type ServiceConfiguration VerifyDomainDkim = SesConfiguration
+    signQuery (VerifyDomainDkim domain) =
+        sesSignQuery [ ("Action", "VerifyDomainDkim")
+                     , ("Domain", T.encodeUtf8 domain)
+                     ]
+
+-- | The response sent back by Amazon SES after a 'VerifyDomainDkim' command.
+data VerifyDomainDkimResponse = VerifyDomainDkimResponse [Text]
+    deriving (Eq, Ord, Show, Typeable)
+
+instance ResponseConsumer VerifyDomainDkim VerifyDomainDkimResponse where
+    type ResponseMetadata VerifyDomainDkimResponse = SesMetadata
+    responseConsumer _ =
+      sesResponseConsumer $ \cursor -> do
+        let tokens = cursor $// laxElement "DkimTokens" &/ elContent "member"
+        return (VerifyDomainDkimResponse tokens)
+
+instance Transaction VerifyDomainDkim VerifyDomainDkimResponse where
+
+instance AsMemoryResponse VerifyDomainDkimResponse where
+    type MemoryResponse VerifyDomainDkimResponse = VerifyDomainDkimResponse
+    loadToMemory = return
diff --git a/Aws/Ses/Commands/VerifyDomainIdentity.hs b/Aws/Ses/Commands/VerifyDomainIdentity.hs
new file mode 100644
--- /dev/null
+++ b/Aws/Ses/Commands/VerifyDomainIdentity.hs
@@ -0,0 +1,41 @@
+module Aws.Ses.Commands.VerifyDomainIdentity
+    ( VerifyDomainIdentity(..)
+    , VerifyDomainIdentityResponse(..)
+    ) where
+
+import Data.Text (Text)
+import Data.Text.Encoding as T (encodeUtf8)
+import Data.Typeable
+import Aws.Core
+import Aws.Ses.Core
+import Text.XML.Cursor (($//))
+
+-- | Verify ownership of a domain.
+data VerifyDomainIdentity  = VerifyDomainIdentity Text
+    deriving (Eq, Ord, Show, Typeable)
+
+-- | ServiceConfiguration: 'SesConfiguration'
+instance SignQuery VerifyDomainIdentity where
+    type ServiceConfiguration VerifyDomainIdentity = SesConfiguration
+    signQuery (VerifyDomainIdentity domain) =
+        sesSignQuery [ ("Action", "VerifyDomainIdentity")
+                     , ("Domain", T.encodeUtf8 domain)
+                     ]
+
+-- | The response sent back by Amazon SES after a
+-- 'VerifyDomainIdentity' command.
+data VerifyDomainIdentityResponse = VerifyDomainIdentityResponse Text
+    deriving (Eq, Ord, Show, Typeable)
+
+instance ResponseConsumer VerifyDomainIdentity VerifyDomainIdentityResponse where
+    type ResponseMetadata VerifyDomainIdentityResponse = SesMetadata
+    responseConsumer _ =
+      sesResponseConsumer $ \cursor -> do
+        token <- force "Verification token not found" $ cursor $// elContent "VerificationToken"
+        return (VerifyDomainIdentityResponse token)
+
+instance Transaction VerifyDomainIdentity VerifyDomainIdentityResponse where
+
+instance AsMemoryResponse VerifyDomainIdentityResponse where
+    type MemoryResponse VerifyDomainIdentityResponse = VerifyDomainIdentityResponse
+    loadToMemory = return
diff --git a/Aws/Ses/Commands/VerifyEmailIdentity.hs b/Aws/Ses/Commands/VerifyEmailIdentity.hs
new file mode 100644
--- /dev/null
+++ b/Aws/Ses/Commands/VerifyEmailIdentity.hs
@@ -0,0 +1,39 @@
+module Aws.Ses.Commands.VerifyEmailIdentity
+    ( VerifyEmailIdentity(..)
+    , VerifyEmailIdentityResponse(..)
+    ) where
+
+import Data.Text (Text)
+import Data.Text.Encoding as T (encodeUtf8)
+import Data.Typeable
+import Aws.Core
+import Aws.Ses.Core
+
+-- | List email addresses and/or domains
+data VerifyEmailIdentity  = VerifyEmailIdentity Text
+    deriving (Eq, Ord, Show, Typeable)
+
+-- | ServiceConfiguration: 'SesConfiguration'
+instance SignQuery VerifyEmailIdentity where
+    type ServiceConfiguration VerifyEmailIdentity = SesConfiguration
+    signQuery (VerifyEmailIdentity address) =
+        sesSignQuery [ ("Action", "VerifyEmailIdentity")
+                     , ("EmailAddress", T.encodeUtf8 address)
+                     ]
+
+-- | The response sent back by Amazon SES after a
+-- 'VerifyEmailIdentity' command.
+data VerifyEmailIdentityResponse = VerifyEmailIdentityResponse
+    deriving (Eq, Ord, Show, Typeable)
+
+
+instance ResponseConsumer VerifyEmailIdentity VerifyEmailIdentityResponse where
+    type ResponseMetadata VerifyEmailIdentityResponse = SesMetadata
+    responseConsumer _ = sesResponseConsumer $ \_ -> return VerifyEmailIdentityResponse
+
+
+instance Transaction VerifyEmailIdentity VerifyEmailIdentityResponse where
+
+instance AsMemoryResponse VerifyEmailIdentityResponse where
+    type MemoryResponse VerifyEmailIdentityResponse = VerifyEmailIdentityResponse
+    loadToMemory = return
diff --git a/Aws/Sqs/Core.hs b/Aws/Sqs/Core.hs
--- a/Aws/Sqs/Core.hs
+++ b/Aws/Sqs/Core.hs
@@ -1,7 +1,7 @@
 module Aws.Sqs.Core where
 
 import           Aws.Core
-import           Aws.S3.Core                    (LocationConstraint, locationUsClassic, locationUsWest, locationApSouthEast, locationApNorthEast, locationEu)
+import           Aws.S3.Core                    (LocationConstraint, locationUsClassic, locationUsWest, locationUsWest2, locationApSouthEast, locationApNorthEast, locationEu)
 import qualified Blaze.ByteString.Builder       as Blaze
 import qualified Blaze.ByteString.Builder.Char8 as Blaze8
 import qualified Control.Exception              as C
@@ -115,6 +115,14 @@
         endpointHost = "us-west-1.queue.amazonaws.com"
       , endpointDefaultLocationConstraint = locationUsWest
       , endpointAllowedLocationConstraints = [locationUsWest]
+      }
+
+sqsEndpointUsWest2 :: Endpoint
+sqsEndpointUsWest2
+    = Endpoint {
+        endpointHost = "us-west-2.queue.amazonaws.com"
+      , endpointDefaultLocationConstraint = locationUsWest2
+      , endpointAllowedLocationConstraints = [locationUsWest2]
       }
 
 sqsEndpointEu :: Endpoint
diff --git a/README.org b/README.org
--- a/README.org
+++ b/README.org
@@ -91,8 +91,25 @@
 
 * Release Notes
 
+** 0.8 series
+
+- 0.8.0
+  - S3, SQS: support for US-West2 (#58)
+  - S3: GetObject now has support for Content-Range (#22, #50)
+  - S3: GetBucket now supports the "IsTruncated" flag (#39)
+  - S3: PutObject now supports web page redirects (#46)
+  - S3: support for (multi-object) DeleteObjects (#47, #56)
+  - S3: HeadObject now uses an actual HEAD request (#53)
+  - S3: fixed signing issues for GetObject call (#54)
+  - SES: support for many more operations (#65, #66, #70, #71, #72, #74)
+  - SES: SendRawEmail now correctly encodes destinations and allows multiple destinations (#73)
+  - EC2: support fo Instance metadata (#37)
+  - Core: queryToHttpRequest allows overriding "Date" for the benefit of Chris Dornan's Elastic Transcoder bindings (#77)
+
 ** 0.7 series
 
+- 0.7.6.4
+  - CryptoHash update
 - 0.7.6.3
   - In addition to supporting http-conduit 1.9, it would seem nice to support conduit 1.0. Previously slipped through the radar.
 
@@ -179,10 +196,11 @@
 
 | Name               | Github       | E-Mail                    | Company                | Components    |
 |--------------------+--------------+---------------------------+------------------------+---------------|
-| Aristid Breitkreuz | [[https://github.com/aristidb][aristidb]]     | aristidb@gmail.com        | -                      | Maintainer    |
+| Aristid Breitkreuz | [[https://github.com/aristidb][aristidb]]     | aristidb@gmail.com        | -                      | Co-Maintainer    |
 | Bas van Dijk       | [[https://github.com/basvandijk][basvandijk]]   | v.dijk.bas@gmail.com      | [[http://erudify.ch][Erudify AG]]             | S3            |
 | David Vollbracht   | [[https://github.com/qxjit][qxjit]]        |                           |                        |               |
 | Felipe Lessa       | [[https://github.com/meteficha][meteficha]]    | felipe.lessa@gmail.com    | currently secret       | Core, S3, SES |
 | Nathan Howell      | [[https://github.com/NathanHowell][NathanHowell]] | nhowell@alphaheavy.com    | [[http://www.alphaheavy.com][Alpha Heavy Industries]] | S3            |
 | Ozgun Ataman       | [[https://github.com/ozataman][ozataman]]     | ozgun.ataman@soostone.com | [[http://soostone.com][Soostone Inc]]           | Core, S3      |
 | Steve Severance    | [[https://github.com/sseveran][sseveran]]     | sseverance@alphaheavy.com | [[http://www.alphaheavy.com][Alpha Heavy Industries]] | S3, SQS       |
+| John Wiegley       | [[https://github.com/jwiegley][jwiegley]]     | johnw@fpcomplete.com      | [[http://fpcomplete.com][FP Complete]]            | Co-Maintainer, S3            |
diff --git a/aws.cabal b/aws.cabal
--- a/aws.cabal
+++ b/aws.cabal
@@ -1,5 +1,5 @@
 Name:                aws
-Version:             0.7.6.4
+Version:             0.8.0
 Synopsis:            Amazon Web Services (AWS) for Haskell
 Description:         Bindings for Amazon Web Services (AWS), with the aim of supporting all AWS services. To see a high level overview of the library, see the README at <https://github.com/aristidb/aws/blob/master/README.org>.
 Homepage:            http://github.com/aristidb/aws
@@ -20,7 +20,7 @@
 Source-repository this
   type: git
   location: https://github.com/aristidb/aws.git
-  tag: 0.7.6.4
+  tag: 0.8.0
 
 Source-repository head
   type: git
@@ -35,13 +35,16 @@
                        Aws,
                        Aws.Aws,
                        Aws.Core,
+                       Aws.Ec2.InstanceMetadata,
                        Aws.S3,
                        Aws.S3.Commands,
                        Aws.S3.Commands.CopyObject,
                        Aws.S3.Commands.DeleteObject,
+                       Aws.S3.Commands.DeleteObjects,
                        Aws.S3.Commands.GetBucket,
                        Aws.S3.Commands.GetObject,
                        Aws.S3.Commands.GetService,
+                       Aws.S3.Commands.HeadObject,
                        Aws.S3.Commands.PutBucket,
                        Aws.S3.Commands.PutObject,
                        Aws.S3.Core,
@@ -61,6 +64,17 @@
                        Aws.Ses,
                        Aws.Ses.Commands,
                        Aws.Ses.Commands.SendRawEmail,
+                       Aws.Ses.Commands.ListIdentities,
+                       Aws.Ses.Commands.VerifyEmailIdentity,
+                       Aws.Ses.Commands.VerifyDomainIdentity,
+                       Aws.Ses.Commands.VerifyDomainDkim,
+                       Aws.Ses.Commands.DeleteIdentity,
+                       Aws.Ses.Commands.GetIdentityDkimAttributes,
+                       Aws.Ses.Commands.GetIdentityNotificationAttributes,
+                       Aws.Ses.Commands.GetIdentityVerificationAttributes,
+                       Aws.Ses.Commands.SetIdentityNotificationTopic,
+                       Aws.Ses.Commands.SetIdentityDkimEnabled,
+                       Aws.Ses.Commands.SetIdentityFeedbackForwardingEnabled,
                        Aws.Ses.Core
 
   Build-depends:
@@ -71,15 +85,15 @@
                        bytestring           >= 0.9     && < 0.11,
                        case-insensitive     >= 0.2     && < 1.1,
                        cereal               == 0.3.*,
-                       conduit              >= 0.5     && < 1.1,
+                       conduit              >= 1.0     && < 1.1,
                        containers           >= 0.4,
                        crypto-api           >= 0.9,
-                       cryptohash           >= 0.6     && < 0.10,
+                       cryptohash           >= 0.8     && < 0.11,
                        cryptohash-cryptoapi == 0.1.*,
                        directory            >= 1.0     && < 1.3,
                        failure              >= 0.2.0.1 && < 0.3,
                        filepath             >= 1.1     && < 1.4,
-                       http-conduit         >= 1.6     && < 1.10,
+                       http-conduit         >= 1.9     && < 1.10,
                        http-types           >= 0.7     && < 0.9,
                        lifted-base          >= 0.1     && < 0.3,
                        monad-control        >= 0.3,
@@ -90,7 +104,7 @@
                        time                 >= 1.1.4   && < 1.5,
                        transformers         >= 0.2.2.0 && < 0.4,
                        utf8-string          == 0.3.*,
-                       xml-conduit          >= 1.0.1 && <1.2
+                       xml-conduit          >= 1.1 && <1.2
 
   GHC-Options: -Wall