-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Core data types and functionality for Amazonka libraries.
--   
--   Core data types, functionality and serialisation primitives for
--   Amazonka related Amazon Web Services SDKs.
--   
--   The external interface of this library is stable with respect to the
--   downstream Amazonka libraries, only, and as such is not suitable for
--   use in non-Amazonka projects.
@package amazonka-core
@version 1.4.5


module Network.AWS.Lens


module Network.AWS.Data.Crypto
digestToBS :: ByteArrayAccess a => a -> ByteString
digestToBase :: ByteArrayAccess a => Base -> a -> ByteString
hmacSHA256 :: (ByteArrayAccess a, ByteArray b) => a -> b -> HMAC SHA256
hashSHA256 :: ByteArrayAccess a => a -> Digest SHA256
hashMD5 :: ByteArrayAccess a => a -> Digest MD5

-- | Hash a strict bytestring into a digest.
hash :: (ByteArrayAccess ba, HashAlgorithm a) => ba -> Digest a

-- | Hash a lazy bytestring into a digest.
hashlazy :: HashAlgorithm a => ByteString -> Digest a

-- | Initialize a new context for this hash algorithm
hashInit :: HashAlgorithm a => Context a

-- | run hashUpdates on one single bytestring and return the updated
--   context.
hashUpdate :: (ByteArrayAccess ba, HashAlgorithm a) => Context a -> ba -> Context a

-- | Finalize a context and return a digest.
hashFinalize :: HashAlgorithm a => Context a -> Digest a

-- | Represent an HMAC that is a phantom type with the hash used to produce
--   the mac.
--   
--   The Eq instance is constant time.
data HMAC a :: * -> *

-- | Represent a digest for a given hash algorithm.
data Digest a :: * -> *

-- | Class representing hashing algorithms.
--   
--   The interface presented here is update in place and lowlevel. the Hash
--   module takes care of hidding the mutable interface properly.
class HashAlgorithm a

-- | SHA256 cryptographic hash algorithm
data SHA256 :: *
SHA256 :: SHA256

-- | MD5 cryptographic hash algorithm
data MD5 :: *
MD5 :: MD5

-- | Different bases that can be used
--   
--   See <a>RFC4648</a> for details. In particular, Base64 can be standard
--   or <a>URL-safe</a>. URL-safe encoding is often used in other
--   specifications without <a>padding</a> characters.
data Base :: *

-- | similar to hexadecimal
Base16 :: Base
Base32 :: Base

-- | standard Base64
Base64 :: Base

-- | unpadded URL-safe Base64
Base64URLUnpadded :: Base

-- | Base64 as used in OpenBSD password encoding (such as bcrypt)
Base64OpenBSD :: Base


module Network.AWS.Data.Text

-- | A space efficient, packed, unboxed Unicode text type.
data Text :: *
class FromText a
parser :: FromText a => Parser a
fromText :: FromText a => Text -> Either String a

-- | Fail parsing with a <a>Text</a> error.
--   
--   Constrained to the actual attoparsec monad to avoid exposing
--   <a>fail</a> usage directly.
fromTextError :: Text -> Parser a
takeLowerText :: Parser Text
takeText :: Parser Text
class ToText a
toText :: ToText a => a -> Text
toTextCI :: ToText a => a -> CI Text
showText :: ToText a => a -> String
instance Network.AWS.Data.Text.FromText Data.Text.Internal.Text
instance Network.AWS.Data.Text.FromText Data.ByteString.Internal.ByteString
instance (Data.CaseInsensitive.Internal.FoldCase a, Network.AWS.Data.Text.FromText a) => Network.AWS.Data.Text.FromText (Data.CaseInsensitive.Internal.CI a)
instance Network.AWS.Data.Text.FromText GHC.Types.Char
instance Network.AWS.Data.Text.FromText GHC.Types.Int
instance Network.AWS.Data.Text.FromText GHC.Integer.Type.Integer
instance Network.AWS.Data.Text.FromText Data.Scientific.Scientific
instance Network.AWS.Data.Text.FromText GHC.Natural.Natural
instance Network.AWS.Data.Text.FromText GHC.Types.Double
instance Network.AWS.Data.Text.FromText GHC.Types.Bool
instance Network.AWS.Data.Text.FromText Network.HTTP.Types.Method.StdMethod
instance Network.AWS.Data.Text.ToText a => Network.AWS.Data.Text.ToText (Data.CaseInsensitive.Internal.CI a)
instance Network.AWS.Data.Text.ToText Data.Text.Internal.Text
instance Network.AWS.Data.Text.ToText Data.ByteString.Internal.ByteString
instance Network.AWS.Data.Text.ToText GHC.Types.Char
instance Network.AWS.Data.Text.ToText GHC.Base.String
instance Network.AWS.Data.Text.ToText GHC.Types.Int
instance Network.AWS.Data.Text.ToText GHC.Int.Int64
instance Network.AWS.Data.Text.ToText GHC.Integer.Type.Integer
instance Network.AWS.Data.Text.ToText GHC.Natural.Natural
instance Network.AWS.Data.Text.ToText Data.Scientific.Scientific
instance Network.AWS.Data.Text.ToText GHC.Types.Double
instance Network.AWS.Data.Text.ToText Network.HTTP.Types.Method.StdMethod
instance Network.AWS.Data.Text.ToText (Crypto.Hash.Types.Digest a)
instance Network.AWS.Data.Text.ToText GHC.Types.Bool


module Network.AWS.Data.JSON

