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

-- | Twitter API package with conduit interface and Streaming API support.
--   
--   This package provides bindings to Twitter's APIs (see
--   https://dev.twitter.com/).
--   
--   This package uses the http-conduit package for accessing the Twitter
--   API (see http://hackage.haskell.org/package/http-conduit). This
--   package also depends on the twitter-types package (see
--   http://hackage.haskell.org/package/twitter-types).
--   
--   You can find basic examples in the
--   https://github.com/himura/twitter-conduit/tree/master/sample
--   directory.
--   
--   This package is under development. If you find something that has not
--   been implemented yet, please send a pull request or open an issue on
--   GitHub.
@package twitter-conduit
@version 0.5.0

module Web.Twitter.Conduit.Cursor
class CursorKey a
cursorKey :: CursorKey a => a -> Text

-- | Phantom type to specify the key which point out the content in the
--   response.
data IdsCursorKey

-- | Phantom type to specify the key which point out the content in the
--   response.
data UsersCursorKey

-- | Phantom type to specify the key which point out the content in the
--   response.
data ListsCursorKey
data EventsCursorKey

-- | A wrapper for API responses which have "next_cursor" field.
--   
--   The first type parameter of WithCursor specifies the field name
--   of contents.
--   
--   
--   >>> let Just res = decode "{\"previous_cursor\": 0, \"next_cursor\": 1234567890, \"ids\": [1111111111]}" :: Maybe (WithCursor Integer IdsCursorKey UserId)
--   
--   >>> nextCursor res
--   Just 1234567890
--   
--   >>> contents res
--   [1111111111]
--   
--   
--   
--   >>> let Just res = decode "{\"previous_cursor\": 0, \"next_cursor\": 0, \"users\": [1000]}" :: Maybe (WithCursor Integer UsersCursorKey UserId)
--   
--   >>> nextCursor res
--   Just 0
--   
--   >>> contents res
--   [1000]
--   
--   
--   
--   >>> let Just res = decode "{\"next_cursor\": \"hogehoge\", \"events\": [1000]}" :: Maybe (WithCursor Text EventsCursorKey UserId)
--   
--   >>> nextCursor res
--   Just "hogehoge"
--   
--   >>> contents res
--   [1000]
--   
data WithCursor cursorType cursorKey wrapped
WithCursor :: Maybe cursorType -> Maybe cursorType -> [wrapped] -> WithCursor cursorType cursorKey wrapped
[previousCursor] :: WithCursor cursorType cursorKey wrapped -> Maybe cursorType
[nextCursor] :: WithCursor cursorType cursorKey wrapped -> Maybe cursorType
[contents] :: WithCursor cursorType cursorKey wrapped -> [wrapped]
instance (GHC.Show.Show cursorType, GHC.Show.Show wrapped) => GHC.Show.Show (Web.Twitter.Conduit.Cursor.WithCursor cursorType cursorKey wrapped)
instance (Data.Aeson.Types.FromJSON.FromJSON wrapped, Data.Aeson.Types.FromJSON.FromJSON ct, Web.Twitter.Conduit.Cursor.CursorKey c) => Data.Aeson.Types.FromJSON.FromJSON (Web.Twitter.Conduit.Cursor.WithCursor ct c wrapped)
instance Web.Twitter.Conduit.Cursor.CursorKey Web.Twitter.Conduit.Cursor.EventsCursorKey
instance Web.Twitter.Conduit.Cursor.CursorKey Web.Twitter.Conduit.Cursor.ListsCursorKey
instance Web.Twitter.Conduit.Cursor.CursorKey Web.Twitter.Conduit.Cursor.UsersCursorKey
instance Web.Twitter.Conduit.Cursor.CursorKey Web.Twitter.Conduit.Cursor.IdsCursorKey

module Web.Twitter.Conduit.Request.Internal
data Param label t
(:=) :: label -> t -> Param label t
type EmptyParams = ('[] :: [Param Symbol *])
type HasParam (label :: Symbol) (paramType :: *) (params :: [Param Symbol *]) = ParamType label params ~ paramType
type family ParamType (label :: Symbol) (params :: [Param Symbol *]) :: *
type APIQuery = [APIQueryItem]
type APIQueryItem = (ByteString, PV)
data PV
PVInteger :: Integer -> PV
[unPVInteger] :: PV -> Integer
PVBool :: Bool -> PV
[unPVBool] :: PV -> Bool
PVString :: Text -> PV
[unPVString] :: PV -> Text
PVIntegerArray :: [Integer] -> PV
[unPVIntegerArray] :: PV -> [Integer]
PVStringArray :: [Text] -> PV
[unPVStringArray] :: PV -> [Text]
PVDay :: Day -> PV
[unPVDay] :: PV -> Day
class Parameters req where {
    type family SupportParameters req :: [Param Symbol *];
}
params :: Parameters req => Lens' req APIQuery
class ParameterValue a
wrap :: ParameterValue a => a -> PV
unwrap :: ParameterValue a => PV -> a
makeSimpleQuery :: APIQuery -> SimpleQuery
paramValueBS :: PV -> ByteString
rawParam :: (Parameters p, ParameterValue a) => ByteString -> Lens' p (Maybe a)
instance GHC.Classes.Eq Web.Twitter.Conduit.Request.Internal.PV
instance GHC.Show.Show Web.Twitter.Conduit.Request.Internal.PV
instance Web.Twitter.Conduit.Request.Internal.ParameterValue GHC.Integer.Type.Integer
instance Web.Twitter.Conduit.Request.Internal.ParameterValue GHC.Types.Bool
instance Web.Twitter.Conduit.Request.Internal.ParameterValue Data.Text.Internal.Text
instance Web.Twitter.Conduit.Request.Internal.ParameterValue [GHC.Integer.Type.Integer]
instance Web.Twitter.Conduit.Request.Internal.ParameterValue [Data.Text.Internal.Text]
instance Web.Twitter.Conduit.Request.Internal.ParameterValue Data.Time.Calendar.Days.Day
instance (Web.Twitter.Conduit.Request.Internal.Parameters req, Web.Twitter.Conduit.Request.Internal.ParameterValue a, GHC.TypeLits.KnownSymbol label, Web.Twitter.Conduit.Request.Internal.HasParam label a (Web.Twitter.Conduit.Request.Internal.SupportParameters req), GHC.Base.Functor f, lens GHC.Types.~ ((GHC.Maybe.Maybe a -> f (GHC.Maybe.Maybe a)) -> req -> f req)) => GHC.OverloadedLabels.IsLabel label lens

module Web.Twitter.Conduit.Request
type HasParam (label :: Symbol) (paramType :: *) (params :: [Param Symbol *]) = ParamType label params ~ paramType

-- | API request. You should use specific builder functions instead of
--   building this directly.
--   
--   For example, if there were a SampleApi type and a builder
--   function which named sampleApiRequest.
--   
--   
--   type SampleId = Integer
--   sampleApiRequest :: APIRequest SampleApi [SampleId]
--   sampleApiRequest = APIRequest "GET" "https://api.twitter.com/sample/api.json" []
--   type SampleApi = '[ "count" ':= Integer
--                     , "max_id" ':= Integer
--                     ]
--   
--   
--   We can obtain request params from APIRequest SampleApi
--   [SampleId] :
--   
--   
--   >>> sampleApiRequest ^. params
--   []
--   
--   
--   The second type parameter of the APIRequest represents the allowed
--   parameters for the APIRequest. For example, sampleApiRequest
--   has 2 Integer parameters, that is "count" and "max_id". You
--   can update those parameters by label lenses (#count and
--   #max_id respectively)
--   
--   
--   >>> (sampleApiRequest & #count ?~ 100 & #max_id ?~ 1234567890) ^. params
--   [("max_id",PVInteger {unPVInteger = 1234567890}),("count",PVInteger {unPVInteger = 100})]
--   
--   >>> (sampleApiRequest & #count ?~ 100 & #max_id ?~ 1234567890 & #count .~ Nothing) ^. params
--   [("max_id",PVInteger {unPVInteger = 1234567890})]
--   
data APIRequest (supports :: [Param Symbol *]) responseType
APIRequest :: Method -> String -> APIQuery -> APIRequest (supports :: [Param Symbol *]) responseType
[_method] :: APIRequest (supports :: [Param Symbol *]) responseType -> Method
[_url] :: APIRequest (supports :: [Param Symbol *]) responseType -> String
[_params] :: APIRequest (supports :: [Param Symbol *]) responseType -> APIQuery
APIRequestMultipart :: Method -> String -> APIQuery -> [Part] -> APIRequest (supports :: [Param Symbol *]) responseType
[_method] :: APIRequest (supports :: [Param Symbol *]) responseType -> Method
[_url] :: APIRequest (supports :: [Param Symbol *]) responseType -> String
[_params] :: APIRequest (supports :: [Param Symbol *]) responseType -> APIQuery
[_part] :: APIRequest (supports :: [Param Symbol *]) responseType -> [Part]
APIRequestJSON :: Method -> String -> APIQuery -> Value -> APIRequest (supports :: [Param Symbol *]) responseType
[_method] :: APIRequest (supports :: [Param Symbol *]) responseType -> Method
[_url] :: APIRequest (supports :: [Param Symbol *]) responseType -> String
[_params] :: APIRequest (supports :: [Param Symbol *]) responseType -> APIQuery
[_body] :: APIRequest (supports :: [Param Symbol *]) responseType -> Value
instance Web.Twitter.Conduit.Request.Internal.Parameters (Web.Twitter.Conduit.Request.APIRequest supports responseType)
instance GHC.Show.Show (Web.Twitter.Conduit.Request.APIRequest apiName responseType)

module Web.Twitter.Conduit.ParametersDeprecated
count :: (Parameters p, HasParam "count" Integer (SupportParameters p)) => Lens' p (Maybe Integer)
sinceId :: (Parameters p, HasParam "since_id" Integer (SupportParameters p)) => Lens' p (Maybe Integer)
maxId :: (Parameters p, HasParam "max_id" Integer (SupportParameters p)) => Lens' p (Maybe Integer)
page :: (Parameters p, HasParam "page" Integer (SupportParameters p)) => Lens' p (Maybe Integer)
trimUser :: (Parameters p, HasParam "trim_user" Bool (SupportParameters p)) => Lens' p (Maybe Bool)
excludeReplies :: (Parameters p, HasParam "exclude_replies" Bool (SupportParameters p)) => Lens' p (Maybe Bool)
contributorDetails :: (Parameters p, HasParam "contributor_details" Bool (SupportParameters p)) => Lens' p (Maybe Bool)
includeEntities :: (Parameters p, HasParam "include_entities" Bool (SupportParameters p)) => Lens' p (Maybe Bool)
includeEmail :: (Parameters p, HasParam "include_email" Bool (SupportParameters p)) => Lens' p (Maybe Bool)
includeUserEntities :: (Parameters p, HasParam "include_user_entities" Bool (SupportParameters p)) => Lens' p (Maybe Bool)
includeRts :: (Parameters p, HasParam "include_rts" Bool (SupportParameters p)) => Lens' p (Maybe Bool)
includeMyRetweet :: (Parameters p, HasParam "include_my_retweet" Bool (SupportParameters p)) => Lens' p (Maybe Bool)
includeExtAltText :: (Parameters p, HasParam "include_ext_alt_text" Bool (SupportParameters p)) => Lens' p (Maybe Bool)
inReplyToStatusId :: (Parameters p, HasParam "in_reply_to_status_id" Integer (SupportParameters p)) => Lens' p (Maybe Integer)
displayCoordinates :: (Parameters p, HasParam "display_coordinates" Bool (SupportParameters p)) => Lens' p (Maybe Bool)
possiblySensitive :: (Parameters p, HasParam "possibly_sensitive" Bool (SupportParameters p)) => Lens' p (Maybe Bool)
lang :: (Parameters p, HasParam "lang" Text (SupportParameters p)) => Lens' p (Maybe Text)
language :: (Parameters p, HasParam "language" Text (SupportParameters p)) => Lens' p (Maybe Text)
locale :: (Parameters p, HasParam "locale" Text (SupportParameters p)) => Lens' p (Maybe Text)
filterLevel :: (Parameters p, HasParam "filter_level" Text (SupportParameters p)) => Lens' p (Maybe Text)
stallWarnings :: (Parameters p, HasParam "stall_warnings" Bool (SupportParameters p)) => Lens' p (Maybe Bool)
replies :: (Parameters p, HasParam "replies" Text (SupportParameters p)) => Lens' p (Maybe Text)
until :: (Parameters p, HasParam "until" Day (SupportParameters p)) => Lens' p (Maybe Day)
skipStatus :: (Parameters p, HasParam "skip_status" Bool (SupportParameters p)) => Lens' p (Maybe Bool)
follow :: (Parameters p, HasParam "follow" Bool (SupportParameters p)) => Lens' p (Maybe Bool)
map :: (Parameters p, HasParam "map" Bool (SupportParameters p)) => Lens' p (Maybe Bool)
mediaIds :: (Parameters p, HasParam "media_ids" [Integer] (SupportParameters p)) => Lens' p (Maybe [Integer])
description :: (Parameters p, HasParam "description" Text (SupportParameters p)) => Lens' p (Maybe Text)
name :: (Parameters p, HasParam "name" Text (SupportParameters p)) => Lens' p (Maybe Text)
profileLinkColor :: (Parameters p, HasParam "profile_link_color" Text (SupportParameters p)) => Lens' p (Maybe Text)
location :: (Parameters p, HasParam "location" Text (SupportParameters p)) => Lens' p (Maybe Text)
url :: (Parameters p, HasParam "url" URIString (SupportParameters p)) => Lens' p (Maybe URIString)
fullText :: (Parameters p, HasParam "full_text" Bool (SupportParameters p)) => Lens' p (Maybe Bool)
with :: (Parameters p, HasParam "with" Text (SupportParameters p)) => Lens' p (Maybe Text)

module Web.Twitter.Conduit.Parameters
data UserParam
UserIdParam :: UserId -> UserParam
ScreenNameParam :: String -> UserParam
data UserListParam
UserIdListParam :: [UserId] -> UserListParam
ScreenNameListParam :: [String] -> UserListParam
data ListParam
ListIdParam :: Integer -> ListParam
ListNameParam :: String -> ListParam
data MediaData
MediaFromFile :: FilePath -> MediaData
MediaRequestBody :: FilePath -> RequestBody -> MediaData

-- | converts UserParam to SimpleQuery.
--   
--   
--   >>> makeSimpleQuery . mkUserParam $ UserIdParam 123456
--   [("user_id","123456")]
--   
--   >>> makeSimpleQuery . mkUserParam $ ScreenNameParam "thimura"
--   [("screen_name","thimura")]
--   
mkUserParam :: UserParam -> APIQuery

-- | converts UserListParam to SimpleQuery.
--   
--   
--   >>> makeSimpleQuery . mkUserListParam $ UserIdListParam [123456]
--   [("user_id","123456")]
--   
--   >>> makeSimpleQuery . mkUserListParam $ UserIdListParam [123456, 654321]
--   [("user_id","123456,654321")]
--   
--   >>> makeSimpleQuery . mkUserListParam $ ScreenNameListParam ["thimura", "NikaidouShinku"]
--   [("screen_name","thimura,NikaidouShinku")]
--   
mkUserListParam :: UserListParam -> APIQuery

-- | converts ListParam to SimpleQuery.
--   
--   
--   >>> makeSimpleQuery . mkListParam $ ListIdParam 123123
--   [("list_id","123123")]
--   
--   >>> makeSimpleQuery . mkListParam $ ListNameParam "thimura/haskell"
--   [("slug","haskell"),("owner_screen_name","thimura")]
--   
mkListParam :: ListParam -> APIQuery
instance GHC.Classes.Eq Web.Twitter.Conduit.Parameters.ListParam
instance GHC.Show.Show Web.Twitter.Conduit.Parameters.ListParam
instance GHC.Classes.Eq Web.Twitter.Conduit.Parameters.UserListParam
instance GHC.Show.Show Web.Twitter.Conduit.Parameters.UserListParam
instance GHC.Classes.Eq Web.Twitter.Conduit.Parameters.UserParam
instance GHC.Show.Show Web.Twitter.Conduit.Parameters.UserParam

module Web.Twitter.Conduit.Response
data Response responseType
Response :: Status -> ResponseHeaders -> responseType -> Response responseType
[responseStatus] :: Response responseType -> Status
[responseHeaders] :: Response responseType -> ResponseHeaders
[responseBody] :: Response responseType -> responseType
data TwitterError
FromJSONError :: String -> TwitterError
TwitterErrorResponse :: Status -> ResponseHeaders -> [TwitterErrorMessage] -> TwitterError
TwitterUnknownErrorResponse :: Status -> ResponseHeaders -> Value -> TwitterError
TwitterStatusError :: Status -> ResponseHeaders -> Value -> TwitterError

-- | Twitter Error Messages
--   
--   see detail: https://dev.twitter.com/docs/error-codes-responses
data TwitterErrorMessage
TwitterErrorMessage :: Int -> Text -> TwitterErrorMessage
[twitterErrorCode] :: TwitterErrorMessage -> Int
[twitterErrorMessage] :: TwitterErrorMessage -> Text
instance GHC.Classes.Eq Web.Twitter.Conduit.Response.TwitterError
instance GHC.Show.Show Web.Twitter.Conduit.Response.TwitterError
instance Data.Data.Data Web.Twitter.Conduit.Response.TwitterErrorMessage
instance GHC.Show.Show Web.Twitter.Conduit.Response.TwitterErrorMessage
instance Data.Traversable.Traversable Web.Twitter.Conduit.Response.Response
instance Data.Foldable.Foldable Web.Twitter.Conduit.Response.Response
instance GHC.Base.Functor Web.Twitter.Conduit.Response.Response
instance GHC.Classes.Eq responseType => GHC.Classes.Eq (Web.Twitter.Conduit.Response.Response responseType)
instance GHC.Show.Show responseType => GHC.Show.Show (Web.Twitter.Conduit.Response.Response responseType)
instance GHC.Exception.Type.Exception Web.Twitter.Conduit.Response.TwitterError
instance GHC.Classes.Eq Web.Twitter.Conduit.Response.TwitterErrorMessage
instance GHC.Classes.Ord Web.Twitter.Conduit.Response.TwitterErrorMessage
instance GHC.Enum.Enum Web.Twitter.Conduit.Response.TwitterErrorMessage
instance Data.Aeson.Types.FromJSON.FromJSON Web.Twitter.Conduit.Response.TwitterErrorMessage

module Web.Twitter.Conduit.Lens
data Response responseType
responseStatus :: forall responseType. Lens' (Response responseType) Status
responseBody :: forall a b. Lens (Response a) (Response b) a b
responseHeaders :: forall responseType. Lens' (Response responseType) ResponseHeaders

-- | Twitter Error Messages
--   
--   see detail: https://dev.twitter.com/docs/error-codes-responses
data TwitterErrorMessage
twitterErrorMessage :: Lens' TwitterErrorMessage Text
twitterErrorCode :: Lens' TwitterErrorMessage Int

-- | A wrapper for API responses which have "next_cursor" field.
--   
--   The first type parameter of WithCursor specifies the field name
--   of contents.
--   
--   
--   >>> let Just res = decode "{\"previous_cursor\": 0, \"next_cursor\": 1234567890, \"ids\": [1111111111]}" :: Maybe (WithCursor Integer IdsCursorKey UserId)
--   
--   >>> nextCursor res
--   Just 1234567890
--   
--   >>> contents res
--   [1111111111]
--   
--   
--   
--   >>> let Just res = decode "{\"previous_cursor\": 0, \"next_cursor\": 0, \"users\": [1000]}" :: Maybe (WithCursor Integer UsersCursorKey UserId)
--   
--   >>> nextCursor res
--   Just 0
--   
--   >>> contents res
--   [1000]
--   
--   
--   
--   >>> let Just res = decode "{\"next_cursor\": \"hogehoge\", \"events\": [1000]}" :: Maybe (WithCursor Text EventsCursorKey UserId)
--   
--   >>> nextCursor res
--   Just "hogehoge"
--   
--   >>> contents res
--   [1000]
--   
data WithCursor cursorType cursorKey wrapped
previousCursor :: forall cursorType cursorKey wrapped. Lens' (WithCursor cursorType cursorKey wrapped) (Maybe cursorType)
nextCursor :: forall cursorType cursorKey wrapped. Lens' (WithCursor cursorType cursorKey wrapped) (Maybe cursorType)
contents :: forall cursorType cursorKey a b. Lens (WithCursor cursorType cursorKey a) (WithCursor cursorType cursorKey b) [a] [b]
data TwitterError
FromJSONError :: String -> TwitterError
TwitterErrorResponse :: Status -> ResponseHeaders -> [TwitterErrorMessage] -> TwitterError
TwitterUnknownErrorResponse :: Status -> ResponseHeaders -> Value -> TwitterError
TwitterStatusError :: Status -> ResponseHeaders -> Value -> TwitterError
class CursorKey a
cursorKey :: CursorKey a => a -> Text

-- | Phantom type to specify the key which point out the content in the
--   response.
data IdsCursorKey

-- | Phantom type to specify the key which point out the content in the
--   response.
data UsersCursorKey

-- | Phantom type to specify the key which point out the content in the
--   response.
data ListsCursorKey

module Web.Twitter.Conduit.Types
data TWToken
TWToken :: OAuth -> Credential -> TWToken
[twOAuth] :: TWToken -> OAuth
[twCredential] :: TWToken -> Credential
data TWInfo
TWInfo :: TWToken -> Maybe Proxy -> TWInfo
[twToken] :: TWInfo -> TWToken
[twProxy] :: TWInfo -> Maybe Proxy
twitterOAuth :: OAuth

-- | set OAuth keys and Credentials to TWInfo.
--   
--   
--   >>> let proxy = Proxy "localhost" 8080
--   
--   >>> let twinfo = def { twProxy = Just proxy }
--   
--   >>> let oauth = twitterOAuth { oauthConsumerKey = "consumer_key", oauthConsumerSecret = "consumer_secret" }
--   
--   >>> let credential = Credential [("oauth_token","...")]
--   
--   >>> let twinfo2 = setCredential oauth credential twinfo
--   
--   >>> oauthConsumerKey . twOAuth . twToken $ twinfo2
--   "consumer_key"
--   
--   >>> twProxy twinfo2 == Just proxy
--   True
--   
setCredential :: OAuth -> Credential -> TWInfo -> TWInfo
instance GHC.Classes.Eq Web.Twitter.Conduit.Types.TWInfo
instance GHC.Read.Read Web.Twitter.Conduit.Types.TWInfo
instance GHC.Show.Show Web.Twitter.Conduit.Types.TWInfo
instance GHC.Classes.Eq Web.Twitter.Conduit.Types.TWToken
instance GHC.Read.Read Web.Twitter.Conduit.Types.TWToken
instance GHC.Show.Show Web.Twitter.Conduit.Types.TWToken
instance Data.Default.Class.Default Web.Twitter.Conduit.Types.TWInfo
instance Data.Default.Class.Default Web.Twitter.Conduit.Types.TWToken

module Web.Twitter.Conduit.Base
class ResponseBodyType a
parseResponseBody :: ResponseBodyType a => Response (ConduitM () ByteString (ResourceT IO) ()) -> ResourceT IO (Response a)
type NoContent = ()
getResponse :: MonadResource m => TWInfo -> Manager -> Request -> m (Response (ConduitM () ByteString m ()))

-- | Perform an APIRequest and then provide the response which is
--   mapped to a suitable type of twitter-types.
--   
--   Example:
--   
--   
--   user <- call twInfo mgr $ accountVerifyCredentials
--   print user
--   
--   
--   If you need raw JSON value which is parsed by aeson, use
--   call' to obtain it.
call :: ResponseBodyType responseType => TWInfo -> Manager -> APIRequest apiName responseType -> IO responseType

-- | Perform an APIRequest and then provide the response. The
--   response of this function is not restrict to responseType, so
--   you can choose an arbitrarily type of FromJSON instances.
call' :: ResponseBodyType value => TWInfo -> Manager -> APIRequest apiName responseType -> IO value

-- | Perform an APIRequest and then provide the Response.
--   
--   Example:
--   
--   
--   res <- callWithResponse twInfo mgr $ accountVerifyCredentials
--   print $ responseStatus res
--   print $ responseHeaders res
--   print $ responseBody res
--   
callWithResponse :: ResponseBodyType responseType => TWInfo -> Manager -> APIRequest apiName responseType -> IO (Response responseType)

-- | Perform an APIRequest and then provide the Response. The
--   response of this function is not restrict to responseType, so
--   you can choose an arbitrarily type of FromJSON instances.
--   
--   Example:
--   
--   
--   res <- callWithResponse' twInfo mgr $ accountVerifyCredentials
--   print $ responseStatus res
--   print $ responseHeaders res
--   print $ responseBody (res :: Value)
--   
callWithResponse' :: ResponseBodyType value => TWInfo -> Manager -> APIRequest apiName responseType -> IO (Response value)
checkResponse :: Response Value -> Either TwitterError Value

-- | A wrapper function to perform multiple API request with changing
--   max_id parameter.
--   
--   This function cooperate with instances of HasMaxIdParam.
sourceWithMaxId :: (MonadIO m, FromJSON responseType, AsStatus responseType, HasParam "max_id" Integer supports) => TWInfo -> Manager -> APIRequest supports [responseType] -> ConduitT () responseType m ()

-- | A wrapper function to perform multiple API request with changing
--   max_id parameter. The response of this function is not
--   restrict to responseType, so you can choose an arbitrarily
--   type of FromJSON instances.
--   
--   This function cooperate with instances of HasMaxIdParam.
sourceWithMaxId' :: (MonadIO m, HasParam "max_id" Integer supports) => TWInfo -> Manager -> APIRequest supports [responseType] -> ConduitT () Value m ()

-- | A wrapper function to perform multiple API request with changing
--   cursor parameter.
--   
--   This function cooperate with instances of HasCursorParam.
sourceWithCursor :: (MonadIO m, FromJSON responseType, CursorKey ck, HasParam "cursor" Integer supports) => TWInfo -> Manager -> APIRequest supports (WithCursor Integer ck responseType) -> ConduitT () responseType m ()

-- | A wrapper function to perform multiple API request with changing
--   cursor parameter. The response of this function is not
--   restrict to responseType, so you can choose an arbitrarily
--   type of FromJSON instances.
--   
--   This function cooperate with instances of HasCursorParam.
sourceWithCursor' :: (MonadIO m, CursorKey ck, HasParam "cursor" Integer supports) => TWInfo -> Manager -> APIRequest supports (WithCursor Integer ck responseType) -> ConduitT () Value m ()

-- | A wrapper function to perform multiple API request with
--   SearchResult.
sourceWithSearchResult :: (MonadIO m, FromJSON responseType) => TWInfo -> Manager -> APIRequest supports (SearchResult [responseType]) -> m (SearchResult (ConduitT () responseType m ()))

-- | A wrapper function to perform multiple API request with
--   SearchResult.
sourceWithSearchResult' :: MonadIO m => TWInfo -> Manager -> APIRequest supports (SearchResult [responseType]) -> m (SearchResult (ConduitT () Value m ()))
endpoint :: String
makeRequest :: APIRequest apiName responseType -> IO Request
sinkJSON :: MonadThrow m => ConduitT ByteString o m Value
sinkFromJSON :: (FromJSON a, MonadThrow m) => ConduitT ByteString o m a
instance Web.Twitter.Conduit.Base.ResponseBodyType Web.Twitter.Conduit.Base.NoContent
instance Data.Aeson.Types.FromJSON.FromJSON a => Web.Twitter.Conduit.Base.ResponseBodyType a

module Web.Twitter.Conduit.Stream
type Userstream = '["language" := Text, "filter_level" := Text, "stall_warnings" := Bool, "replies" := Text]
userstream :: APIRequest Userstream StreamingAPI
type StatusesFilter = '["language" := Text, "filter_level" := Text, "stall_warnings" := Bool]
data FilterParameter
Follow :: [UserId] -> FilterParameter
Track :: [Text] -> FilterParameter

-- | Returns statuses/filter.json API query data.
--   
--   
--   >>> statusesFilter [Follow [1,2,3]]
--   APIRequest "POST" "https://stream.twitter.com/1.1/statuses/filter.json" [("follow","1,2,3")]
--   
--   >>> statusesFilter [Track ["haskell","functional"]]
--   APIRequest "POST" "https://stream.twitter.com/1.1/statuses/filter.json" [("track","haskell,functional")]
--   
--   >>> statusesFilter [Follow [1,2,3],Track ["haskell","functional"]]
--   APIRequest "POST" "https://stream.twitter.com/1.1/statuses/filter.json" [("follow","1,2,3"),("track","haskell,functional")]
--   
statusesFilter :: [FilterParameter] -> APIRequest StatusesFilter StreamingAPI

-- | Returns statuses/filter.json API query data.
--   
--   
--   >>> statusesFilterByFollow [1,2,3]
--   APIRequest "POST" "https://stream.twitter.com/1.1/statuses/filter.json" [("follow","1,2,3")]
--   
statusesFilterByFollow :: [UserId] -> APIRequest StatusesFilter StreamingAPI

-- | Returns statuses/filter.json API query data.
--   
--   
--   >>> statusesFilterByTrack "haskell"
--   APIRequest "POST" "https://stream.twitter.com/1.1/statuses/filter.json" [("track","haskell")]
--   
statusesFilterByTrack :: Text -> APIRequest StatusesFilter StreamingAPI
stream :: (MonadResource m, FromJSON responseType, MonadThrow m) => TWInfo -> Manager -> APIRequest apiName responseType -> m (ConduitM () responseType m ())
stream' :: (MonadResource m, FromJSON value, MonadThrow m) => TWInfo -> Manager -> APIRequest apiName responseType -> m (ConduitM () value m ())

module Web.Twitter.Conduit.Status
type StatusesMentionsTimeline = '["count" := Integer, "since_id" := Integer, "max_id" := Integer, "trim_user" := Bool, "contributor_details" := Bool, "include_entities" := Bool, "tweet_mode" := Text]

-- | Returns query data asks the most recent mentions for the
--   authenticating user.
--   
--   You can perform a query using call:
--   
--   
--   res <- call mentionsTimeline
--   
--   
--   
--   >>> mentionsTimeline
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/mentions_timeline.json" []
--   
mentionsTimeline :: APIRequest StatusesMentionsTimeline [Status]
type StatusesUserTimeline = '["count" := Integer, "since_id" := Integer, "max_id" := Integer, "trim_user" := Bool, "exclude_replies" := Bool, "contributor_details" := Bool, "include_rts" := Bool, "tweet_mode" := Text]

-- | Returns query data asks a collection of the most recent Tweets posted
--   by the user indicated by the screen_name or user_id parameters.
--   
--   You can perform a search query using call:
--   
--   
--   res <- call $ userTimeline (ScreenNameParam "thimura")
--   
--   
--   
--   >>> userTimeline (ScreenNameParam "thimura")
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/user_timeline.json" [("screen_name","thimura")]
--   
--   >>> userTimeline (ScreenNameParam "thimura") & #include_rts ?~ True & #count ?~ 200
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/user_timeline.json" [("count","200"),("include_rts","true"),("screen_name","thimura")]
--   
userTimeline :: UserParam -> APIRequest StatusesUserTimeline [Status]
type StatusesHomeTimeline = '["count" := Integer, "since_id" := Integer, "max_id" := Integer, "trim_user" := Bool, "exclude_replies" := Bool, "contributor_details" := Bool, "include_entities" := Bool, "tweet_mode" := Text]

-- | Returns query data asks a collection of the most recentTweets and
--   retweets posted by the authenticating user and the users they follow.
--   
--   You can perform a search query using call:
--   
--   
--   res <- call homeTimeline
--   
--   
--   
--   >>> homeTimeline
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/home_timeline.json" []
--   
--   >>> homeTimeline & #count ?~ 200
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/home_timeline.json" [("count","200")]
--   
homeTimeline :: APIRequest StatusesHomeTimeline [Status]
type StatusesRetweetsOfMe = '["count" := Integer, "since_id" := Integer, "max_id" := Integer, "trim_user" := Bool, "include_entities" := Bool, "include_user_entities" := Bool, "tweet_mode" := Text]

-- | Returns query data asks the most recent tweets authored by the
--   authenticating user that have been retweeted by others.
--   
--   You can perform a search query using call:
--   
--   
--   res <- call retweetsOfMe
--   
--   
--   
--   >>> retweetsOfMe
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/retweets_of_me.json" []
--   
--   >>> retweetsOfMe & #count ?~ 100
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/retweets_of_me.json" [("count","100")]
--   
retweetsOfMe :: APIRequest StatusesRetweetsOfMe [Status]
type StatusesRetweetsId = '["count" := Integer, "trim_user" := Bool]

-- | Returns query data that asks for the most recent retweets of the
--   specified tweet
--   
--   You can perform a search query using call:
--   
--   
--   res <- call twInfo mgr $ retweetsId 1234567890
--   
--   
--   
--   >>> retweetsId 1234567890
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/retweets/1234567890.json" []
--   
--   >>> retweetsId 1234567890 & #count ?~ 100
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/retweets/1234567890.json" [("count","100")]
--   
retweetsId :: StatusId -> APIRequest StatusesRetweetsId [RetweetedStatus]
type StatusesShowId = '["trim_user" := Bool, "include_my_retweet" := Bool, "include_entities" := Bool, "include_ext_alt_text" := Bool, "tweet_mode" := Text]

-- | Returns query data asks a single Tweet, specified by the id parameter.
--   
--   You can perform a search query using call:
--   
--   
--   res <- call twInfo mgr $ showId 1234567890
--   
--   
--   
--   >>> showId 1234567890
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/show/1234567890.json" []
--   
--   >>> showId 1234567890 & #include_my_retweet ?~ True
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/show/1234567890.json" [("include_my_retweet","true")]
--   
showId :: StatusId -> APIRequest StatusesShowId Status
type StatusesDestroyId = '["trim_user" := Bool, "tweet_mode" := Text]

-- | Returns post data which destroys the status specified by the require
--   ID parameter.
--   
--   You can perform a search query using call:
--   
--   
--   res <- call twInfo mgr $ destroyId 1234567890
--   
--   
--   
--   >>> destroyId 1234567890
--   APIRequest "POST" "https://api.twitter.com/1.1/statuses/destroy/1234567890.json" []
--   
destroyId :: StatusId -> APIRequest StatusesDestroyId Status
type StatusesUpdate = '["in_reply_to_status_id" := Integer, "display_coordinates" := Bool, "trim_user" := Bool, "media_ids" := [Integer], "tweet_mode" := Text]

-- | Returns post data which updates the authenticating user's current
--   status. To upload an image to accompany the tweet, use
--   updateWithMedia.
--   
--   You can perform a search query using call:
--   
--   
--   res <- call twInfo mgr $ update "Hello World"
--   
--   
--   
--   >>> update "Hello World"
--   APIRequest "POST" "https://api.twitter.com/1.1/statuses/update.json" [("status","Hello World")]
--   
--   >>> update "Hello World" & #in_reply_to_status_id ?~ 1234567890
--   APIRequest "POST" "https://api.twitter.com/1.1/statuses/update.json" [("in_reply_to_status_id","1234567890"),("status","Hello World")]
--   
update :: Text -> APIRequest StatusesUpdate Status
type StatusesRetweetId = '["trim_user" := Bool]

-- | Returns post data which retweets a tweet, specified by ID.
--   
--   You can perform a search query using call:
--   
--   
--   res <- call twInfo mgr $ retweetId 1234567890
--   
--   
--   
--   >>> retweetId 1234567890
--   APIRequest "POST" "https://api.twitter.com/1.1/statuses/retweet/1234567890.json" []
--   
retweetId :: StatusId -> APIRequest StatusesRetweetId RetweetedStatus
data MediaData
MediaFromFile :: FilePath -> MediaData
MediaRequestBody :: FilePath -> RequestBody -> MediaData
type StatusesUpdateWithMedia = '["possibly_sensitive" := Bool, "in_reply_to_status_id" := Integer, "display_coordinates" := Bool, "tweet_mode" := Text]

-- | Returns post data which updates the authenticating user's current
--   status and attaches media for upload.
--   
--   You can perform a search query using call:
--   
--   
--   res <- call twInfo mgr $ updateWithMedia "Hello World" (MediaFromFile "homethimura/test.jpeg")
--   
--   
--   
--   >>> updateWithMedia "Hello World" (MediaFromFile "/home/fuga/test.jpeg")
--   APIRequestMultipart "POST" "https://api.twitter.com/1.1/statuses/update_with_media.json" [("status","Hello World")]
--   
updateWithMedia :: Text -> MediaData -> APIRequest StatusesUpdateWithMedia Status
type StatusesLookup = '["include_entities" := Bool, "trim_user" := Bool, "map" := Bool, "tweet_mode" := Text]

-- | Returns fully-hydrated tweet objects for up to 100 tweets per request,
--   as specified by comma-separated values passed to the id parameter.
--   
--   You can perform a request using call:
--   
--   
--   res <- call twInfo mgr $ lookup [20, 432656548536401920]
--   
--   
--   
--   >>> lookup [10]
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/lookup.json" [("id","10")]
--   
--   >>> lookup [10, 432656548536401920]
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/lookup.json" [("id","10,432656548536401920")]
--   
--   >>> lookup [10, 432656548536401920] & #include_entities ?~ True
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/lookup.json" [("include_entities","true"),("id","10,432656548536401920")]
--   
lookup :: [StatusId] -> APIRequest StatusesLookup [Status]

module Web.Twitter.Conduit.Api
statusesMentionsTimeline :: APIRequest StatusesMentionsTimeline [Status]
statusesUserTimeline :: UserParam -> APIRequest StatusesUserTimeline [Status]
statusesHomeTimeline :: APIRequest StatusesHomeTimeline [Status]
statusesRetweetsOfMe :: APIRequest StatusesRetweetsOfMe [Status]
statusesRetweetsId :: StatusId -> APIRequest StatusesRetweetsId [RetweetedStatus]
statusesShowId :: StatusId -> APIRequest StatusesShowId Status
statusesDestroyId :: StatusId -> APIRequest StatusesDestroyId Status
statusesUpdate :: Text -> APIRequest StatusesUpdate Status
statusesRetweetId :: StatusId -> APIRequest StatusesRetweetId RetweetedStatus
statusesUpdateWithMedia :: Text -> MediaData -> APIRequest StatusesUpdateWithMedia Status
statusesLookup :: [StatusId] -> APIRequest StatusesLookup [Status]
type SearchTweets = '["lang" := Text, "locale" := Text, "count" := Integer, "until" := Day, "since_id" := Integer, "max_id" := Integer, "include_entities" := Bool]

-- | Returns search query.
--   
--   You can perform a search query using call:
--   
--   
--   res <- call (searchTweets "search text")
--   print $ res ^. searchResultStatuses
--   
--   
--   
--   >>> searchTweets "search text"
--   APIRequest "GET" "https://api.twitter.com/1.1/search/tweets.json" [("q","search text")]
--   
--   >>> searchTweets "search text" & #lang ?~ "ja" & #count ?~ 100
--   APIRequest "GET" "https://api.twitter.com/1.1/search/tweets.json" [("count","100"),("lang","ja"),("q","search text")]
--   
searchTweets :: Text -> APIRequest SearchTweets (SearchResult [Status])

-- | Alias of searchTweets, for backward compatibility

-- | Deprecated: Please use Web.Twitter.Conduit.searchTweets
search :: Text -> APIRequest SearchTweets (SearchResult [Status])
type DirectMessages = '["count" := Integer, "include_entities" := Bool, "skip_status" := Bool, "full_text" := Bool, "cursor" := Text]

-- | Returns query data which asks recent direct messages sent to the
--   authenticating user.
--   
--   You can perform a query using call:
--   
--   
--   res <- call twInfo mgr $ directMessages & #count ?~ 50
--   
--   
--   
--   >>> directMessages
--   APIRequest "GET" "https://api.twitter.com/1.1/direct_messages/events/list.json" []
--   
--   >>> directMessages & #count ?~ 50
--   APIRequest "GET" "https://api.twitter.com/1.1/direct_messages/events/list.json" [("count","50")]
--   
directMessages :: APIRequest DirectMessages (WithCursor Text EventsCursorKey DirectMessage)
type DirectMessagesSent = '["since_id" := Integer, "max_id" := Integer, "count" := Integer, "include_entities" := Bool, "page" := Integer, "skip_status" := Bool, "full_text" := Bool]

-- | Returns query data which asks recent direct messages sent by the
--   authenticating user.
--   
--   You can perform a query using call:
--   
--   
--   res <- call twInfo mgr $ directMessagesSent & #count ?~ 100
--   
--   
--   
--   >>> directMessagesSent
--   APIRequest "GET" "https://api.twitter.com/1.1/direct_messages/sent.json" []
--   
--   >>> directMessagesSent & #count ?~ 100
--   APIRequest "GET" "https://api.twitter.com/1.1/direct_messages/sent.json" [("count","100")]
--   
directMessagesSent :: APIRequest DirectMessagesSent [DirectMessage]
type DirectMessagesShow = '["full_text" := Bool]

-- | Returns query data which asks a single direct message, specified by an
--   id parameter.
--   
--   You can perform a query using call:
--   
--   
--   res <- call twInfo mgr $ directMessagesShow 1234567890
--   
--   
--   
--   >>> directMessagesShow 1234567890
--   APIRequest "GET" "https://api.twitter.com/1.1/direct_messages/show.json" [("id","1234567890")]
--   
directMessagesShow :: StatusId -> APIRequest DirectMessagesShow DirectMessage
type DirectMessagesDestroy = EmptyParams

-- | Returns post data which destroys the direct message specified in the
--   required ID parameter.
--   
--   You can perform a query using call:
--   
--   
--   res <- call twInfo mgr $ directMessagesDestroy 1234567890
--   
--   
--   
--   >>> directMessagesDestroy 1234567890
--   APIRequest "DELETE" "https://api.twitter.com/1.1/direct_messages/events/destroy.json" [("id","1234567890")]
--   
directMessagesDestroy :: StatusId -> APIRequest DirectMessagesDestroy NoContent
type DirectMessagesNew = EmptyParams

-- | Returns post data which sends a new direct message to the specified
--   user from the authenticating user.
--   
--   You can perform a post using call:
--   
--   
--   res <- call twInfo mgr $ directMessagesNew (ScreenNameParam "thimura") "Hello DM"
--   
--   
--   
--   >>> directMessagesNew 69179963 "Hello thimura! by UserId"
--   APIRequestJSON "POST" "https://api.twitter.com/1.1/direct_messages/events/new.json" []
--   
directMessagesNew :: RecipientId -> Text -> APIRequest DirectMessagesNew DirectMessagesNewResponse
type FriendshipsNoRetweetsIds = EmptyParams

-- | Returns a collection of user_ids that the currently authenticated user
--   does not want to receive retweets from.
--   
--   You can perform a request using call:
--   
--   
--   res <- call twInfo mgr $ friendshipsNoRetweetsIds
--   
--   
--   
--   >>> friendshipsNoRetweetsIds
--   APIRequest "GET" "https://api.twitter.com/1.1/friendships/no_retweets/ids.json" []
--   
friendshipsNoRetweetsIds :: APIRequest FriendshipsNoRetweetsIds [UserId]
type FriendsIds = '["count" := Integer, "cursor" := Integer]

-- | Returns query data which asks a collection of user IDs for every user
--   the specified user is following.
--   
--   You can perform a query using call:
--   
--   
--   res <- call twInfo mgr $ friendsIds (ScreenNameParam "thimura")
--   
--   
--   Or, you can iterate with sourceWithCursor:
--   
--   
--   sourceWithCursor (friendsIds (ScreenNameParam "thimura")) $$ CL.consume
--   
--   
--   
--   >>> friendsIds (ScreenNameParam "thimura")
--   APIRequest "GET" "https://api.twitter.com/1.1/friends/ids.json" [("screen_name","thimura")]
--   
--   >>> friendsIds (ScreenNameParam "thimura") & #count ?~ 5000
--   APIRequest "GET" "https://api.twitter.com/1.1/friends/ids.json" [("count","5000"),("screen_name","thimura")]
--   
friendsIds :: UserParam -> APIRequest FriendsIds (WithCursor Integer IdsCursorKey UserId)
type FollowersIds = '["count" := Integer, "cursor" := Integer]

-- | Returns query data which asks a collection of user IDs for every user
--   following the specified user.
--   
--   You can perform a query using call:
--   
--   
--   res <- call twInfo mgr $ followersIds (ScreenNameParam "thimura")
--   
--   
--   Or, you can iterate with sourceWithCursor:
--   
--   
--   sourceWithCursor (followersIds (ScreenNameParam "thimura")) $$ CL.consume
--   
--   
--   
--   >>> followersIds (ScreenNameParam "thimura")
--   APIRequest "GET" "https://api.twitter.com/1.1/followers/ids.json" [("screen_name","thimura")]
--   
--   >>> followersIds (ScreenNameParam "thimura") & #count ?~ 5000
--   APIRequest "GET" "https://api.twitter.com/1.1/followers/ids.json" [("count","5000"),("screen_name","thimura")]
--   
followersIds :: UserParam -> APIRequest FollowersIds (WithCursor Integer IdsCursorKey UserId)
type FriendshipsIncoming = '["cursor" := Integer]

-- | Returns a collection of numeric IDs for every user who has a pending
--   request to follow the authenticating user.
--   
--   You can perform a request by using call:
--   
--   
--   res <- call twInfo mgr $ friendshipsIncoming
--   
--   
--   Or, you can iterate with sourceWithCursor:
--   
--   
--   sourceWithCursor friendshipsIncoming $$ CL.consume
--   
--   
--   
--   >>> friendshipsIncoming
--   APIRequest "GET" "https://api.twitter.com/1.1/friendships/incoming.json" []
--   
friendshipsIncoming :: APIRequest FriendshipsIncoming (WithCursor Integer IdsCursorKey UserId)
type FriendshipsOutgoing = '["cursor" := Integer]

-- | Returns a collection of numeric IDs for every protected user for whom
--   the authenticating user has a pending follow request.
--   
--   You can perform a request by using call:
--   
--   
--   res <- call twInfo mgr $ friendshipsOutgoing
--   
--   
--   Or, you can iterate with sourceWithCursor:
--   
--   
--   sourceWithCursor friendshipsOutgoing $$ CL.consume
--   
--   
--   
--   >>> friendshipsOutgoing
--   APIRequest "GET" "https://api.twitter.com/1.1/friendships/outgoing.json" []
--   
friendshipsOutgoing :: APIRequest FriendshipsOutgoing (WithCursor Integer IdsCursorKey UserId)
type FriendshipsCreate = '["follow" := Bool]

-- | Returns post data which follows the user specified in the ID
--   parameter.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ friendshipsCreate (ScreenNameParam "thimura")
--   
--   
--   
--   >>> friendshipsCreate (ScreenNameParam "thimura")
--   APIRequest "POST" "https://api.twitter.com/1.1/friendships/create.json" [("screen_name","thimura")]
--   
--   >>> friendshipsCreate (UserIdParam 69179963)
--   APIRequest "POST" "https://api.twitter.com/1.1/friendships/create.json" [("user_id","69179963")]
--   
friendshipsCreate :: UserParam -> APIRequest FriendshipsCreate User
type FriendshipsDestroy = EmptyParams

-- | Returns post data which unfollows the user specified in the ID
--   parameter.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ friendshipsDestroy (ScreenNameParam "thimura")
--   
--   
--   
--   >>> friendshipsDestroy (ScreenNameParam "thimura")
--   APIRequest "POST" "https://api.twitter.com/1.1/friendships/destroy.json" [("screen_name","thimura")]
--   
--   >>> friendshipsDestroy (UserIdParam 69179963)
--   APIRequest "POST" "https://api.twitter.com/1.1/friendships/destroy.json" [("user_id","69179963")]
--   
friendshipsDestroy :: UserParam -> APIRequest FriendshipsDestroy User
type FriendsList = '["count" := Integer, "cursor" := Integer, "skip_status" := Bool, "include_user_entities" := Bool]

-- | Returns query data which asks a cursored collection of user objects
--   for every user the specified users is following.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ friendsList (ScreenNameParam "thimura")
--   
--   
--   Or, you can iterate with sourceWithCursor:
--   
--   
--   sourceWithCursor (friendsList (ScreenNameParam "thimura")) $$ CL.consume
--   
--   
--   
--   >>> friendsList (ScreenNameParam "thimura")
--   APIRequest "GET" "https://api.twitter.com/1.1/friends/list.json" [("screen_name","thimura")]
--   
--   >>> friendsList (UserIdParam 69179963)
--   APIRequest "GET" "https://api.twitter.com/1.1/friends/list.json" [("user_id","69179963")]
--   
friendsList :: UserParam -> APIRequest FriendsList (WithCursor Integer UsersCursorKey User)
type FollowersList = '["count" := Integer, "cursor" := Integer, "skip_status" := Bool, "include_user_entities" := Bool]

-- | Returns query data which asks a cursored collection of user objects
--   for users following the specified user.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ followersList (ScreenNameParam "thimura")
--   
--   
--   Or, you can iterate with sourceWithCursor:
--   
--   
--   sourceWithCursor (followersList (ScreenNameParam "thimura")) $$ CL.consume
--   
--   
--   
--   >>> followersList (ScreenNameParam "thimura")
--   APIRequest "GET" "https://api.twitter.com/1.1/followers/list.json" [("screen_name","thimura")]
--   
--   >>> followersList (UserIdParam 69179963)
--   APIRequest "GET" "https://api.twitter.com/1.1/followers/list.json" [("user_id","69179963")]
--   
followersList :: UserParam -> APIRequest FollowersList (WithCursor Integer UsersCursorKey User)
type AccountVerifyCredentials = '["include_entities" := Bool, "skip_status" := Bool, "include_email" := Bool]

-- | Returns query data asks that the credential is valid.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ accountVerifyCredentials
--   
--   
--   
--   >>> accountVerifyCredentials
--   APIRequest "GET" "https://api.twitter.com/1.1/account/verify_credentials.json" []
--   
accountVerifyCredentials :: APIRequest AccountVerifyCredentials User
type AccountUpdateProfile = '["include_entities" := Bool, "skip_status" := Bool, "name" := Text, "url" := URIString, "location" := Text, "description" := Text, "profile_link_color" := Text]

-- | Returns user object with updated fields. Note that while no specific
--   parameter is required, you need to provide at least one parameter
--   before executing the query.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ accountUpdateProfile & #url ?~ "http://www.example.com"
--   
--   
--   
--   >>> accountUpdateProfile & #url ?~ "http://www.example.com"
--   APIRequest "POST" "https://api.twitter.com/1.1/account/update_profile.json" [("url","http://www.example.com")]
--   
accountUpdateProfile :: APIRequest AccountUpdateProfile User
type UsersLookup = '["include_entities" := Bool]

-- | Returns query data asks user objects.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ usersLookup (ScreenNameListParam ["thimura", "twitterapi"])
--   
--   
--   
--   >>> usersLookup (ScreenNameListParam ["thimura", "twitterapi"])
--   APIRequest "GET" "https://api.twitter.com/1.1/users/lookup.json" [("screen_name","thimura,twitterapi")]
--   
usersLookup :: UserListParam -> APIRequest UsersLookup [User]
type UsersShow = '["include_entities" := Bool]

-- | Returns query data asks the user specified by user id or screen name
--   parameter.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ usersShow (ScreenNameParam "thimura")
--   
--   
--   
--   >>> usersShow (ScreenNameParam "thimura")
--   APIRequest "GET" "https://api.twitter.com/1.1/users/show.json" [("screen_name","thimura")]
--   
usersShow :: UserParam -> APIRequest UsersShow User
type FavoritesList = '["count" := Integer, "since_id" := Integer, "max_id" := Integer, "include_entities" := Bool]

-- | Returns the 20 most recent Tweets favorited by the specified user.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ favoritesList (ScreenNameParam "thimura")
--   
--   
--   
--   >>> favoritesList Nothing
--   APIRequest "GET" "https://api.twitter.com/1.1/favorites/list.json" []
--   
--   >>> favoritesList (Just (ScreenNameParam "thimura"))
--   APIRequest "GET" "https://api.twitter.com/1.1/favorites/list.json" [("screen_name","thimura")]
--   
--   >>> favoritesList (Just (UserIdParam 69179963))
--   APIRequest "GET" "https://api.twitter.com/1.1/favorites/list.json" [("user_id","69179963")]
--   
favoritesList :: Maybe UserParam -> APIRequest FavoritesList [Status]
type FavoritesDestroy = '["include_entities" := Bool]

-- | Returns post data unfavorites the status specified in the ID paramter
--   as the authenticating user.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ favoritesDestroy 1234567890
--   
--   
--   
--   >>> favoritesDestroy 1234567890
--   APIRequest "POST" "https://api.twitter.com/1.1/favorites/destroy.json" [("id","1234567890")]
--   
favoritesDestroy :: StatusId -> APIRequest FavoritesDestroy Status
type FavoritesCreate = '["include_entities" := Bool]

-- | Returns post data which favorites the status specified in the ID
--   parameter as the authenticating user.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ favoritesCreate 1234567890
--   
--   
--   
--   >>> favoritesCreate 1234567890
--   APIRequest "POST" "https://api.twitter.com/1.1/favorites/create.json" [("id","1234567890")]
--   
favoritesCreate :: StatusId -> APIRequest FavoritesCreate Status
type ListsStatuses = '["since_id" := Integer, "max_id" := Integer, "count" := Integer, "include_entities" := Bool, "include_rts" := Bool]

-- | Returns the query parameter which fetches a timeline of tweets
--   authored by members of the specified list.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ listsStatuses (ListNameParam "thimura/haskell")
--   
--   
--   If you need more statuses, you can obtain those by using
--   sourceWithMaxId:  res <- sourceWithMaxId
--   (listsStatuses (ListNameParam "thimura/haskell") &
--   #count ?~ 200) $$ CL.take 1000 
--   
--   
--   >>> listsStatuses (ListNameParam "thimura/haskell")
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/statuses.json" [("slug","haskell"),("owner_screen_name","thimura")]
--   
--   >>> listsStatuses (ListIdParam 20849097)
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/statuses.json" [("list_id","20849097")]
--   
listsStatuses :: ListParam -> APIRequest ListsStatuses [Status]
type ListsMembersDestroy = EmptyParams

-- | Returns the post parameter which removes the specified member from the
--   list.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ listsMembersDestroy (ListNameParam "thimura/haskell") (ScreenNameParam "thimura")
--   
--   
--   
--   >>> listsMembersDestroy (ListNameParam "thimura/haskell") (ScreenNameParam "thimura")
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/members/destroy.json" [("slug","haskell"),("owner_screen_name","thimura"),("screen_name","thimura")]
--   
--   >>> listsMembersDestroy (ListIdParam 20849097) (UserIdParam 69179963)
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/members/destroy.json" [("list_id","20849097"),("user_id","69179963")]
--   
listsMembersDestroy :: ListParam -> UserParam -> APIRequest ListsMembersDestroy List
type ListsMemberships = '["count" := Integer, "cursor" := Integer]

-- | Returns the request parameters which asks the lists the specified user
--   has been added to. If UserParam are not provided, the
--   memberships for the authenticating user are returned.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ listsMemberships (ListNameParam "thimura/haskell")
--   
--   
--   
--   >>> listsMemberships Nothing
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/memberships.json" []
--   
--   >>> listsMemberships (Just (ScreenNameParam "thimura"))
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/memberships.json" [("screen_name","thimura")]
--   
--   >>> listsMemberships (Just (UserIdParam 69179963))
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/memberships.json" [("user_id","69179963")]
--   
listsMemberships :: Maybe UserParam -> APIRequest ListsMemberships (WithCursor Integer ListsCursorKey List)
type ListsSubscribers = '["count" := Integer, "cursor" := Integer, "skip_status" := Bool]

-- | Returns the request parameter which asks the subscribers of the
--   specified list.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ listsSubscribers (ListNameParam "thimura/haskell")
--   
--   
--   
--   >>> listsSubscribers (ListNameParam "thimura/haskell")
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/subscribers.json" [("slug","haskell"),("owner_screen_name","thimura")]
--   
--   >>> listsSubscribers (ListIdParam 20849097)
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/subscribers.json" [("list_id","20849097")]
--   
listsSubscribers :: ListParam -> APIRequest ListsSubscribers (WithCursor Integer UsersCursorKey User)
type ListsMembersCreateAll = EmptyParams

-- | Adds multiple members to a list.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ listsMembersCreateAll (ListNameParam "thimura/haskell") (ScreenNameListParam ["thimura", "twitterapi"])
--   
--   
--   
--   >>> listsMembersCreateAll (ListNameParam "thimura/haskell") (ScreenNameListParam ["thimura", "twitterapi"])
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/members/create_all.json" [("slug","haskell"),("owner_screen_name","thimura"),("screen_name","thimura,twitterapi")]
--   
--   >>> listsMembersCreateAll (ListIdParam 20849097) (UserIdListParam [69179963, 6253282])
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/members/create_all.json" [("list_id","20849097"),("user_id","69179963,6253282")]
--   
listsMembersCreateAll :: ListParam -> UserListParam -> APIRequest ListsMembersCreateAll List
type ListsMembers = '["count" := Integer, "cursor" := Integer, "skip_status" := Bool]

-- | Returns query data asks the members of the specified list.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ listsMembers (ListNameParam "thimura/haskell")
--   
--   
--   
--   >>> listsMembers (ListNameParam "thimura/haskell")
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/members.json" [("slug","haskell"),("owner_screen_name","thimura")]
--   
--   >>> listsMembers (ListIdParam 20849097)
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/members.json" [("list_id","20849097")]
--   
listsMembers :: ListParam -> APIRequest ListsMembers (WithCursor Integer UsersCursorKey User)
type ListsMembersCreate = EmptyParams

-- | Returns the post parameter which adds a member to a list.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ listsMembersCreate (ListNameParam "thimura/haskell") (ScreenNameParam "thimura")
--   
--   
--   
--   >>> listsMembersCreate (ListNameParam "thimura/haskell") (ScreenNameParam "thimura")
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/members/create.json" [("slug","haskell"),("owner_screen_name","thimura"),("screen_name","thimura")]
--   
--   >>> listsMembersCreate (ListIdParam 20849097) (UserIdParam 69179963)
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/members/create.json" [("list_id","20849097"),("user_id","69179963")]
--   
listsMembersCreate :: ListParam -> UserParam -> APIRequest ListsMembersCreate List
type ListsDestroy = EmptyParams

-- | Returns the post parameter which deletes the specified list.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ listsDestroy (ListNameParam "thimura/haskell")
--   
--   
--   
--   >>> listsDestroy (ListNameParam "thimura/haskell")
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/destroy.json" [("slug","haskell"),("owner_screen_name","thimura")]
--   
--   >>> listsDestroy (ListIdParam 20849097)
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/destroy.json" [("list_id","20849097")]
--   
listsDestroy :: ListParam -> APIRequest ListsDestroy List
type ListsUpdate = EmptyParams

-- | Returns the post parameter which updates the specified list.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ listsUpdate (ListNameParam "thimura/haskell") True (Just Haskellers)
--   
--   
--   
--   >>> listsUpdate (ListNameParam "thimura/haskell") True (Just "Haskellers")
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/update.json" [("slug","haskell"),("owner_screen_name","thimura"),("description","Haskellers"),("mode","public")]
--   
listsUpdate :: ListParam -> Bool -> Maybe Text -> APIRequest ListsUpdate List
type ListsCreate = EmptyParams

-- | Returns the post parameter which creates a new list for the
--   authenticated user.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ listsCreate (ListNameParam "thimura/haskell")
--   
--   
--   
--   >>> listsCreate "haskell" True Nothing
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/create.json" [("name","haskell"),("mode","public")]
--   
--   >>> listsCreate "haskell" False Nothing
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/create.json" [("name","haskell"),("mode","private")]
--   
--   >>> listsCreate "haskell" True (Just "Haskellers")
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/create.json" [("description","Haskellers"),("name","haskell"),("mode","public")]
--   
listsCreate :: Text -> Bool -> Maybe Text -> APIRequest ListsCreate List
type ListsShow = EmptyParams

-- | Returns the request parameter which asks the specified list.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ listsShow (ListNameParam "thimura/haskell")
--   
--   
--   
--   >>> listsShow (ListNameParam "thimura/haskell")
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/show.json" [("slug","haskell"),("owner_screen_name","thimura")]
--   
--   >>> listsShow (ListIdParam 20849097)
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/show.json" [("list_id","20849097")]
--   
listsShow :: ListParam -> APIRequest ListsShow List
type ListsSubscriptions = '["count" := Integer, "cursor" := Integer]

-- | Returns the request parameter which obtains a collection of the lists
--   the specified user is subscribed to.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ listsSubscriptions (ListNameParam "thimura/haskell")
--   
--   
--   
--   >>> listsSubscriptions Nothing
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/subscriptions.json" []
--   
--   >>> listsSubscriptions (Just (ScreenNameParam "thimura"))
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/subscriptions.json" [("screen_name","thimura")]
--   
--   >>> listsSubscriptions (Just (UserIdParam 69179963))
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/subscriptions.json" [("user_id","69179963")]
--   
listsSubscriptions :: Maybe UserParam -> APIRequest ListsSubscriptions (WithCursor Integer ListsCursorKey List)
type ListsMembersDestroyAll = EmptyParams

-- | Adds multiple members to a list.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ listsMembersDestroyAll (ListNameParam "thimura/haskell") (ScreenNameListParam ["thimura", "twitterapi"])
--   
--   
--   
--   >>> listsMembersDestroyAll (ListNameParam "thimura/haskell") (ScreenNameListParam ["thimura", "twitterapi"])
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/members/destroy_all.json" [("slug","haskell"),("owner_screen_name","thimura"),("screen_name","thimura,twitterapi")]
--   
--   >>> listsMembersDestroyAll (ListIdParam 20849097) (UserIdListParam [69179963, 6253282])
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/members/destroy_all.json" [("list_id","20849097"),("user_id","69179963,6253282")]
--   
listsMembersDestroyAll :: ListParam -> UserListParam -> APIRequest ListsMembersDestroyAll List
type ListsOwnerships = '["count" := Integer, "cursor" := Integer]

-- | Returns the request parameter which asks the lists owned by the
--   specified Twitter user.
--   
--   You can perform request by using call:
--   
--   
--   res <- call twInfo mgr $ listsOwnerships (ListNameParam "thimura/haskell")
--   
--   
--   
--   >>> listsOwnerships Nothing
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/ownerships.json" []
--   
--   >>> listsOwnerships (Just (ScreenNameParam "thimura"))
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/ownerships.json" [("screen_name","thimura")]
--   
--   >>> listsOwnerships (Just (UserIdParam 69179963))
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/ownerships.json" [("user_id","69179963")]
--   
listsOwnerships :: Maybe UserParam -> APIRequest ListsOwnerships (WithCursor Integer ListsCursorKey List)
type MediaUpload = EmptyParams

-- | Upload media and returns the media data.
--   
--   You can update your status with multiple media by calling
--   mediaUpload and update successively.
--   
--   First, you should upload media with mediaUpload:
--   
--   
--   res1 <- call twInfo mgr $ mediaUpload (MediaFromFile "/path/to/upload/file1.png")
--   res2 <- call twInfo mgr $ mediaUpload (MediaRequestBody "file2.png" "[.. file body ..]")
--   
--   
--   and then collect the resulting media IDs and update your status by
--   calling update:
--   
--   
--   call twInfo mgr $ update "Hello World" & #media_ids ?~ [uploadedMediaId res1, uploadedMediaId res2]
--   
--   
--   See:
--   https://dev.twitter.com/docs/api/multiple-media-extended-entities
--   
--   
--   >>> mediaUpload (MediaFromFile "/home/test/test.png")
--   APIRequestMultipart "POST" "https://upload.twitter.com/1.1/media/upload.json" []
--   
mediaUpload :: MediaData -> APIRequest MediaUpload UploadedMedia
instance GHC.Classes.Eq Web.Twitter.Conduit.Api.DirectMessagesNewResponse
instance GHC.Show.Show Web.Twitter.Conduit.Api.DirectMessagesNewResponse
instance Data.Aeson.Types.FromJSON.FromJSON Web.Twitter.Conduit.Api.DirectMessagesNewResponse

-- | A client library for Twitter APIs (see
--   https://dev.twitter.com/).
module Web.Twitter.Conduit

-- | Perform an APIRequest and then provide the response which is
--   mapped to a suitable type of twitter-types.
--   
--   Example:
--   
--   
--   user <- call twInfo mgr $ accountVerifyCredentials
--   print user
--   
--   
--   If you need raw JSON value which is parsed by aeson, use
--   call' to obtain it.
call :: ResponseBodyType responseType => TWInfo -> Manager -> APIRequest apiName responseType -> IO responseType

-- | Perform an APIRequest and then provide the response. The
--   response of this function is not restrict to responseType, so
--   you can choose an arbitrarily type of FromJSON instances.
call' :: ResponseBodyType value => TWInfo -> Manager -> APIRequest apiName responseType -> IO value

-- | Perform an APIRequest and then provide the Response.
--   
--   Example:
--   
--   
--   res <- callWithResponse twInfo mgr $ accountVerifyCredentials
--   print $ responseStatus res
--   print $ responseHeaders res
--   print $ responseBody res
--   
callWithResponse :: ResponseBodyType responseType => TWInfo -> Manager -> APIRequest apiName responseType -> IO (Response responseType)

-- | Perform an APIRequest and then provide the Response. The
--   response of this function is not restrict to responseType, so
--   you can choose an arbitrarily type of FromJSON instances.
--   
--   Example:
--   
--   
--   res <- callWithResponse' twInfo mgr $ accountVerifyCredentials
--   print $ responseStatus res
--   print $ responseHeaders res
--   print $ responseBody (res :: Value)
--   
callWithResponse' :: ResponseBodyType value => TWInfo -> Manager -> APIRequest apiName responseType -> IO (Response value)

-- | A wrapper function to perform multiple API request with changing
--   max_id parameter.
--   
--   This function cooperate with instances of HasMaxIdParam.
sourceWithMaxId :: (MonadIO m, FromJSON responseType, AsStatus responseType, HasParam "max_id" Integer supports) => TWInfo -> Manager -> APIRequest supports [responseType] -> ConduitT () responseType m ()

-- | A wrapper function to perform multiple API request with changing
--   max_id parameter. The response of this function is not
--   restrict to responseType, so you can choose an arbitrarily
--   type of FromJSON instances.
--   
--   This function cooperate with instances of HasMaxIdParam.
sourceWithMaxId' :: (MonadIO m, HasParam "max_id" Integer supports) => TWInfo -> Manager -> APIRequest supports [responseType] -> ConduitT () Value m ()

-- | A wrapper function to perform multiple API request with changing
--   cursor parameter.
--   
--   This function cooperate with instances of HasCursorParam.
sourceWithCursor :: (MonadIO m, FromJSON responseType, CursorKey ck, HasParam "cursor" Integer supports) => TWInfo -> Manager -> APIRequest supports (WithCursor Integer ck responseType) -> ConduitT () responseType m ()

-- | A wrapper function to perform multiple API request with changing
--   cursor parameter. The response of this function is not
--   restrict to responseType, so you can choose an arbitrarily
--   type of FromJSON instances.
--   
--   This function cooperate with instances of HasCursorParam.
sourceWithCursor' :: (MonadIO m, CursorKey ck, HasParam "cursor" Integer supports) => TWInfo -> Manager -> APIRequest supports (WithCursor Integer ck responseType) -> ConduitT () Value m ()

-- | A wrapper function to perform multiple API request with
--   SearchResult.
sourceWithSearchResult :: (MonadIO m, FromJSON responseType) => TWInfo -> Manager -> APIRequest supports (SearchResult [responseType]) -> m (SearchResult (ConduitT () responseType m ()))

-- | A wrapper function to perform multiple API request with
--   SearchResult.
sourceWithSearchResult' :: MonadIO m => TWInfo -> Manager -> APIRequest supports (SearchResult [responseType]) -> m (SearchResult (ConduitT () Value m ()))
data ListParam
ListIdParam :: Integer -> ListParam
ListNameParam :: String -> ListParam
data MediaData
MediaFromFile :: FilePath -> MediaData
MediaRequestBody :: FilePath -> RequestBody -> MediaData
data UserListParam
UserIdListParam :: [UserId] -> UserListParam
ScreenNameListParam :: [String] -> UserListParam
data UserParam
UserIdParam :: UserId -> UserParam
ScreenNameParam :: String -> UserParam

-- | Data type for OAuth client (consumer).
--   
--   The constructor for this data type is not exposed. Instead, you should
--   use the def method or newOAuth function to retrieve a
--   default instance, and then use the records below to make
--   modifications. This approach allows us to add configuration options
--   without breaking backwards compatibility.
data OAuth

-- | Data type for credential.
newtype Credential
Credential :: [(ByteString, ByteString)] -> Credential
[unCredential] :: Credential -> [(ByteString, ByteString)]
def :: Default a => a

-- | Keeps track of open connections for keep-alive.
--   
--   If possible, you should share a single Manager between multiple
--   threads and requests.
--   
--   Since 0.1.0
data Manager

-- | Create a Manager. The Manager will be shut down
--   automatically via garbage collection.
--   
--   Creating a new Manager is a relatively expensive operation, you
--   are advised to share a single Manager between requests instead.
--   
--   The first argument to this function is often
--   defaultManagerSettings, though add-on libraries may provide a
--   recommended replacement.
--   
--   Since 0.1.0
newManager :: ManagerSettings -> IO Manager
tlsManagerSettings :: ManagerSettings