-- | A type that can be converted from JSON, with the possibility of
--   failure.
--   
--   In many cases, you can get the compiler to generate parsing code for
--   you (see below). To begin, let's cover writing an instance by hand.
--   
--   There are various reasons a conversion could fail. For example, an
--   <a>Object</a> could be missing a required key, an <a>Array</a> could
--   be of the wrong size, or a value could be of an incompatible type.
--   
--   The basic ways to signal a failed conversion are as follows:
--   
--   <ul>
--   <li><tt>empty</tt> and <tt>mzero</tt> work, but are terse and
--   uninformative;</li>
--   <li><a>fail</a> yields a custom error message;</li>
--   <li><a>typeMismatch</a> produces an informative message for cases when
--   the value encountered is not of the expected type.</li>
--   </ul>
--   
--   An example type and instance using <a>typeMismatch</a>:
--   
--   <pre>
--   -- Allow ourselves to write <a>Text</a> literals.
--   {-# LANGUAGE OverloadedStrings #-}
--   
--   data Coord = Coord { x :: Double, y :: Double }
--   
--   instance <a>FromJSON</a> Coord where
--       <a>parseJSON</a> (<a>Object</a> v) = Coord
--           <a>&lt;$&gt;</a> v <a>.:</a> "x"
--           <a>&lt;*&gt;</a> v <a>.:</a> "y"
--   
--       -- We do not expect a non-<a>Object</a> value here.
--       -- We could use <tt>mzero</tt> to fail, but <a>typeMismatch</a>
--       -- gives a much more informative error message.
--       <a>parseJSON</a> invalid    = <a>typeMismatch</a> "Coord" invalid
--   </pre>
--   
--   For this common case of only being concerned with a single type of
--   JSON value, the functions <a>withObject</a>, <a>withNumber</a>, etc.
--   are provided. Their use is to be preferred when possible, since they
--   are more terse. Using <a>withObject</a>, we can rewrite the above
--   instance (assuming the same language extension and data type) as:
--   
--   <pre>
--   instance <a>FromJSON</a> Coord where
--       <a>parseJSON</a> = <a>withObject</a> "Coord" $ v -&gt; Coord
--           <a>&lt;$&gt;</a> v <a>.:</a> "x"
--           <a>&lt;*&gt;</a> v <a>.:</a> "y"
--   </pre>
--   
--   Instead of manually writing your <a>FromJSON</a> instance, there are
--   two options to do it automatically:
--   
--   <ul>
--   <li><a>Data.Aeson.TH</a> provides Template Haskell functions which
--   will derive an instance at compile time. The generated instance is
--   optimized for your type so it will probably be more efficient than the
--   following option.</li>
--   <li>The compiler can provide a default generic implementation for
--   <a>parseJSON</a>.</li>
--   </ul>
--   
--   To use the second, simply add a <tt>deriving <a>Generic</a></tt>
--   clause to your datatype and declare a <a>FromJSON</a> instance for
--   your datatype without giving a definition for <a>parseJSON</a>.
--   
--   For example, the previous example can be simplified to just:
--   
--   <pre>
--   {-# LANGUAGE DeriveGeneric #-}
--   
--   import <a>GHC.Generics</a>
--   
--   data Coord = Coord { x :: Double, y :: Double } deriving <a>Generic</a>
--   
--   instance <a>FromJSON</a> Coord
--   </pre>
--   
--   The default implementation will be equivalent to <tt>parseJSON =
--   <a>genericParseJSON</a> <a>defaultOptions</a></tt>; If you need
--   different options, you can customize the generic decoding by defining:
--   
--   <pre>
--   customOptions = <a>defaultOptions</a>
--                   { <a>fieldLabelModifier</a> = <a>map</a> <a>toUpper</a>
--                   }
--   
--   instance <a>FromJSON</a> Coord where
--       <a>parseJSON</a> = <a>genericParseJSON</a> customOptions
--   </pre>
class FromJSON a
parseJSON :: FromJSON a => Value -> Parser a
parseJSONList :: FromJSON a => Value -> Parser [a]
parseJSONText :: FromText a => String -> Value -> Parser a

-- | Like <a>decode</a> but returns an error message when decoding fails.
eitherDecode :: FromJSON a => ByteString -> Either String a

-- | Like <a>decode'</a> but returns an error message when decoding fails.
eitherDecode' :: FromJSON a => ByteString -> Either String a

-- | <tt><a>withObject</a> expected f value</tt> applies <tt>f</tt> to the
--   <a>Object</a> when <tt>value</tt> is an <a>Object</a> and fails using
--   <tt><a>typeMismatch</a> expected</tt> otherwise.
withObject :: String -> (Object -> Parser a) -> Value -> Parser a

-- | Retrieve the value associated with the given key of an <a>Object</a>.
--   The result is <tt>empty</tt> if the key is not present or the value
--   cannot be converted to the desired type.
--   
--   This accessor is appropriate if the key and value <i>must</i> be
--   present in an object for it to be valid. If the key and value are
--   optional, use <a>.:?</a> instead.
(.:) :: FromJSON a => Object -> Text -> Parser a

-- | Retrieve the value associated with the given key of an <a>Object</a>.
--   The result is <a>Nothing</a> if the key is not present or if its value
--   is <a>Null</a>, or <tt>empty</tt> if the value cannot be converted to
--   the desired type.
--   
--   This accessor is most useful if the key and value can be absent from
--   an object without affecting its validity. If the key and value are
--   mandatory, use <a>.:</a> instead.
(.:?) :: FromJSON a => Object -> Text -> Parser (Maybe a)

-- | Helper for use in combination with <a>.:?</a> to provide default
--   values for optional JSON object fields.
--   
--   This combinator is most useful if the key and value can be absent from
--   an object without affecting its validity and we know a default value
--   to assign in that case. If the key and value are mandatory, use
--   <a>.:</a> instead.
--   
--   Example usage:
--   
--   <pre>
--   v1 &lt;- o <a>.:?</a> "opt_field_with_dfl" .!= "default_val"
--   v2 &lt;- o <a>.:</a>  "mandatory_field"
--   v3 &lt;- o <a>.:?</a> "opt_field2"
--   </pre>
(.!=) :: Parser (Maybe a) -> a -> Parser a
eitherParseJSON :: FromJSON a => Object -> Either String a
(.:>) :: FromJSON a => Object -> Text -> Either String a
(.?>) :: FromJSON a => Object -> Text -> Either String (Maybe a)

-- | A type that can be converted to JSON.
--   
--   Instances in general <i>must</i> specify <a>toJSON</a> and
--   <i>should</i> (but don't need to) specify <a>toEncoding</a>.
--   
--   An example type and instance:
--   
--   <pre>
--   -- Allow ourselves to write <a>Text</a> literals.
--   {-# LANGUAGE OverloadedStrings #-}
--   
--   data Coord = Coord { x :: Double, y :: Double }
--   
--   instance <a>ToJSON</a> Coord where
--     <a>toJSON</a> (Coord x y) = <a>object</a> ["x" <a>.=</a> x, "y" <a>.=</a> y]
--   
--     <a>toEncoding</a> (Coord x y) = <tt>pairs</tt> ("x" <a>.=</a> x <a>&lt;&gt;</a> "y" <a>.=</a> y)
--   </pre>
--   
--   Instead of manually writing your <a>ToJSON</a> instance, there are two
--   options to do it automatically:
--   
--   <ul>
--   <li><a>Data.Aeson.TH</a> provides Template Haskell functions which
--   will derive an instance at compile time. The generated instance is
--   optimized for your type so it will probably be more efficient than the
--   following option.</li>
--   <li>The compiler can provide a default generic implementation for
--   <a>toJSON</a>.</li>
--   </ul>
--   
--   To use the second, simply add a <tt>deriving <a>Generic</a></tt>
--   clause to your datatype and declare a <a>ToJSON</a> instance. If you
--   require nothing other than <a>defaultOptions</a>, it is sufficient to
--   write (and this is the only alternative where the default
--   <a>toJSON</a> implementation is sufficient):
--   
--   <pre>
--   {-# LANGUAGE DeriveGeneric #-}
--   
--   import <a>GHC.Generics</a>
--   
--   data Coord = Coord { x :: Double, y :: Double } deriving <a>Generic</a>
--   
--   instance <a>ToJSON</a> Coord where
--       <a>toEncoding</a> = <a>genericToEncoding</a> <a>defaultOptions</a>
--   </pre>
--   
--   If on the other hand you wish to customize the generic decoding, you
--   have to implement both methods:
--   
--   <pre>
--   customOptions = <a>defaultOptions</a>
--                   { <a>fieldLabelModifier</a> = <a>map</a> <a>toUpper</a>
--                   }
--   
--   instance <a>ToJSON</a> Coord where
--       <a>toJSON</a>     = <a>genericToJSON</a> customOptions
--       <a>toEncoding</a> = <a>genericToEncoding</a> customOptions
--   </pre>
--   
--   Previous versions of this library only had the <a>toJSON</a> method.
--   Adding <a>toEncoding</a> had to reasons:
--   
--   <ol>
--   <li>toEncoding is more efficient for the common case that the output
--   of <a>toJSON</a> is directly serialized to a <tt>ByteString</tt>.
--   Further, expressing either method in terms of the other would be
--   non-optimal.</li>
--   <li>The choice of defaults allows a smooth transition for existing
--   users: Existing instances that do not define <a>toEncoding</a> still
--   compile and have the correct semantics. This is ensured by making the
--   default implementation of <a>toEncoding</a> use <a>toJSON</a>. This
--   produces correct results, but since it performs an intermediate
--   conversion to a <a>Value</a>, it will be less efficient than directly
--   emitting an <a>Encoding</a>. (this also means that specifying nothing
--   more than <tt>instance ToJSON Coord</tt> would be sufficient as a
--   generically decoding instance, but there probably exists no good
--   reason to not specify <a>toEncoding</a> in new instances.)</li>
--   </ol>
class ToJSON a

-- | Convert a Haskell value to a JSON-friendly intermediate type.
toJSON :: ToJSON a => a -> Value

-- | Encode a Haskell value as JSON.
--   
--   The default implementation of this method creates an intermediate
--   <a>Value</a> using <a>toJSON</a>. This provides source-level
--   compatibility for people upgrading from older versions of this
--   library, but obviously offers no performance advantage.
--   
--   To benefit from direct encoding, you <i>must</i> provide an
--   implementation for this method. The easiest way to do so is by having
--   your types implement <a>Generic</a> using the <tt>DeriveGeneric</tt>
--   extension, and then have GHC generate a method body as follows.
--   
--   <pre>
--   instance <a>ToJSON</a> Coord where
--       <a>toEncoding</a> = <a>genericToEncoding</a> <a>defaultOptions</a>
--   </pre>
toEncoding :: ToJSON a => a -> Encoding
toJSONList :: ToJSON a => [a] -> Value
toEncodingList :: ToJSON a => [a] -> Encoding
toJSONText :: ToText a => a -> Value

-- | A JSON value represented as a Haskell value.
data Value :: *
Object :: ~Object -> Value

-- | Create a <a>Value</a> from a list of name/value <a>Pair</a>s. If
--   duplicate keys arise, earlier keys and their associated values win.
object :: [Pair] -> Value
(.=) :: KeyValue kv => forall v. ToJSON v => Text -> v -> kv


module Network.AWS.Data.ByteString

-- | A space-efficient representation of a <a>Word8</a> vector, supporting
--   many efficient operations.
--   
--   A <a>ByteString</a> contains 8-bit bytes, or by using the operations
--   from <a>Data.ByteString.Char8</a> it can be interpreted as containing
--   8-bit characters.
data ByteString :: *
type LazyByteString = ByteString
class ToByteString a where toBS = encodeUtf8 . toText
toBS :: ToByteString a => a -> ByteString
toBS :: (ToByteString a, ToText a) => a -> ByteString
showBS :: ToByteString a => a -> String
stripBS :: ByteString -> ByteString
instance Network.AWS.Data.ByteString.ToByteString Data.ByteString.Internal.ByteString
instance Network.AWS.Data.ByteString.ToByteString Data.ByteString.Builder.Internal.Builder
instance Network.AWS.Data.ByteString.ToByteString Network.AWS.Data.ByteString.LazyByteString
instance Network.AWS.Data.ByteString.ToByteString Data.Text.Internal.Text
instance Network.AWS.Data.ByteString.ToByteString GHC.Base.String
instance Network.AWS.Data.ByteString.ToByteString GHC.Types.Int
instance Network.AWS.Data.ByteString.ToByteString GHC.Integer.Type.Integer
instance Network.AWS.Data.ByteString.ToByteString GHC.Natural.Natural
instance Network.AWS.Data.ByteString.ToByteString GHC.Types.Double
instance Network.AWS.Data.ByteString.ToByteString Network.HTTP.Types.Method.StdMethod
instance Network.AWS.Data.ByteString.ToByteString Data.Time.Clock.UTC.UTCTime
instance Network.AWS.Data.ByteString.ToByteString a => Network.AWS.Data.ByteString.ToByteString (Data.CaseInsensitive.Internal.CI a)


module Network.AWS.Data.Headers
(.#) :: FromText a => ResponseHeaders -> HeaderName -> Either String a
infixl 7 .#
(.#?) :: FromText a => ResponseHeaders -> HeaderName -> Either String (Maybe a)
infixl 7 .#?
(=#) :: ToHeader a => HeaderName -> a -> [Header]
infixr 7 =#
hdr :: HeaderName -> ByteString -> [Header] -> [Header]
class ToHeaders a where toHeaders = const mempty
toHeaders :: ToHeaders a => a -> [Header]
class ToHeader a where toHeader k = toHeader k . toText
toHeader :: ToHeader a => HeaderName -> a -> [Header]
toHeader :: (ToHeader a, ToText a) => HeaderName -> a -> [Header]
hHost :: HeaderName
hExpect :: HeaderName
hAMZToken :: HeaderName
hAMZTarget :: HeaderName
hAMZAlgorithm :: HeaderName
hAMZCredential :: HeaderName
hAMZExpires :: HeaderName
hAMZSignedHeaders :: HeaderName
hAMZContentSHA256 :: HeaderName
hAMZDate :: HeaderName
hMetaPrefix :: HeaderName
hAMZRequestId :: HeaderName
hAMZNRequestId :: HeaderName
hAMZNErrorType :: HeaderName
hAMZNAuth :: HeaderName
hAMZDecodedContentLength :: HeaderName
hTransferEncoding :: HeaderName
hFormEncoded :: ByteString

-- | Header name
type HeaderName = CI ByteString

-- | Header
type Header = (HeaderName, ByteString)

-- | HTTP Header names According to
--   <a>http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html</a>
hContentType :: HeaderName
instance Network.AWS.Data.Headers.ToHeader Data.Text.Internal.Text
instance Network.AWS.Data.Headers.ToHeader Data.ByteString.Internal.ByteString
instance Network.AWS.Data.Text.ToText a => Network.AWS.Data.Headers.ToHeader (GHC.Base.Maybe a)


module Network.AWS.Data.Path
type RawPath = Path NoEncoding
type EscapedPath = Path Percent
class ToPath a
toPath :: ToPath a => a -> ByteString
rawPath :: ToPath a => a -> Path NoEncoding
escapePath :: Path a -> EscapedPath
collapsePath :: Path a -> Path a
instance GHC.Show.Show Network.AWS.Data.Path.Encoding
instance GHC.Classes.Eq Network.AWS.Data.Path.Encoding
instance GHC.Show.Show (Network.AWS.Data.Path.Path a)
instance GHC.Classes.Eq (Network.AWS.Data.Path.Path a)
instance Network.AWS.Data.Path.ToPath Data.ByteString.Internal.ByteString
instance Network.AWS.Data.Path.ToPath Data.Text.Internal.Text
instance GHC.Base.Monoid Network.AWS.Data.Path.RawPath
instance Network.AWS.Data.ByteString.ToByteString Network.AWS.Data.Path.EscapedPath


module Network.AWS.Data.Query
data QueryString
QList :: [QueryString] -> QueryString
QPair :: ByteString -> QueryString -> QueryString
QValue :: (Maybe ByteString) -> QueryString
pair :: ToQuery a => ByteString -> a -> QueryString -> QueryString
(=:) :: ToQuery a => ByteString -> a -> QueryString
infixr 7 =:
toQueryList :: (IsList a, ToQuery (Item a)) => ByteString -> a -> QueryString
class ToQuery a where toQuery = toQuery . toText
toQuery :: ToQuery a => a -> QueryString
toQuery :: (ToQuery a, ToText a) => a -> QueryString
instance Data.Data.Data Network.AWS.Data.Query.QueryString
instance GHC.Show.Show Network.AWS.Data.Query.QueryString
instance GHC.Classes.Eq Network.AWS.Data.Query.QueryString
instance GHC.Base.Monoid Network.AWS.Data.Query.QueryString
instance Data.String.IsString Network.AWS.Data.Query.QueryString
instance Network.AWS.Data.ByteString.ToByteString Network.AWS.Data.Query.QueryString
instance Network.AWS.Data.Query.ToQuery Network.AWS.Data.Query.QueryString
instance (Network.AWS.Data.ByteString.ToByteString k, Network.AWS.Data.Query.ToQuery v) => Network.AWS.Data.Query.ToQuery (k, v)
instance Network.AWS.Data.Query.ToQuery GHC.Types.Char
instance Network.AWS.Data.Query.ToQuery Data.ByteString.Internal.ByteString
instance Network.AWS.Data.Query.ToQuery Data.Text.Internal.Text
instance Network.AWS.Data.Query.ToQuery GHC.Types.Int
instance Network.AWS.Data.Query.ToQuery GHC.Integer.Type.Integer
instance Network.AWS.Data.Query.ToQuery GHC.Types.Double
instance Network.AWS.Data.Query.ToQuery GHC.Natural.Natural
instance Network.AWS.Data.Query.ToQuery a => Network.AWS.Data.Query.ToQuery (GHC.Base.Maybe a)
instance Network.AWS.Data.Query.ToQuery GHC.Types.Bool


module Network.AWS.Data.Log
class ToLog a

-- | Convert a value to a loggable builder.
build :: ToLog a => a -> Builder

-- | Intercalate a list of <a>Builder</a>s with newlines.
buildLines :: [Builder] -> Builder
instance Network.AWS.Data.Log.ToLog Data.ByteString.Builder.Internal.Builder
instance Network.AWS.Data.Log.ToLog Data.ByteString.Lazy.Internal.ByteString
instance Network.AWS.Data.Log.ToLog Data.ByteString.Internal.ByteString
instance Network.AWS.Data.Log.ToLog GHC.Types.Int
instance Network.AWS.Data.Log.ToLog GHC.Int.Int8
instance Network.AWS.Data.Log.ToLog GHC.Int.Int16
instance Network.AWS.Data.Log.ToLog GHC.Int.Int32
instance Network.AWS.Data.Log.ToLog GHC.Int.Int64
instance Network.AWS.Data.Log.ToLog GHC.Integer.Type.Integer
instance Network.AWS.Data.Log.ToLog GHC.Types.Word
instance Network.AWS.Data.Log.ToLog GHC.Word.Word8
instance Network.AWS.Data.Log.ToLog GHC.Word.Word16
instance Network.AWS.Data.Log.ToLog GHC.Word.Word32
instance Network.AWS.Data.Log.ToLog GHC.Word.Word64
instance Network.AWS.Data.Log.ToLog Data.Time.Clock.UTC.UTCTime
instance Network.AWS.Data.Log.ToLog GHC.Types.Float
instance Network.AWS.Data.Log.ToLog GHC.Types.Double
instance Network.AWS.Data.Log.ToLog Data.Text.Internal.Text
instance Network.AWS.Data.Log.ToLog Data.Text.Internal.Lazy.Text
instance Network.AWS.Data.Log.ToLog GHC.Types.Char
instance Network.AWS.Data.Log.ToLog [GHC.Types.Char]
instance Network.AWS.Data.Log.ToLog Network.HTTP.Types.Method.StdMethod
instance Network.AWS.Data.Log.ToLog Network.AWS.Data.Query.QueryString
instance Network.AWS.Data.Log.ToLog Network.AWS.Data.Path.EscapedPath
instance Network.AWS.Data.Log.ToLog a => Network.AWS.Data.Log.ToLog (Data.CaseInsensitive.Internal.CI a)
instance Network.AWS.Data.Log.ToLog a => Network.AWS.Data.Log.ToLog (GHC.Base.Maybe a)
instance Network.AWS.Data.Log.ToLog GHC.Types.Bool
instance Network.AWS.Data.Log.ToLog Network.HTTP.Types.Status.Status
instance Network.AWS.Data.Log.ToLog [Network.HTTP.Types.Header.Header]
instance Network.AWS.Data.Log.ToLog Network.HTTP.Types.Version.HttpVersion
instance Network.AWS.Data.Log.ToLog Network.HTTP.Client.Types.RequestBody
instance Network.AWS.Data.Log.ToLog Network.HTTP.Client.Types.HttpException
instance Network.AWS.Data.Log.ToLog Network.HTTP.Client.Types.HttpExceptionContent
instance Network.AWS.Data.Log.ToLog Network.HTTP.Client.Types.Request
instance Network.AWS.Data.Log.ToLog (Network.HTTP.Client.Types.Response a)


module Network.AWS.Data.XML
(.@) :: FromXML a => [Node] -> Text -> Either String a
infixl 7 .@
(.@?) :: FromXML a => [Node] -> Text -> Either String (Maybe a)
infixl 7 .@?
(@=) :: ToXML a => Name -> a -> XML
infixr 7 @=
decodeXML :: FromXML a => LazyByteString -> Either String a
encodeXML :: ToElement a => a -> LazyByteString
class FromXML a
parseXML :: FromXML a => [Node] -> Either String a
class ToElement a
toElement :: ToElement a => a -> Element

-- | Convert to an <a>Element</a>, only if the resulting element contains
--   <tt>&gt; 0</tt> nodes.
maybeElement :: ToElement a => a -> Maybe Element

-- | Provides a way to make the operators for ToXML instance declaration be
--   consistent WRT to single nodes or lists of nodes.
data XML
XNull :: XML
XOne :: Node -> XML
XMany :: [Node] -> XML
listXMLNodes :: XML -> [Node]
class ToXML a
toXML :: ToXML a => a -> XML
toXMLNodes :: ToXML a => a -> [Node]
parseXMLList :: FromXML a => Text -> [Node] -> Either String [a]
parseXMLText :: FromText a => String -> [Node] -> Either String a
toXMLList :: (IsList a, ToXML (Item a)) => Name -> a -> XML
toXMLText :: ToText a => a -> XML
mkElement :: ToXML a => Name -> a -> Element
withContent :: String -> [Node] -> Either String (Maybe Text)
withElement :: Text -> ([Node] -> Either String a) -> [Node] -> Either String a

-- | Find a specific named NodeElement, at the current depth in the node
--   tree.
--   
--   Fails if absent.
findElement :: Text -> [Node] -> Either String [Node]

-- | Find the first specific named NodeElement, at any depth in the node
--   tree.
--   
--   Fails if absent.
firstElement :: Text -> [Node] -> Either String [Node]
childNodesOf :: Text -> Node -> Maybe [Node]
localName :: Node -> Maybe Text

-- | An inefficient mechanism for retreiving the root element name of an
--   XML document.
rootElementName :: LazyByteString -> Maybe Text
missingElement :: Text -> [Node] -> Maybe a -> Either String a
instance GHC.Show.Show Network.AWS.Data.XML.XML
instance Network.AWS.Data.XML.FromXML [Text.XML.Node]
instance Network.AWS.Data.XML.FromXML a => Network.AWS.Data.XML.FromXML (GHC.Base.Maybe a)
instance Network.AWS.Data.XML.FromXML Data.Text.Internal.Text
instance Network.AWS.Data.XML.FromXML GHC.Types.Char
instance Network.AWS.Data.XML.FromXML Data.ByteString.Internal.ByteString
instance Network.AWS.Data.XML.FromXML GHC.Types.Int
instance Network.AWS.Data.XML.FromXML GHC.Integer.Type.Integer
instance Network.AWS.Data.XML.FromXML GHC.Natural.Natural
instance Network.AWS.Data.XML.FromXML GHC.Types.Double
instance Network.AWS.Data.XML.FromXML GHC.Types.Bool
instance Network.AWS.Data.XML.ToElement Text.XML.Element
instance GHC.Base.Monoid Network.AWS.Data.XML.XML
instance Network.AWS.Data.XML.ToXML Network.AWS.Data.XML.XML
instance Network.AWS.Data.XML.ToXML a => Network.AWS.Data.XML.ToXML (GHC.Base.Maybe a)
instance Network.AWS.Data.XML.ToXML Data.Text.Internal.Text
instance Network.AWS.Data.XML.ToXML Data.ByteString.Internal.ByteString
instance Network.AWS.Data.XML.ToXML GHC.Types.Int
instance Network.AWS.Data.XML.ToXML GHC.Integer.Type.Integer
instance Network.AWS.Data.XML.ToXML GHC.Natural.Natural
instance Network.AWS.Data.XML.ToXML GHC.Types.Double
instance Network.AWS.Data.XML.ToXML GHC.Types.Bool


module Network.AWS.Data.List1
newtype List1 a
List1 :: NonEmpty a -> List1 a
[toNonEmpty] :: List1 a -> NonEmpty a
_List1 :: (Coercible a b, Coercible b a) => Iso' (List1 a) (NonEmpty b)
parseXMLList1 :: FromXML a => Text -> [Node] -> Either String (List1 a)
instance GHC.Generics.Generic (Network.AWS.Data.List1.List1 a)
instance Data.Data.Data a => Data.Data.Data (Network.AWS.Data.List1.List1 a)
instance GHC.Show.Show a => GHC.Show.Show (Network.AWS.Data.List1.List1 a)
instance GHC.Read.Read a => GHC.Read.Read (Network.AWS.Data.List1.List1 a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Network.AWS.Data.List1.List1 a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Network.AWS.Data.List1.List1 a)
instance Data.Semigroup.Semigroup (Network.AWS.Data.List1.List1 a)
instance Data.Traversable.Traversable Network.AWS.Data.List1.List1
instance Data.Foldable.Foldable Network.AWS.Data.List1.List1
instance GHC.Base.Applicative Network.AWS.Data.List1.List1
instance GHC.Base.Monad Network.AWS.Data.List1.List1
instance GHC.Base.Functor Network.AWS.Data.List1.List1
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Network.AWS.Data.List1.List1 a)
instance GHC.Exts.IsList (Network.AWS.Data.List1.List1 a)
instance Data.Aeson.Types.FromJSON.FromJSON a => Data.Aeson.Types.FromJSON.FromJSON (Network.AWS.Data.List1.List1 a)
instance Data.Aeson.Types.ToJSON.ToJSON a => Data.Aeson.Types.ToJSON.ToJSON (Network.AWS.Data.List1.List1 a)
instance Data.Hashable.Class.Hashable a => Data.Hashable.Class.Hashable (Network.AWS.Data.List1.List1 a)


module Network.AWS.Data.Map
newtype Map k v
Map :: HashMap k v -> Map k v
[toMap] :: Map k v -> HashMap k v
_Map :: (Coercible a b, Coercible b a) => Iso' (Map k a) (HashMap k b)
parseXMLMap :: (Eq k, Hashable k, FromText k, FromXML v) => Text -> Text -> Text -> [Node] -> Either String (Map k v)
parseHeadersMap :: FromText a => ByteString -> ResponseHeaders -> Either String (Map Text a)
toQueryMap :: (Hashable k, Eq k, ToQuery k, ToQuery v) => ByteString -> ByteString -> ByteString -> Map k v -> QueryString
instance GHC.Generics.Generic (Network.AWS.Data.Map.Map k v)
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k, Data.Data.Data v, Data.Data.Data k) => Data.Data.Data (Network.AWS.Data.Map.Map k v)
instance (GHC.Show.Show v, GHC.Show.Show k) => GHC.Show.Show (Network.AWS.Data.Map.Map k v)
instance (GHC.Read.Read v, GHC.Read.Read k, Data.Hashable.Class.Hashable k, GHC.Classes.Eq k) => GHC.Read.Read (Network.AWS.Data.Map.Map k v)
instance (GHC.Classes.Eq v, GHC.Classes.Eq k) => GHC.Classes.Eq (Network.AWS.Data.Map.Map k v)
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k) => Data.Semigroup.Semigroup (Network.AWS.Data.Map.Map k v)
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k) => GHC.Base.Monoid (Network.AWS.Data.Map.Map k v)
instance Data.Traversable.Traversable (Network.AWS.Data.Map.Map k)
instance Data.Foldable.Foldable (Network.AWS.Data.Map.Map k)
instance GHC.Base.Functor (Network.AWS.Data.Map.Map k)
instance (Data.Hashable.Class.Hashable k, Data.Hashable.Class.Hashable v) => Data.Hashable.Class.Hashable (Network.AWS.Data.Map.Map k v)
instance (Control.DeepSeq.NFData k, Control.DeepSeq.NFData v) => Control.DeepSeq.NFData (Network.AWS.Data.Map.Map k v)
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k) => GHC.Exts.IsList (Network.AWS.Data.Map.Map k v)
instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k, Network.AWS.Data.Text.FromText k, Data.Aeson.Types.FromJSON.FromJSON v) => Data.Aeson.Types.FromJSON.FromJSON (Network.AWS.Data.Map.Map k v)
instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k, Network.AWS.Data.Text.ToText k, Data.Aeson.Types.ToJSON.ToJSON v) => Data.Aeson.Types.ToJSON.ToJSON (Network.AWS.Data.Map.Map k v)
instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k, Network.AWS.Data.ByteString.ToByteString k, Network.AWS.Data.Text.ToText v) => Network.AWS.Data.Headers.ToHeader (Network.AWS.Data.Map.Map k v)


module Network.AWS.Data.Numeric
newtype Nat
Nat :: Natural -> Nat
[unNat] :: Nat -> Natural
_Nat :: Iso' Nat Natural
instance Network.AWS.Data.Query.ToQuery Network.AWS.Data.Numeric.Nat
instance Network.AWS.Data.XML.ToXML Network.AWS.Data.Numeric.Nat
instance Network.AWS.Data.XML.FromXML Network.AWS.Data.Numeric.Nat
instance Network.AWS.Data.Text.ToText Network.AWS.Data.Numeric.Nat
instance Network.AWS.Data.Text.FromText Network.AWS.Data.Numeric.Nat
instance Network.AWS.Data.ByteString.ToByteString Network.AWS.Data.Numeric.Nat
instance GHC.Generics.Generic Network.AWS.Data.Numeric.Nat
instance Data.Data.Data Network.AWS.Data.Numeric.Nat
instance GHC.Real.Integral Network.AWS.Data.Numeric.Nat
instance GHC.Real.Real Network.AWS.Data.Numeric.Nat
instance GHC.Num.Num Network.AWS.Data.Numeric.Nat
instance GHC.Enum.Enum Network.AWS.Data.Numeric.Nat
instance GHC.Show.Show Network.AWS.Data.Numeric.Nat
instance GHC.Read.Read Network.AWS.Data.Numeric.Nat
instance GHC.Classes.Ord Network.AWS.Data.Numeric.Nat
instance GHC.Classes.Eq Network.AWS.Data.Numeric.Nat
instance Data.Hashable.Class.Hashable Network.AWS.Data.Numeric.Nat
instance Control.DeepSeq.NFData Network.AWS.Data.Numeric.Nat
instance Data.Aeson.Types.FromJSON.FromJSON Network.AWS.Data.Numeric.Nat
instance Data.Aeson.Types.ToJSON.ToJSON Network.AWS.Data.Numeric.Nat


module Network.AWS.Data.Sensitive

-- | <i>Note</i>: read . show /= isomorphic
newtype Sensitive a
Sensitive :: a -> Sensitive a
[desensitise] :: Sensitive a -> a
_Sensitive :: Iso' (Sensitive a) a
instance Data.Aeson.Types.FromJSON.FromJSON a => Data.Aeson.Types.FromJSON.FromJSON (Network.AWS.Data.Sensitive.Sensitive a)
instance Data.Aeson.Types.ToJSON.ToJSON a => Data.Aeson.Types.ToJSON.ToJSON (Network.AWS.Data.Sensitive.Sensitive a)
instance Network.AWS.Data.Query.ToQuery a => Network.AWS.Data.Query.ToQuery (Network.AWS.Data.Sensitive.Sensitive a)
instance Network.AWS.Data.XML.ToXML a => Network.AWS.Data.XML.ToXML (Network.AWS.Data.Sensitive.Sensitive a)
instance Network.AWS.Data.XML.FromXML a => Network.AWS.Data.XML.FromXML (Network.AWS.Data.Sensitive.Sensitive a)
instance Network.AWS.Data.Text.ToText a => Network.AWS.Data.Text.ToText (Network.AWS.Data.Sensitive.Sensitive a)
instance Network.AWS.Data.Text.FromText a => Network.AWS.Data.Text.FromText (Network.AWS.Data.Sensitive.Sensitive a)
instance Network.AWS.Data.ByteString.ToByteString a => Network.AWS.Data.ByteString.ToByteString (Network.AWS.Data.Sensitive.Sensitive a)
instance GHC.Generics.Generic (Network.AWS.Data.Sensitive.Sensitive a)
instance Data.Data.Data a => Data.Data.Data (Network.AWS.Data.Sensitive.Sensitive a)
instance GHC.Base.Monoid a => GHC.Base.Monoid (Network.AWS.Data.Sensitive.Sensitive a)
instance Data.String.IsString a => Data.String.IsString (Network.AWS.Data.Sensitive.Sensitive a)
instance GHC.Read.Read a => GHC.Read.Read (Network.AWS.Data.Sensitive.Sensitive a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Network.AWS.Data.Sensitive.Sensitive a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Network.AWS.Data.Sensitive.Sensitive a)
instance GHC.Show.Show (Network.AWS.Data.Sensitive.Sensitive a)
instance Data.Hashable.Class.Hashable a => Data.Hashable.Class.Hashable (Network.AWS.Data.Sensitive.Sensitive a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Network.AWS.Data.Sensitive.Sensitive a)


module Network.AWS.Data.Body

-- | A streaming, exception safe response body.
newtype RsBody
RsBody :: ResumableSource (ResourceT IO) ByteString -> RsBody
[_streamBody] :: RsBody -> ResumableSource (ResourceT IO) ByteString
fuseStream :: RsBody -> Conduit ByteString (ResourceT IO) ByteString -> RsBody

-- | Specifies the transmitted size of the 'Transfer-Encoding' chunks.
--   
--   <i>See:</i> <tt>defaultChunk</tt>.
newtype ChunkSize
ChunkSize :: Int -> ChunkSize

-- | The default chunk size of 128 KB. The minimum chunk size accepted by
--   AWS is 8 KB, unless the entirety of the request is below this
--   threshold.
--   
--   A chunk size of 64 KB or higher is recommended for performance
--   reasons.
defaultChunkSize :: ChunkSize

-- | An opaque request body which will be transmitted via
--   <tt>Transfer-Encoding: chunked</tt>.
--   
--   <i>Invariant:</i> Only services that support chunked encoding can
--   accept a <a>ChunkedBody</a>. (Currently S3.) This is enforced by the
--   type signatures emitted by the generator.
data ChunkedBody
ChunkedBody :: !ChunkSize -> !Integer -> Source (ResourceT IO) ByteString -> ChunkedBody
[_chunkedSize] :: ChunkedBody -> !ChunkSize
[_chunkedLength] :: ChunkedBody -> !Integer
[_chunkedBody] :: ChunkedBody -> Source (ResourceT IO) ByteString
chunkedLength :: Lens' ChunkedBody Integer
fuseChunks :: ChunkedBody -> Conduit ByteString (ResourceT IO) ByteString -> ChunkedBody
fullChunks :: ChunkedBody -> Integer
remainderBytes :: ChunkedBody -> Maybe Integer

-- | An opaque request body containing a <a>SHA256</a> hash.
data HashedBody
HashedStream :: (Digest SHA256) -> !Integer -> (Source (ResourceT IO) ByteString) -> HashedBody
HashedBytes :: (Digest SHA256) -> ByteString -> HashedBody
sha256Base16 :: HashedBody -> ByteString

-- | Invariant: only services that support _both_ standard and chunked
--   signing expose <a>RqBody</a> as a parameter.
data RqBody
Chunked :: ChunkedBody -> RqBody
Hashed :: HashedBody -> RqBody
md5Base64 :: RqBody -> Maybe ByteString
isStreaming :: RqBody -> Bool
toRequestBody :: RqBody -> RequestBody
contentLength :: RqBody -> Integer

-- | Anything that can be safely converted to a <a>HashedBody</a>.
class ToHashedBody a

-- | Convert a value to a hashed request body.
toHashed :: ToHashedBody a => a -> HashedBody

-- | Anything that can be converted to a streaming request <tt>Body</tt>.
class ToBody a where toBody = Hashed . toHashed

-- | Convert a value to a request body.
toBody :: ToBody a => a -> RqBody

-- | Convert a value to a request body.
toBody :: (ToBody a, ToHashedBody a) => a -> RqBody
_Body :: ToBody a => AReview RqBody a
instance GHC.Show.Show Network.AWS.Data.Body.RqBody
instance GHC.Real.Integral Network.AWS.Data.Body.ChunkSize
instance GHC.Real.Real Network.AWS.Data.Body.ChunkSize
instance GHC.Num.Num Network.AWS.Data.Body.ChunkSize
instance GHC.Enum.Enum Network.AWS.Data.Body.ChunkSize
instance GHC.Show.Show Network.AWS.Data.Body.ChunkSize
instance GHC.Classes.Ord Network.AWS.Data.Body.ChunkSize
instance GHC.Classes.Eq Network.AWS.Data.Body.ChunkSize
instance GHC.Show.Show Network.AWS.Data.Body.RsBody
instance Network.AWS.Data.Log.ToLog Network.AWS.Data.Body.ChunkSize
instance GHC.Show.Show Network.AWS.Data.Body.ChunkedBody
instance GHC.Show.Show Network.AWS.Data.Body.HashedBody
instance Data.String.IsString Network.AWS.Data.Body.HashedBody
instance Data.String.IsString Network.AWS.Data.Body.RqBody
instance Network.AWS.Data.Body.ToHashedBody Data.ByteString.Internal.ByteString
instance Network.AWS.Data.Body.ToHashedBody Network.AWS.Data.Body.HashedBody
instance Network.AWS.Data.Body.ToHashedBody GHC.Base.String
instance Network.AWS.Data.Body.ToHashedBody Data.ByteString.Lazy.Internal.ByteString
instance Network.AWS.Data.Body.ToHashedBody Data.Text.Internal.Text
instance Network.AWS.Data.Body.ToHashedBody Data.Text.Internal.Lazy.Text
instance Network.AWS.Data.Body.ToHashedBody Data.Aeson.Types.Internal.Value
instance Network.AWS.Data.Body.ToHashedBody Text.XML.Element
instance Network.AWS.Data.Body.ToHashedBody Network.AWS.Data.Query.QueryString
instance Network.AWS.Data.Body.ToHashedBody (Data.HashMap.Base.HashMap Data.Text.Internal.Text Data.Aeson.Types.Internal.Value)
instance Network.AWS.Data.Body.ToBody Network.AWS.Data.Body.RqBody
instance Network.AWS.Data.Body.ToBody Network.AWS.Data.Body.HashedBody
instance Network.AWS.Data.Body.ToBody Network.AWS.Data.Body.ChunkedBody
instance Network.AWS.Data.Body.ToHashedBody a => Network.AWS.Data.Body.ToBody (GHC.Base.Maybe a)
instance Network.AWS.Data.Body.ToBody GHC.Base.String
instance Network.AWS.Data.Body.ToBody Data.ByteString.Lazy.Internal.ByteString
instance Network.AWS.Data.Body.ToBody Data.ByteString.Internal.ByteString
instance Network.AWS.Data.Body.ToBody Data.Text.Internal.Text
instance Network.AWS.Data.Body.ToBody Data.Text.Internal.Lazy.Text
instance Network.AWS.Data.Body.ToBody (Data.HashMap.Base.HashMap Data.Text.Internal.Text Data.Aeson.Types.Internal.Value)
instance Network.AWS.Data.Body.ToBody Data.Aeson.Types.Internal.Value
instance Network.AWS.Data.Body.ToBody Text.XML.Element
instance Network.AWS.Data.Body.ToBody Network.AWS.Data.Query.QueryString


module Network.AWS.Types

-- | Access key credential.
newtype AccessKey
AccessKey :: ByteString -> AccessKey

-- | Secret key credential.
newtype SecretKey
SecretKey :: ByteString -> SecretKey

-- | A session token used by STS to temporarily authorise access to an AWS
--   resource.
newtype SessionToken
SessionToken :: ByteString -> SessionToken

-- | The authorisation environment.
data AuthEnv
AuthEnv :: !AccessKey -> !SecretKey -> Maybe SessionToken -> Maybe UTCTime -> AuthEnv
[_authAccess] :: AuthEnv -> !AccessKey
[_authSecret] :: AuthEnv -> !SecretKey
[_authToken] :: AuthEnv -> Maybe SessionToken
[_authExpiry] :: AuthEnv -> Maybe UTCTime

-- | An authorisation environment containing AWS credentials, and
--   potentially a reference which can be refreshed out-of-band as
--   temporary credentials expire.
data Auth
Ref :: ThreadId -> (IORef AuthEnv) -> Auth
Auth :: AuthEnv -> Auth
withAuth :: MonadIO m => Auth -> (AuthEnv -> m a) -> m a
data LogLevel

-- | Info messages supplied by the user - this level is not emitted by the
--   library.
Info :: LogLevel

-- | Error messages only.
Error :: LogLevel

-- | Useful debug information + info + error levels.
Debug :: LogLevel

-- | Includes potentially sensitive signing metadata, and non-streaming
--   response bodies.
Trace :: LogLevel

-- | A function threaded through various request and serialisation routines
--   to log informational and debug messages.
type Logger = LogLevel -> Builder -> IO ()
type Algorithm a = Request a -> AuthEnv -> Region -> UTCTime -> Signed a

-- | Signing algorithm specific metadata.
data Meta
[Meta] :: ToLog a => a -> Meta
data Signer
Signer :: (forall a. Algorithm a) -> (forall a. Seconds -> Algorithm a) -> Signer
[sgSign] :: Signer -> forall a. Algorithm a
[sgPresign] :: Signer -> forall a. Seconds -> Algorithm a

-- | A signed <a>ClientRequest</a> and associated metadata specific to the
--   signing algorithm, tagged with the initial request type to be able to
--   obtain the associated response, 'Rs a'.
data Signed a
Signed :: !Meta -> !ClientRequest -> Signed a
[sgMeta] :: Signed a -> !Meta
[sgRequest] :: Signed a -> !ClientRequest

-- | Abbreviated service name.
data Abbrev

-- | Attributes and functions specific to an AWS service.
data Service
Service :: !Abbrev -> !Signer -> !ByteString -> !ByteString -> !(Region -> Endpoint) -> !(Maybe Seconds) -> !(Status -> Bool) -> !(Status -> [Header] -> LazyByteString -> Error) -> !Retry -> Service
[_svcAbbrev] :: Service -> !Abbrev
[_svcSigner] :: Service -> !Signer
[_svcPrefix] :: Service -> !ByteString
[_svcVersion] :: Service -> !ByteString
[_svcEndpoint] :: Service -> !(Region -> Endpoint)
[_svcTimeout] :: Service -> !(Maybe Seconds)
[_svcCheck] :: Service -> !(Status -> Bool)
[_svcError] :: Service -> !(Status -> [Header] -> LazyByteString -> Error)
[_svcRetry] :: Service -> !Retry
serviceSigner :: Lens' Service Signer
serviceEndpoint :: Setter' Service Endpoint
serviceTimeout :: Lens' Service (Maybe Seconds)
serviceCheck :: Lens' Service (Status -> Bool)
serviceRetry :: Lens' Service Retry

-- | Specify how a request can be de/serialised.
class AWSRequest a where type Rs a :: * where {
    type family Rs a :: *;
}
request :: AWSRequest a => a -> Request a
response :: (AWSRequest a, MonadResource m) => Logger -> Service -> Proxy a -> ClientResponse -> m (Response a)

-- | An unsigned request.
data Request a
Request :: !Service -> !StdMethod -> !RawPath -> !QueryString -> ![Header] -> !RqBody -> Request a
[_rqService] :: Request a -> !Service
[_rqMethod] :: Request a -> !StdMethod
[_rqPath] :: Request a -> !RawPath
[_rqQuery] :: Request a -> !QueryString
[_rqHeaders] :: Request a -> ![Header]
[_rqBody] :: Request a -> !RqBody
rqService :: Lens' (Request a) Service
rqMethod :: Lens' (Request a) StdMethod
rqHeaders :: Lens' (Request a) [Header]
rqPath :: Lens' (Request a) RawPath
rqQuery :: Lens' (Request a) QueryString
rqBody :: Lens' (Request a) RqBody
rqSign :: Algorithm a
rqPresign :: Seconds -> Algorithm a
type Response a = (Status, Rs a)

-- | Constants and predicates used to create a <tt>RetryPolicy</tt>.
data Retry
Exponential :: !Double -> !Int -> !Int -> (ServiceError -> Maybe Text) -> Retry
[_retryBase] :: Retry -> !Double
[_retryGrowth] :: Retry -> !Int
[_retryAttempts] :: Retry -> !Int

-- | Returns a descriptive name for logging if the request should be
--   retried.
[_retryCheck] :: Retry -> ServiceError -> Maybe Text
exponentBase :: Lens' Retry Double
exponentGrowth :: Lens' Retry Int
retryAttempts :: Lens' Retry Int
retryCheck :: Lens' Retry (ServiceError -> Maybe Text)
class AsError a where _TransportError = _Error . _TransportError _SerializeError = _Error . _SerializeError _ServiceError = _Error . _ServiceError

-- | A general Amazonka error.
_Error :: AsError a => Prism' a Error

-- | An error occured while communicating over HTTP with a remote service.
_TransportError :: AsError a => Prism' a HttpException

-- | A serialisation error occured when attempting to deserialise a
--   response.
_SerializeError :: AsError a => Prism' a SerializeError

-- | A service specific error returned by the remote service.
_ServiceError :: AsError a => Prism' a ServiceError

-- | An error type representing errors that can be attributed to this
--   library.
data Error
TransportError :: HttpException -> Error
SerializeError :: SerializeError -> Error
ServiceError :: ServiceError -> Error

-- | An exception which may be generated by this library
data HttpException :: *
data SerializeError
SerializeError' :: !Abbrev -> !Status -> Maybe LazyByteString -> String -> SerializeError
[_serializeAbbrev] :: SerializeError -> !Abbrev
[_serializeStatus] :: SerializeError -> !Status

-- | The response body, if the response was not streaming.
[_serializeBody] :: SerializeError -> Maybe LazyByteString
[_serializeMessage] :: SerializeError -> String
serializeAbbrev :: Lens' SerializeError Abbrev
serializeStatus :: Lens' SerializeError Status
serializeMessage :: Lens' SerializeError String
data ServiceError
ServiceError' :: !Abbrev -> !Status -> [Header] -> !ErrorCode -> Maybe ErrorMessage -> Maybe RequestId -> ServiceError
[_serviceAbbrev] :: ServiceError -> !Abbrev
[_serviceStatus] :: ServiceError -> !Status
[_serviceHeaders] :: ServiceError -> [Header]
[_serviceCode] :: ServiceError -> !ErrorCode
[_serviceMessage] :: ServiceError -> Maybe ErrorMessage
[_serviceRequestId] :: ServiceError -> Maybe RequestId
serviceAbbrev :: Lens' ServiceError Abbrev
serviceStatus :: Lens' ServiceError Status
serviceHeaders :: Lens' ServiceError [Header]
serviceCode :: Lens' ServiceError ErrorCode
serviceMessage :: Lens' ServiceError (Maybe ErrorMessage)
serviceRequestId :: Lens' ServiceError (Maybe RequestId)
newtype ErrorCode
ErrorCode :: Text -> ErrorCode

-- | Construct an <a>ErrorCode</a>.
errorCode :: Text -> ErrorCode
newtype ErrorMessage
ErrorMessage :: Text -> ErrorMessage
newtype RequestId
RequestId :: Text -> RequestId

-- | The available AWS regions.
data Region

-- | US East ('us-east-1').
NorthVirginia :: Region

-- | US East ('us-east-2').
Ohio :: Region

-- | US West ('us-west-1').
NorthCalifornia :: Region

-- | US West ('us-west-2').
Oregon :: Region

-- | Asia Pacific ('ap-northeast-1').
Tokyo :: Region

-- | Asia Pacific ('ap-northeast-2').
Seoul :: Region

-- | Asia Pacific ('ap-south-1').
Mumbai :: Region

-- | Asia Pacific ('ap-southeast-1').
Singapore :: Region

-- | Asia Pacific ('ap-southeast-2').
Sydney :: Region

-- | South America ('sa-east-1').
SaoPaulo :: Region

-- | EU ('eu-west-1').
Ireland :: Region

-- | EU ('eu-central-1').
Frankfurt :: Region

-- | US GovCloud ('us-gov-west-1').
GovCloud :: Region

-- | US GovCloud FIPS (S3 Only, 'fips-us-gov-west-1').
GovCloudFIPS :: Region

-- | China ('cn-north-1').
Beijing :: Region
data Endpoint
Endpoint :: ByteString -> !Bool -> !Int -> ByteString -> Endpoint
[_endpointHost] :: Endpoint -> ByteString
[_endpointSecure] :: Endpoint -> !Bool
[_endpointPort] :: Endpoint -> !Int
[_endpointScope] :: Endpoint -> ByteString
endpointHost :: Lens' Endpoint ByteString
endpointPort :: Lens' Endpoint Int
endpointSecure :: Lens' Endpoint Bool
endpointScope :: Lens' Endpoint ByteString

-- | A convenience alias to avoid type ambiguity.
type ClientRequest = Request

-- | A convenience alias encapsulating the common <a>Response</a>.
type ClientResponse = Response ResponseBody

-- | A convenience alias encapsulating the common <a>Response</a> body.
type ResponseBody = ResumableSource (ResourceT IO) ByteString

-- | Construct a <a>ClientRequest</a> using common parameters such as TLS
--   and prevent throwing errors when receiving erroneous status codes in
--   respones.
clientRequest :: Endpoint -> Maybe Seconds -> ClientRequest

-- | An integral value representing seconds.
newtype Seconds
Seconds :: Int -> Seconds
seconds :: Seconds -> Int
microseconds :: Seconds -> Int
_Coerce :: (Coercible a b, Coercible b a) => Iso' a b

-- | Invalid Iso, should be a Prism but exists for ease of composition with
--   the current 'Lens . Iso' chaining to hide internal types from the
--   user.
_Default :: Monoid a => Iso' (Maybe a) a
instance Network.AWS.Data.Text.ToText Network.AWS.Types.Seconds
instance Network.AWS.Data.ByteString.ToByteString Network.AWS.Types.Seconds
instance Network.AWS.Data.Query.ToQuery Network.AWS.Types.Seconds
instance GHC.Generics.Generic Network.AWS.Types.Seconds
instance Data.Data.Data Network.AWS.Types.Seconds
instance GHC.Real.Real Network.AWS.Types.Seconds
instance GHC.Real.Integral Network.AWS.Types.Seconds
instance GHC.Enum.Bounded Network.AWS.Types.Seconds
instance GHC.Num.Num Network.AWS.Types.Seconds
instance GHC.Enum.Enum Network.AWS.Types.Seconds
instance GHC.Show.Show Network.AWS.Types.Seconds
instance GHC.Read.Read Network.AWS.Types.Seconds
instance GHC.Classes.Ord Network.AWS.Types.Seconds
instance GHC.Classes.Eq Network.AWS.Types.Seconds
instance GHC.Generics.Generic Network.AWS.Types.Region
instance Data.Data.Data Network.AWS.Types.Region
instance GHC.Show.Show Network.AWS.Types.Region
instance GHC.Read.Read Network.AWS.Types.Region
instance GHC.Classes.Ord Network.AWS.Types.Region
instance GHC.Classes.Eq Network.AWS.Types.Region
instance Network.AWS.Data.ByteString.ToByteString Network.AWS.Types.SessionToken
instance Network.AWS.Data.Text.ToText Network.AWS.Types.SessionToken
instance Data.String.IsString Network.AWS.Types.SessionToken
instance GHC.Classes.Eq Network.AWS.Types.SessionToken
instance Network.AWS.Data.ByteString.ToByteString Network.AWS.Types.SecretKey
instance Network.AWS.Data.Text.ToText Network.AWS.Types.SecretKey
instance Data.String.IsString Network.AWS.Types.SecretKey
instance GHC.Classes.Eq Network.AWS.Types.SecretKey
instance Network.AWS.Data.Log.ToLog Network.AWS.Types.AccessKey
instance Network.AWS.Data.ByteString.ToByteString Network.AWS.Types.AccessKey
instance Network.AWS.Data.Text.ToText Network.AWS.Types.AccessKey
instance Data.String.IsString Network.AWS.Types.AccessKey
instance GHC.Show.Show Network.AWS.Types.AccessKey
instance GHC.Classes.Eq Network.AWS.Types.AccessKey
instance Data.Data.Data Network.AWS.Types.LogLevel
instance GHC.Show.Show Network.AWS.Types.LogLevel
instance GHC.Enum.Enum Network.AWS.Types.LogLevel
instance GHC.Classes.Ord Network.AWS.Types.LogLevel
instance GHC.Classes.Eq Network.AWS.Types.LogLevel
instance Data.Data.Data Network.AWS.Types.Endpoint
instance GHC.Show.Show Network.AWS.Types.Endpoint
instance GHC.Classes.Eq Network.AWS.Types.Endpoint
instance GHC.Show.Show Network.AWS.Types.Error
instance GHC.Show.Show Network.AWS.Types.ServiceError
instance GHC.Classes.Eq Network.AWS.Types.ServiceError
instance GHC.Show.Show Network.AWS.Types.SerializeError
instance GHC.Classes.Eq Network.AWS.Types.SerializeError
instance Network.AWS.Data.Log.ToLog Network.AWS.Types.RequestId
instance Network.AWS.Data.Text.ToText Network.AWS.Types.RequestId
instance Network.AWS.Data.Text.FromText Network.AWS.Types.RequestId
instance Data.Aeson.Types.FromJSON.FromJSON Network.AWS.Types.RequestId
instance Network.AWS.Data.XML.FromXML Network.AWS.Types.RequestId
instance Data.String.IsString Network.AWS.Types.RequestId
instance GHC.Show.Show Network.AWS.Types.RequestId
instance GHC.Classes.Ord Network.AWS.Types.RequestId
instance GHC.Classes.Eq Network.AWS.Types.RequestId
instance Network.AWS.Data.Log.ToLog Network.AWS.Types.ErrorMessage
instance Network.AWS.Data.Text.ToText Network.AWS.Types.ErrorMessage
instance Network.AWS.Data.Text.FromText Network.AWS.Types.ErrorMessage
instance Data.Aeson.Types.FromJSON.FromJSON Network.AWS.Types.ErrorMessage
instance Network.AWS.Data.XML.FromXML Network.AWS.Types.ErrorMessage
instance Data.String.IsString Network.AWS.Types.ErrorMessage
instance GHC.Show.Show Network.AWS.Types.ErrorMessage
instance GHC.Classes.Ord Network.AWS.Types.ErrorMessage
instance GHC.Classes.Eq Network.AWS.Types.ErrorMessage
instance Network.AWS.Data.Log.ToLog Network.AWS.Types.ErrorCode
instance Network.AWS.Data.Text.ToText Network.AWS.Types.ErrorCode
instance GHC.Show.Show Network.AWS.Types.ErrorCode
instance GHC.Classes.Ord Network.AWS.Types.ErrorCode
instance GHC.Classes.Eq Network.AWS.Types.ErrorCode
instance Network.AWS.Data.Log.ToLog Network.AWS.Types.Abbrev
instance Network.AWS.Data.Text.ToText Network.AWS.Types.Abbrev
instance Network.AWS.Data.Text.FromText Network.AWS.Types.Abbrev
instance Data.Aeson.Types.FromJSON.FromJSON Network.AWS.Types.Abbrev
instance Network.AWS.Data.XML.FromXML Network.AWS.Types.Abbrev
instance Data.String.IsString Network.AWS.Types.Abbrev
instance GHC.Show.Show Network.AWS.Types.Abbrev
instance GHC.Classes.Ord Network.AWS.Types.Abbrev
instance GHC.Classes.Eq Network.AWS.Types.Abbrev
instance Data.String.IsString Network.AWS.Types.ErrorCode
instance Data.Aeson.Types.FromJSON.FromJSON Network.AWS.Types.ErrorCode
instance Network.AWS.Data.XML.FromXML Network.AWS.Types.ErrorCode
instance Network.AWS.Data.Text.FromText Network.AWS.Types.ErrorCode
instance GHC.Exception.Exception Network.AWS.Types.Error
instance Network.AWS.Data.Log.ToLog Network.AWS.Types.Error
instance Network.AWS.Data.Log.ToLog Network.AWS.Types.SerializeError
instance Network.AWS.Data.Log.ToLog Network.AWS.Types.ServiceError
instance Network.AWS.Types.AsError GHC.Exception.SomeException
instance Network.AWS.Types.AsError Network.AWS.Types.Error
instance Network.AWS.Data.Text.FromText Network.AWS.Types.LogLevel
instance Network.AWS.Data.Text.ToText Network.AWS.Types.LogLevel
instance Network.AWS.Data.ByteString.ToByteString Network.AWS.Types.LogLevel
instance Network.AWS.Data.Log.ToLog Network.AWS.Types.Meta
instance Network.AWS.Data.Log.ToLog Network.AWS.Types.AuthEnv
instance Data.Aeson.Types.FromJSON.FromJSON Network.AWS.Types.AuthEnv
instance Network.AWS.Data.Log.ToLog Network.AWS.Types.Auth
instance Data.Hashable.Class.Hashable Network.AWS.Types.Region
instance Control.DeepSeq.NFData Network.AWS.Types.Region
instance Network.AWS.Data.Text.FromText Network.AWS.Types.Region
instance Network.AWS.Data.Text.ToText Network.AWS.Types.Region
instance Network.AWS.Data.ByteString.ToByteString Network.AWS.Types.Region
instance Network.AWS.Data.Log.ToLog Network.AWS.Types.Region
instance Network.AWS.Data.XML.FromXML Network.AWS.Types.Region
instance Network.AWS.Data.XML.ToXML Network.AWS.Types.Region
instance Data.Aeson.Types.FromJSON.FromJSON Network.AWS.Types.Region
instance Data.Aeson.Types.ToJSON.ToJSON Network.AWS.Types.Region
instance Data.Hashable.Class.Hashable Network.AWS.Types.Seconds
instance Control.DeepSeq.NFData Network.AWS.Types.Seconds
instance Network.AWS.Data.Log.ToLog Network.AWS.Types.Seconds


module Network.AWS.Endpoint

-- | A convenience function for overriding the <a>Service</a>
--   <a>Endpoint</a>.
--   
--   <i>See:</i> <a>serviceEndpoint</a>.
setEndpoint :: Bool -> ByteString -> Int -> Service -> Service

-- | Determine the full host address and credential scope within the
--   specified <a>Region</a>.
defaultEndpoint :: Service -> Region -> Endpoint


module Network.AWS.Error
statusSuccess :: Status -> Bool
httpStatus :: AsError a => Getting (First Status) a Status
hasStatus :: (Applicative f, Choice p) => Int -> Optic' p f ServiceError ServiceError
hasCode :: (Applicative f, Choice p) => ErrorCode -> Optic' p f ServiceError ServiceError
serviceError :: Abbrev -> Status -> [Header] -> Maybe ErrorCode -> Maybe ErrorMessage -> Maybe RequestId -> ServiceError
getRequestId :: [Header] -> Maybe RequestId
getErrorCode :: Status -> [Header] -> ErrorCode
parseJSONError :: Abbrev -> Status -> [Header] -> LazyByteString -> Error
parseXMLError :: Abbrev -> Status -> [Header] -> LazyByteString -> Error
parseRESTError :: Abbrev -> Status -> [Header] -> a -> Error
decodeError :: Abbrev -> Status -> [Header] -> LazyByteString -> Either String ServiceError -> Error


module Network.AWS.Pager

-- | Specify how an <a>AWSRequest</a> and it's associated <a>Rs</a>
--   response can generate a subsequent request, if available.
class AWSRequest a => AWSPager a
page :: AWSPager a => a -> Rs a -> Maybe a

-- | Generalise IsTruncated and other optional/required response pagination
--   fields.
class AWSTruncated a
truncated :: AWSTruncated a => a -> Bool
stop :: AWSTruncated a => a -> Bool
choice :: (Alternative f, ToText a, ToText b) => (s -> f a) -> (s -> f b) -> Getter s (f Text)
instance Network.AWS.Pager.AWSTruncated GHC.Types.Bool
instance Network.AWS.Pager.AWSTruncated (GHC.Base.Maybe GHC.Types.Int)
instance Network.AWS.Pager.AWSTruncated (GHC.Base.Maybe GHC.Types.Bool)
instance Network.AWS.Pager.AWSTruncated (GHC.Base.Maybe Data.Text.Internal.Text)
instance Network.AWS.Pager.AWSTruncated [a]
instance Network.AWS.Pager.AWSTruncated (Data.HashMap.Base.HashMap k v)


module Network.AWS.Request
head' :: ToRequest a => Service -> a -> Request a
delete :: ToRequest a => Service -> a -> Request a
get :: ToRequest a => Service -> a -> Request a
post :: ToRequest a => Service -> a -> Request a
put :: ToRequest a => Service -> a -> Request a
patchJSON :: (ToRequest a, ToJSON a) => Service -> a -> Request a
postXML :: (ToRequest a, ToElement a) => Service -> a -> Request a
postJSON :: (ToRequest a, ToJSON a) => Service -> a -> Request a
postQuery :: ToRequest a => Service -> a -> Request a
postBody :: (ToRequest a, ToBody a) => Service -> a -> Request a
putXML :: (ToRequest a, ToElement a) => Service -> a -> Request a
putJSON :: (ToRequest a, ToJSON a) => Service -> a -> Request a
putBody :: (ToRequest a, ToBody a) => Service -> a -> Request a
defaultRequest :: ToRequest a => Service -> a -> Request a
contentMD5Header :: Request a -> Request a
expectHeader :: Request a -> Request a
requestHeaders :: Lens' Request RequestHeaders
queryString :: Lens' Request ByteString
requestURL :: ClientRequest -> ByteString


module Network.AWS.Response
receiveNull :: MonadResource m => Rs a -> Logger -> Service -> Proxy a -> ClientResponse -> m (Response a)
receiveEmpty :: MonadResource m => (Int -> ResponseHeaders -> () -> Either String (Rs a)) -> Logger -> Service -> Proxy a -> ClientResponse -> m (Response a)
receiveXMLWrapper :: MonadResource m => Text -> (Int -> ResponseHeaders -> [Node] -> Either String (Rs a)) -> Logger -> Service -> Proxy a -> ClientResponse -> m (Response a)
receiveXML :: MonadResource m => (Int -> ResponseHeaders -> [Node] -> Either String (Rs a)) -> Logger -> Service -> Proxy a -> ClientResponse -> m (Response a)
receiveJSON :: MonadResource m => (Int -> ResponseHeaders -> Object -> Either String (Rs a)) -> Logger -> Service -> Proxy a -> ClientResponse -> m (Response a)
receiveBody :: MonadResource m => (Int -> ResponseHeaders -> RsBody -> Either String (Rs a)) -> Logger -> Service -> Proxy a -> ClientResponse -> m (Response a)

-- | Deserialise an entire response body, such as an XML or JSON payload.
deserialise :: MonadResource m => (LazyByteString -> Either String b) -> (Int -> ResponseHeaders -> b -> Either String (Rs a)) -> Logger -> Service -> Proxy a -> ClientResponse -> m (Response a)

-- | Stream a raw response body, such as an S3 object payload.
stream :: MonadResource m => (Int -> ResponseHeaders -> ResponseBody -> m (Either String (Rs a))) -> Service -> Proxy a -> ClientResponse -> m (Response a)
sinkLBS :: MonadResource m => ResponseBody -> m LazyByteString


module Network.AWS.Waiter
type Acceptor a = Request a -> Either Error (Response a) -> Maybe Accept
data Accept
AcceptSuccess :: Accept
AcceptFailure :: Accept
AcceptRetry :: Accept

-- | Timing and acceptance criteria to check fulfillment of a remote
--   operation.
data Wait a
Wait :: ByteString -> !Int -> !Seconds -> [Acceptor a] -> Wait a
[_waitName] :: Wait a -> ByteString
[_waitAttempts] :: Wait a -> !Int
[_waitDelay] :: Wait a -> !Seconds
[_waitAcceptors] :: Wait a -> [Acceptor a]
accept :: Wait a -> Acceptor a
matchAll :: Eq b => b -> Accept -> Fold (Rs a) b -> Acceptor a
matchAny :: Eq b => b -> Accept -> Fold (Rs a) b -> Acceptor a
matchError :: ErrorCode -> Accept -> Acceptor a
matchStatus :: Int -> Accept -> Acceptor a
nonEmpty :: Fold a Text -> Fold a Bool
instance GHC.Show.Show Network.AWS.Waiter.Accept
instance GHC.Classes.Eq Network.AWS.Waiter.Accept
instance Network.AWS.Data.Log.ToLog Network.AWS.Waiter.Accept


module Network.AWS.Data.Base64

-- | Base64 encoded binary data.
--   
--   Encoding/decoding is automatically deferred to serialisation and
--   deserialisation respectively.
newtype Base64
Base64 :: ByteString -> Base64
[unBase64] :: Base64 -> ByteString
_Base64 :: Iso' Base64 ByteString
instance GHC.Generics.Generic Network.AWS.Data.Base64.Base64
instance Data.Data.Data Network.AWS.Data.Base64.Base64
instance GHC.Classes.Ord Network.AWS.Data.Base64.Base64
instance GHC.Read.Read Network.AWS.Data.Base64.Base64
instance GHC.Classes.Eq Network.AWS.Data.Base64.Base64
instance Data.Hashable.Class.Hashable Network.AWS.Data.Base64.Base64
instance Control.DeepSeq.NFData Network.AWS.Data.Base64.Base64
instance Network.AWS.Data.Text.FromText Network.AWS.Data.Base64.Base64
instance Network.AWS.Data.ByteString.ToByteString Network.AWS.Data.Base64.Base64
instance GHC.Show.Show Network.AWS.Data.Base64.Base64
instance Network.AWS.Data.Text.ToText Network.AWS.Data.Base64.Base64
instance Network.AWS.Data.Query.ToQuery Network.AWS.Data.Base64.Base64
instance Network.AWS.Data.XML.FromXML Network.AWS.Data.Base64.Base64
instance Network.AWS.Data.XML.ToXML Network.AWS.Data.Base64.Base64
instance Data.Aeson.Types.FromJSON.FromJSON Network.AWS.Data.Base64.Base64
instance Data.Aeson.Types.ToJSON.ToJSON Network.AWS.Data.Base64.Base64
instance Network.AWS.Data.Body.ToHashedBody Network.AWS.Data.Base64.Base64
instance Network.AWS.Data.Body.ToBody Network.AWS.Data.Base64.Base64


module Network.AWS.Compat.Time
parseTime :: ParseTime a => TimeLocale -> String -> String -> Maybe a


module Network.AWS.Compat.Locale

-- | Locale representing American usage.
--   
--   <a>knownTimeZones</a> contains only the ten time-zones mentioned in
--   RFC 822 sec. 5: "UT", "GMT", "EST", "EDT", "CST", "CDT", "MST", "MDT",
--   "PST", "PDT". Note that the parsing functions will regardless parse
--   single-letter military time-zones and +HHMM format.
defaultTimeLocale :: TimeLocale

-- | Construct format string according to <a>ISO-8601</a>.
--   
--   The <tt>Maybe String</tt> argument allows to supply an optional time
--   specification. E.g.:
--   
--   <pre>
--   <a>iso8601DateFormat</a> Nothing            == "%Y-%m-%d"           -- i.e. <tt><i>YYYY-MM-DD</i></tt>
--   <a>iso8601DateFormat</a> (Just "%H:%M:%S")  == "%Y-%m-%dT%H:%M:%S"  -- i.e. <tt><i>YYYY-MM-DD</i>T<i>HH:MM:SS</i></tt>
--   </pre>
iso8601DateFormat :: Maybe String -> String


module Network.AWS.Data.Time
data Format
RFC822Format :: Format
ISO8601Format :: Format
BasicFormat :: Format
AWSFormat :: Format
POSIXFormat :: Format
data Time :: Format -> *
[Time] :: UTCTime -> Time a
_Time :: Iso' (Time a) UTCTime

-- | This is the simplest representation of UTC. It consists of the day
--   number, and a time offset from midnight. Note that if a day has a leap
--   second added to it, it will have 86401 seconds.
data UTCTime :: *
type RFC822 = Time RFC822Format
type ISO8601 = Time ISO8601Format
type BasicTime = Time BasicFormat
type AWSTime = Time AWSFormat
type POSIX = Time POSIXFormat
instance GHC.Generics.Generic (Network.AWS.Data.Time.Time a)
instance Data.Typeable.Internal.Typeable a => Data.Data.Data (Network.AWS.Data.Time.Time a)
instance GHC.Generics.Generic Network.AWS.Data.Time.Format
instance Data.Data.Data Network.AWS.Data.Time.Format
instance GHC.Show.Show Network.AWS.Data.Time.Format
instance GHC.Read.Read Network.AWS.Data.Time.Format
instance GHC.Classes.Eq Network.AWS.Data.Time.Format
instance GHC.Classes.Eq (Network.AWS.Data.Time.Time a)
instance GHC.Classes.Ord (Network.AWS.Data.Time.Time a)
instance GHC.Read.Read (Network.AWS.Data.Time.Time a)
instance GHC.Show.Show (Network.AWS.Data.Time.Time a)
instance Control.DeepSeq.NFData (Network.AWS.Data.Time.Time a)
instance Data.Hashable.Class.Hashable (Network.AWS.Data.Time.Time a)
instance Network.AWS.Data.Time.TimeFormat Network.AWS.Data.Time.RFC822
instance Network.AWS.Data.Time.TimeFormat Network.AWS.Data.Time.ISO8601
instance Network.AWS.Data.Time.TimeFormat Network.AWS.Data.Time.BasicTime
instance Network.AWS.Data.Time.TimeFormat Network.AWS.Data.Time.AWSTime
instance Network.AWS.Data.Text.FromText Network.AWS.Data.Time.BasicTime
instance Network.AWS.Data.Text.FromText Network.AWS.Data.Time.AWSTime
instance Network.AWS.Data.Text.FromText Network.AWS.Data.Time.RFC822
instance Network.AWS.Data.Text.FromText Network.AWS.Data.Time.ISO8601
instance Network.AWS.Data.Text.ToText Network.AWS.Data.Time.RFC822
instance Network.AWS.Data.Text.ToText Network.AWS.Data.Time.ISO8601
instance Network.AWS.Data.Text.ToText Network.AWS.Data.Time.BasicTime
instance Network.AWS.Data.Text.ToText Network.AWS.Data.Time.AWSTime
instance Network.AWS.Data.Text.ToText Network.AWS.Data.Time.POSIX
instance Network.AWS.Data.XML.FromXML Network.AWS.Data.Time.RFC822
instance Network.AWS.Data.XML.FromXML Network.AWS.Data.Time.ISO8601
instance Network.AWS.Data.XML.FromXML Network.AWS.Data.Time.AWSTime
instance Network.AWS.Data.XML.FromXML Network.AWS.Data.Time.BasicTime
instance Data.Aeson.Types.FromJSON.FromJSON Network.AWS.Data.Time.RFC822
instance Data.Aeson.Types.FromJSON.FromJSON Network.AWS.Data.Time.ISO8601
instance Data.Aeson.Types.FromJSON.FromJSON Network.AWS.Data.Time.AWSTime
instance Data.Aeson.Types.FromJSON.FromJSON Network.AWS.Data.Time.BasicTime
instance Data.Aeson.Types.FromJSON.FromJSON Network.AWS.Data.Time.POSIX
instance Network.AWS.Data.ByteString.ToByteString Network.AWS.Data.Time.RFC822
instance Network.AWS.Data.ByteString.ToByteString Network.AWS.Data.Time.ISO8601
instance Network.AWS.Data.ByteString.ToByteString Network.AWS.Data.Time.BasicTime
instance Network.AWS.Data.ByteString.ToByteString Network.AWS.Data.Time.AWSTime
instance Network.AWS.Data.Query.ToQuery Network.AWS.Data.Time.RFC822
instance Network.AWS.Data.Query.ToQuery Network.AWS.Data.Time.ISO8601
instance Network.AWS.Data.Query.ToQuery Network.AWS.Data.Time.BasicTime
instance Network.AWS.Data.Query.ToQuery Network.AWS.Data.Time.AWSTime
instance Network.AWS.Data.XML.ToXML Network.AWS.Data.Time.RFC822
instance Network.AWS.Data.XML.ToXML Network.AWS.Data.Time.ISO8601
instance Network.AWS.Data.XML.ToXML Network.AWS.Data.Time.AWSTime
instance Network.AWS.Data.XML.ToXML Network.AWS.Data.Time.BasicTime
instance Data.Aeson.Types.ToJSON.ToJSON Network.AWS.Data.Time.RFC822
instance Data.Aeson.Types.ToJSON.ToJSON Network.AWS.Data.Time.ISO8601
instance Data.Aeson.Types.ToJSON.ToJSON Network.AWS.Data.Time.AWSTime
instance Data.Aeson.Types.ToJSON.ToJSON Network.AWS.Data.Time.BasicTime
instance Data.Aeson.Types.ToJSON.ToJSON Network.AWS.Data.Time.POSIX


module Network.AWS.Prelude
(.!@) :: Functor f => f (Maybe a) -> a -> f a
infixl 7 .!@
may :: Applicative f => ([a] -> f b) -> [a] -> f (Maybe b)


module Network.AWS.Sign.V2
v2 :: Signer
instance Network.AWS.Data.Log.ToLog Network.AWS.Sign.V2.V2


module Network.AWS.Sign.V4
data V4
V4 :: !UTCTime -> !Method -> !Path -> !Endpoint -> !Credential -> !CanonicalQuery -> !CanonicalRequest -> !CanonicalHeaders -> !SignedHeaders -> !StringToSign -> !Signature -> ![Header] -> !(Maybe Seconds) -> V4
[metaTime] :: V4 -> !UTCTime
[metaMethod] :: V4 -> !Method
[metaPath] :: V4 -> !Path
[metaEndpoint] :: V4 -> !Endpoint
[metaCredential] :: V4 -> !Credential
[metaCanonicalQuery] :: V4 -> !CanonicalQuery
[metaCanonicalRequest] :: V4 -> !CanonicalRequest
[metaCanonicalHeaders] :: V4 -> !CanonicalHeaders
[metaSignedHeaders] :: V4 -> !SignedHeaders
[metaStringToSign] :: V4 -> !StringToSign
[metaSignature] :: V4 -> !Signature
[metaHeaders] :: V4 -> ![Header]
[metaTimeout] :: V4 -> !(Maybe Seconds)
v4 :: Signer
