-- 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
--   <a>https://dev.twitter.com/</a>).
--   
--   This package uses the http-conduit package for accessing the Twitter
--   API (see <a>http://hackage.haskell.org/package/http-conduit</a>). This
--   package also depends on the twitter-types package (see
--   <a>http://hackage.haskell.org/package/twitter-types</a>).
--   
--   You can find basic examples in the
--   <a>https://github.com/himura/twitter-conduit/tree/master/sample</a>
--   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 <a>WithCursor</a> specifies the field name
--   of contents.
--   
--   <pre>
--   &gt;&gt;&gt; let Just res = decode "{\"previous_cursor\": 0, \"next_cursor\": 1234567890, \"ids\": [1111111111]}" :: Maybe (WithCursor Integer IdsCursorKey UserId)
--   
--   &gt;&gt;&gt; nextCursor res
--   Just 1234567890
--   
--   &gt;&gt;&gt; contents res
--   [1111111111]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let Just res = decode "{\"previous_cursor\": 0, \"next_cursor\": 0, \"users\": [1000]}" :: Maybe (WithCursor Integer UsersCursorKey UserId)
--   
--   &gt;&gt;&gt; nextCursor res
--   Just 0
--   
--   &gt;&gt;&gt; contents res
--   [1000]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let Just res = decode "{\"next_cursor\": \"hogehoge\", \"events\": [1000]}" :: Maybe (WithCursor Text EventsCursorKey UserId)
--   
--   &gt;&gt;&gt; nextCursor res
--   Just "hogehoge"
--   
--   &gt;&gt;&gt; contents res
--   [1000]
--   </pre>
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 <tt>SampleApi</tt> type and a builder
--   function which named <tt>sampleApiRequest</tt>.
--   
--   <pre>
--   type SampleId = <a>Integer</a>
--   sampleApiRequest :: <a>APIRequest</a> SampleApi [SampleId]
--   sampleApiRequest = <a>APIRequest</a> "GET" "https://api.twitter.com/sample/api.json" []
--   type SampleApi = '[ "count" ':= Integer
--                     , "max_id" ':= Integer
--                     ]
--   </pre>
--   
--   We can obtain request params from <tt><a>APIRequest</a> SampleApi
--   [SampleId]</tt> :
--   
--   <pre>
--   &gt;&gt;&gt; sampleApiRequest ^. params
--   []
--   </pre>
--   
--   The second type parameter of the APIRequest represents the allowed
--   parameters for the APIRequest. For example, <tt>sampleApiRequest</tt>
--   has 2 <tt>Integer</tt> parameters, that is "count" and "max_id". You
--   can update those parameters by label lenses (<tt>#count</tt> and
--   <tt>#max_id</tt> respectively)
--   
--   <pre>
--   &gt;&gt;&gt; (sampleApiRequest &amp; #count ?~ 100 &amp; #max_id ?~ 1234567890) ^. params
--   [("max_id",PVInteger {unPVInteger = 1234567890}),("count",PVInteger {unPVInteger = 100})]
--   
--   &gt;&gt;&gt; (sampleApiRequest &amp; #count ?~ 100 &amp; #max_id ?~ 1234567890 &amp; #count .~ Nothing) ^. params
--   [("max_id",PVInteger {unPVInteger = 1234567890})]
--   </pre>
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 <a>UserParam</a> to <a>SimpleQuery</a>.
--   
--   <pre>
--   &gt;&gt;&gt; makeSimpleQuery . mkUserParam $ UserIdParam 123456
--   [("user_id","123456")]
--   
--   &gt;&gt;&gt; makeSimpleQuery . mkUserParam $ ScreenNameParam "thimura"
--   [("screen_name","thimura")]
--   </pre>
mkUserParam :: UserParam -> APIQuery

-- | converts <a>UserListParam</a> to <a>SimpleQuery</a>.
--   
--   <pre>
--   &gt;&gt;&gt; makeSimpleQuery . mkUserListParam $ UserIdListParam [123456]
--   [("user_id","123456")]
--   
--   &gt;&gt;&gt; makeSimpleQuery . mkUserListParam $ UserIdListParam [123456, 654321]
--   [("user_id","123456,654321")]
--   
--   &gt;&gt;&gt; makeSimpleQuery . mkUserListParam $ ScreenNameListParam ["thimura", "NikaidouShinku"]
--   [("screen_name","thimura,NikaidouShinku")]
--   </pre>
mkUserListParam :: UserListParam -> APIQuery

-- | converts <a>ListParam</a> to <a>SimpleQuery</a>.
--   
--   <pre>
--   &gt;&gt;&gt; makeSimpleQuery . mkListParam $ ListIdParam 123123
--   [("list_id","123123")]
--   
--   &gt;&gt;&gt; makeSimpleQuery . mkListParam $ ListNameParam "thimura/haskell"
--   [("slug","haskell"),("owner_screen_name","thimura")]
--   </pre>
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: <a>https://dev.twitter.com/docs/error-codes-responses</a>
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: <a>https://dev.twitter.com/docs/error-codes-responses</a>
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 <a>WithCursor</a> specifies the field name
--   of contents.
--   
--   <pre>
--   &gt;&gt;&gt; let Just res = decode "{\"previous_cursor\": 0, \"next_cursor\": 1234567890, \"ids\": [1111111111]}" :: Maybe (WithCursor Integer IdsCursorKey UserId)
--   
--   &gt;&gt;&gt; nextCursor res
--   Just 1234567890
--   
--   &gt;&gt;&gt; contents res
--   [1111111111]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let Just res = decode "{\"previous_cursor\": 0, \"next_cursor\": 0, \"users\": [1000]}" :: Maybe (WithCursor Integer UsersCursorKey UserId)
--   
--   &gt;&gt;&gt; nextCursor res
--   Just 0
--   
--   &gt;&gt;&gt; contents res
--   [1000]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; let Just res = decode "{\"next_cursor\": \"hogehoge\", \"events\": [1000]}" :: Maybe (WithCursor Text EventsCursorKey UserId)
--   
--   &gt;&gt;&gt; nextCursor res
--   Just "hogehoge"
--   
--   &gt;&gt;&gt; contents res
--   [1000]
--   </pre>
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.
--   
--   <pre>
--   &gt;&gt;&gt; let proxy = Proxy "localhost" 8080
--   
--   &gt;&gt;&gt; let twinfo = def { twProxy = Just proxy }
--   
--   &gt;&gt;&gt; let oauth = twitterOAuth { oauthConsumerKey = "consumer_key", oauthConsumerSecret = "consumer_secret" }
--   
--   &gt;&gt;&gt; let credential = Credential [("oauth_token","...")]
--   
--   &gt;&gt;&gt; let twinfo2 = setCredential oauth credential twinfo
--   
--   &gt;&gt;&gt; oauthConsumerKey . twOAuth . twToken $ twinfo2
--   "consumer_key"
--   
--   &gt;&gt;&gt; twProxy twinfo2 == Just proxy
--   True
--   </pre>
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 <a>APIRequest</a> and then provide the response which is
--   mapped to a suitable type of <a>twitter-types</a>.
--   
--   Example:
--   
--   <pre>
--   user &lt;- <a>call</a> twInfo mgr $ <tt>accountVerifyCredentials</tt>
--   print user
--   </pre>
--   
--   If you need raw JSON value which is parsed by <a>aeson</a>, use
--   <a>call'</a> to obtain it.
call :: ResponseBodyType responseType => TWInfo -> Manager -> APIRequest apiName responseType -> IO responseType

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

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

-- | Perform an <a>APIRequest</a> and then provide the <a>Response</a>. The
--   response of this function is not restrict to <tt>responseType</tt>, so
--   you can choose an arbitrarily type of FromJSON instances.
--   
--   Example:
--   
--   <pre>
--   res &lt;- <a>callWithResponse'</a> twInfo mgr $ <tt>accountVerifyCredentials</tt>
--   <a>print</a> $ <a>responseStatus</a> res
--   <a>print</a> $ <a>responseHeaders</a> res
--   <a>print</a> $ <a>responseBody</a> (res :: Value)
--   </pre>
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
--   <tt>max_id</tt> parameter.
--   
--   This function cooperate with instances of <tt>HasMaxIdParam</tt>.
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
--   <tt>max_id</tt> parameter. The response of this function is not
--   restrict to <tt>responseType</tt>, so you can choose an arbitrarily
--   type of FromJSON instances.
--   
--   This function cooperate with instances of <tt>HasMaxIdParam</tt>.
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
--   <tt>cursor</tt> parameter.
--   
--   This function cooperate with instances of <tt>HasCursorParam</tt>.
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
--   <tt>cursor</tt> parameter. The response of this function is not
--   restrict to <tt>responseType</tt>, so you can choose an arbitrarily
--   type of FromJSON instances.
--   
--   This function cooperate with instances of <tt>HasCursorParam</tt>.
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
--   <tt>SearchResult</tt>.
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
--   <tt>SearchResult</tt>.
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.
--   
--   <pre>
--   &gt;&gt;&gt; statusesFilter [Follow [1,2,3]]
--   APIRequest "POST" "https://stream.twitter.com/1.1/statuses/filter.json" [("follow","1,2,3")]
--   
--   &gt;&gt;&gt; statusesFilter [Track ["haskell","functional"]]
--   APIRequest "POST" "https://stream.twitter.com/1.1/statuses/filter.json" [("track","haskell,functional")]
--   
--   &gt;&gt;&gt; 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")]
--   </pre>
statusesFilter :: [FilterParameter] -> APIRequest StatusesFilter StreamingAPI

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

-- | Returns statuses/filter.json API query data.
--   
--   <pre>
--   &gt;&gt;&gt; statusesFilterByTrack "haskell"
--   APIRequest "POST" "https://stream.twitter.com/1.1/statuses/filter.json" [("track","haskell")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> <a>mentionsTimeline</a>
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; mentionsTimeline
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/mentions_timeline.json" []
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> $ <a>userTimeline</a> (<a>ScreenNameParam</a> "thimura")
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; userTimeline (ScreenNameParam "thimura")
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/user_timeline.json" [("screen_name","thimura")]
--   
--   &gt;&gt;&gt; userTimeline (ScreenNameParam "thimura") &amp; #include_rts ?~ True &amp; #count ?~ 200
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/user_timeline.json" [("count","200"),("include_rts","true"),("screen_name","thimura")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> <a>homeTimeline</a>
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; homeTimeline
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/home_timeline.json" []
--   
--   &gt;&gt;&gt; homeTimeline &amp; #count ?~ 200
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/home_timeline.json" [("count","200")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> <a>retweetsOfMe</a>
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; retweetsOfMe
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/retweets_of_me.json" []
--   
--   &gt;&gt;&gt; retweetsOfMe &amp; #count ?~ 100
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/retweets_of_me.json" [("count","100")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>retweetsId</a> 1234567890
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; retweetsId 1234567890
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/retweets/1234567890.json" []
--   
--   &gt;&gt;&gt; retweetsId 1234567890 &amp; #count ?~ 100
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/retweets/1234567890.json" [("count","100")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>showId</a> 1234567890
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; showId 1234567890
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/show/1234567890.json" []
--   
--   &gt;&gt;&gt; showId 1234567890 &amp; #include_my_retweet ?~ True
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/show/1234567890.json" [("include_my_retweet","true")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>destroyId</a> 1234567890
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; destroyId 1234567890
--   APIRequest "POST" "https://api.twitter.com/1.1/statuses/destroy/1234567890.json" []
--   </pre>
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
--   <a>updateWithMedia</a>.
--   
--   You can perform a search query using <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>update</a> "Hello World"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; update "Hello World"
--   APIRequest "POST" "https://api.twitter.com/1.1/statuses/update.json" [("status","Hello World")]
--   
--   &gt;&gt;&gt; update "Hello World" &amp; #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")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>retweetId</a> 1234567890
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; retweetId 1234567890
--   APIRequest "POST" "https://api.twitter.com/1.1/statuses/retweet/1234567890.json" []
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>updateWithMedia</a> "Hello World" (<a>MediaFromFile</a> "<i>home</i>thimura/test.jpeg")
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; updateWithMedia "Hello World" (MediaFromFile "/home/fuga/test.jpeg")
--   APIRequestMultipart "POST" "https://api.twitter.com/1.1/statuses/update_with_media.json" [("status","Hello World")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>lookup</a> [20, 432656548536401920]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lookup [10]
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/lookup.json" [("id","10")]
--   
--   &gt;&gt;&gt; lookup [10, 432656548536401920]
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/lookup.json" [("id","10,432656548536401920")]
--   
--   &gt;&gt;&gt; lookup [10, 432656548536401920] &amp; #include_entities ?~ True
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/lookup.json" [("include_entities","true"),("id","10,432656548536401920")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> (<a>searchTweets</a> "search text")
--   <a>print</a> $ res ^. <a>searchResultStatuses</a>
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; searchTweets "search text"
--   APIRequest "GET" "https://api.twitter.com/1.1/search/tweets.json" [("q","search text")]
--   
--   &gt;&gt;&gt; searchTweets "search text" &amp; #lang ?~ "ja" &amp; #count ?~ 100
--   APIRequest "GET" "https://api.twitter.com/1.1/search/tweets.json" [("count","100"),("lang","ja"),("q","search text")]
--   </pre>
searchTweets :: Text -> APIRequest SearchTweets (SearchResult [Status])

-- | Alias of <a>searchTweets</a>, for backward compatibility

-- | <i>Deprecated: Please use Web.Twitter.Conduit.searchTweets</i>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>directMessages</a> <tt>&amp;</tt> #count <tt>?~</tt> 50
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; directMessages
--   APIRequest "GET" "https://api.twitter.com/1.1/direct_messages/events/list.json" []
--   
--   &gt;&gt;&gt; directMessages &amp; #count ?~ 50
--   APIRequest "GET" "https://api.twitter.com/1.1/direct_messages/events/list.json" [("count","50")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>directMessagesSent</a> <tt>&amp;</tt> #count <tt>?~</tt> 100
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; directMessagesSent
--   APIRequest "GET" "https://api.twitter.com/1.1/direct_messages/sent.json" []
--   
--   &gt;&gt;&gt; directMessagesSent &amp; #count ?~ 100
--   APIRequest "GET" "https://api.twitter.com/1.1/direct_messages/sent.json" [("count","100")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>directMessagesShow</a> 1234567890
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; directMessagesShow 1234567890
--   APIRequest "GET" "https://api.twitter.com/1.1/direct_messages/show.json" [("id","1234567890")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>directMessagesDestroy</a> 1234567890
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; directMessagesDestroy 1234567890
--   APIRequest "DELETE" "https://api.twitter.com/1.1/direct_messages/events/destroy.json" [("id","1234567890")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>directMessagesNew</a> (ScreenNameParam "thimura") "Hello DM"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; directMessagesNew 69179963 "Hello thimura! by UserId"
--   APIRequestJSON "POST" "https://api.twitter.com/1.1/direct_messages/events/new.json" []
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>friendshipsNoRetweetsIds</a>
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; friendshipsNoRetweetsIds
--   APIRequest "GET" "https://api.twitter.com/1.1/friendships/no_retweets/ids.json" []
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>friendsIds</a> (<a>ScreenNameParam</a> "thimura")
--   </pre>
--   
--   Or, you can iterate with <a>sourceWithCursor</a>:
--   
--   <pre>
--   <a>sourceWithCursor</a> (<a>friendsIds</a> (<a>ScreenNameParam</a> "thimura")) $$ CL.consume
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; friendsIds (ScreenNameParam "thimura")
--   APIRequest "GET" "https://api.twitter.com/1.1/friends/ids.json" [("screen_name","thimura")]
--   
--   &gt;&gt;&gt; friendsIds (ScreenNameParam "thimura") &amp; #count ?~ 5000
--   APIRequest "GET" "https://api.twitter.com/1.1/friends/ids.json" [("count","5000"),("screen_name","thimura")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>followersIds</a> (<a>ScreenNameParam</a> "thimura")
--   </pre>
--   
--   Or, you can iterate with <a>sourceWithCursor</a>:
--   
--   <pre>
--   <a>sourceWithCursor</a> (<a>followersIds</a> (<a>ScreenNameParam</a> "thimura")) $$ CL.consume
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; followersIds (ScreenNameParam "thimura")
--   APIRequest "GET" "https://api.twitter.com/1.1/followers/ids.json" [("screen_name","thimura")]
--   
--   &gt;&gt;&gt; followersIds (ScreenNameParam "thimura") &amp; #count ?~ 5000
--   APIRequest "GET" "https://api.twitter.com/1.1/followers/ids.json" [("count","5000"),("screen_name","thimura")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>friendshipsIncoming</a>
--   </pre>
--   
--   Or, you can iterate with <a>sourceWithCursor</a>:
--   
--   <pre>
--   <a>sourceWithCursor</a> <a>friendshipsIncoming</a> $$ CL.consume
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; friendshipsIncoming
--   APIRequest "GET" "https://api.twitter.com/1.1/friendships/incoming.json" []
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>friendshipsOutgoing</a>
--   </pre>
--   
--   Or, you can iterate with <a>sourceWithCursor</a>:
--   
--   <pre>
--   <a>sourceWithCursor</a> <a>friendshipsOutgoing</a> $$ CL.consume
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; friendshipsOutgoing
--   APIRequest "GET" "https://api.twitter.com/1.1/friendships/outgoing.json" []
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>friendshipsCreate</a> (<a>ScreenNameParam</a> "thimura")
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; friendshipsCreate (ScreenNameParam "thimura")
--   APIRequest "POST" "https://api.twitter.com/1.1/friendships/create.json" [("screen_name","thimura")]
--   
--   &gt;&gt;&gt; friendshipsCreate (UserIdParam 69179963)
--   APIRequest "POST" "https://api.twitter.com/1.1/friendships/create.json" [("user_id","69179963")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>friendshipsDestroy</a> (<a>ScreenNameParam</a> "thimura")
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; friendshipsDestroy (ScreenNameParam "thimura")
--   APIRequest "POST" "https://api.twitter.com/1.1/friendships/destroy.json" [("screen_name","thimura")]
--   
--   &gt;&gt;&gt; friendshipsDestroy (UserIdParam 69179963)
--   APIRequest "POST" "https://api.twitter.com/1.1/friendships/destroy.json" [("user_id","69179963")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>friendsList</a> (<a>ScreenNameParam</a> "thimura")
--   </pre>
--   
--   Or, you can iterate with <a>sourceWithCursor</a>:
--   
--   <pre>
--   <a>sourceWithCursor</a> (<a>friendsList</a> (<a>ScreenNameParam</a> "thimura")) $$ CL.consume
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; friendsList (ScreenNameParam "thimura")
--   APIRequest "GET" "https://api.twitter.com/1.1/friends/list.json" [("screen_name","thimura")]
--   
--   &gt;&gt;&gt; friendsList (UserIdParam 69179963)
--   APIRequest "GET" "https://api.twitter.com/1.1/friends/list.json" [("user_id","69179963")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>followersList</a> (<a>ScreenNameParam</a> "thimura")
--   </pre>
--   
--   Or, you can iterate with <a>sourceWithCursor</a>:
--   
--   <pre>
--   <a>sourceWithCursor</a> (<a>followersList</a> (<a>ScreenNameParam</a> "thimura")) $$ CL.consume
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; followersList (ScreenNameParam "thimura")
--   APIRequest "GET" "https://api.twitter.com/1.1/followers/list.json" [("screen_name","thimura")]
--   
--   &gt;&gt;&gt; followersList (UserIdParam 69179963)
--   APIRequest "GET" "https://api.twitter.com/1.1/followers/list.json" [("user_id","69179963")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>accountVerifyCredentials</a>
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; accountVerifyCredentials
--   APIRequest "GET" "https://api.twitter.com/1.1/account/verify_credentials.json" []
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>accountUpdateProfile</a> &amp; #url ?~ "http://www.example.com"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; accountUpdateProfile &amp; #url ?~ "http://www.example.com"
--   APIRequest "POST" "https://api.twitter.com/1.1/account/update_profile.json" [("url","http://www.example.com")]
--   </pre>
accountUpdateProfile :: APIRequest AccountUpdateProfile User
type UsersLookup = '["include_entities" := Bool]

-- | Returns query data asks user objects.
--   
--   You can perform request by using <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>usersLookup</a> (<a>ScreenNameListParam</a> ["thimura", "twitterapi"])
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; usersLookup (ScreenNameListParam ["thimura", "twitterapi"])
--   APIRequest "GET" "https://api.twitter.com/1.1/users/lookup.json" [("screen_name","thimura,twitterapi")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>usersShow</a> (<a>ScreenNameParam</a> "thimura")
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; usersShow (ScreenNameParam "thimura")
--   APIRequest "GET" "https://api.twitter.com/1.1/users/show.json" [("screen_name","thimura")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>favoritesList</a> (ScreenNameParam "thimura")
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; favoritesList Nothing
--   APIRequest "GET" "https://api.twitter.com/1.1/favorites/list.json" []
--   
--   &gt;&gt;&gt; favoritesList (Just (ScreenNameParam "thimura"))
--   APIRequest "GET" "https://api.twitter.com/1.1/favorites/list.json" [("screen_name","thimura")]
--   
--   &gt;&gt;&gt; favoritesList (Just (UserIdParam 69179963))
--   APIRequest "GET" "https://api.twitter.com/1.1/favorites/list.json" [("user_id","69179963")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>favoritesDestroy</a> 1234567890
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; favoritesDestroy 1234567890
--   APIRequest "POST" "https://api.twitter.com/1.1/favorites/destroy.json" [("id","1234567890")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>favoritesCreate</a> 1234567890
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; favoritesCreate 1234567890
--   APIRequest "POST" "https://api.twitter.com/1.1/favorites/create.json" [("id","1234567890")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>listsStatuses</a> (<a>ListNameParam</a> "thimura/haskell")
--   </pre>
--   
--   If you need more statuses, you can obtain those by using
--   <a>sourceWithMaxId</a>: <tt> res &lt;- sourceWithMaxId
--   (<a>listsStatuses</a> (<a>ListNameParam</a> "thimura/haskell") &amp;
--   #count ?~ 200) $$ CL.take 1000 </tt>
--   
--   <pre>
--   &gt;&gt;&gt; listsStatuses (ListNameParam "thimura/haskell")
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/statuses.json" [("slug","haskell"),("owner_screen_name","thimura")]
--   
--   &gt;&gt;&gt; listsStatuses (ListIdParam 20849097)
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/statuses.json" [("list_id","20849097")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>listsMembersDestroy</a> (<a>ListNameParam</a> "thimura/haskell") (<a>ScreenNameParam</a> "thimura")
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; 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")]
--   
--   &gt;&gt;&gt; listsMembersDestroy (ListIdParam 20849097) (UserIdParam 69179963)
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/members/destroy.json" [("list_id","20849097"),("user_id","69179963")]
--   </pre>
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 <a>UserParam</a> are not provided, the
--   memberships for the authenticating user are returned.
--   
--   You can perform request by using <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>listsMemberships</a> (<a>ListNameParam</a> "thimura/haskell")
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; listsMemberships Nothing
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/memberships.json" []
--   
--   &gt;&gt;&gt; listsMemberships (Just (ScreenNameParam "thimura"))
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/memberships.json" [("screen_name","thimura")]
--   
--   &gt;&gt;&gt; listsMemberships (Just (UserIdParam 69179963))
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/memberships.json" [("user_id","69179963")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>listsSubscribers</a> (<a>ListNameParam</a> "thimura/haskell")
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; listsSubscribers (ListNameParam "thimura/haskell")
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/subscribers.json" [("slug","haskell"),("owner_screen_name","thimura")]
--   
--   &gt;&gt;&gt; listsSubscribers (ListIdParam 20849097)
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/subscribers.json" [("list_id","20849097")]
--   </pre>
listsSubscribers :: ListParam -> APIRequest ListsSubscribers (WithCursor Integer UsersCursorKey User)
type ListsMembersCreateAll = EmptyParams

-- | Adds multiple members to a list.
--   
--   You can perform request by using <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>listsMembersCreateAll</a> (<a>ListNameParam</a> "thimura/haskell") (<a>ScreenNameListParam</a> ["thimura", "twitterapi"])
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; 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")]
--   
--   &gt;&gt;&gt; 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")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>listsMembers</a> (<a>ListNameParam</a> "thimura/haskell")
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; listsMembers (ListNameParam "thimura/haskell")
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/members.json" [("slug","haskell"),("owner_screen_name","thimura")]
--   
--   &gt;&gt;&gt; listsMembers (ListIdParam 20849097)
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/members.json" [("list_id","20849097")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>listsMembersCreate</a> (<a>ListNameParam</a> "thimura/haskell") (<a>ScreenNameParam</a> "thimura")
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; 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")]
--   
--   &gt;&gt;&gt; listsMembersCreate (ListIdParam 20849097) (UserIdParam 69179963)
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/members/create.json" [("list_id","20849097"),("user_id","69179963")]
--   </pre>
listsMembersCreate :: ListParam -> UserParam -> APIRequest ListsMembersCreate List
type ListsDestroy = EmptyParams

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

-- | Returns the post parameter which updates the specified list.
--   
--   You can perform request by using <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>listsUpdate</a> (<a>ListNameParam</a> "thimura/haskell") True (Just <a>Haskellers</a>)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; 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")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>listsCreate</a> (<a>ListNameParam</a> "thimura/haskell")
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; listsCreate "haskell" True Nothing
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/create.json" [("name","haskell"),("mode","public")]
--   
--   &gt;&gt;&gt; listsCreate "haskell" False Nothing
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/create.json" [("name","haskell"),("mode","private")]
--   
--   &gt;&gt;&gt; listsCreate "haskell" True (Just "Haskellers")
--   APIRequest "POST" "https://api.twitter.com/1.1/lists/create.json" [("description","Haskellers"),("name","haskell"),("mode","public")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>listsShow</a> (<a>ListNameParam</a> "thimura/haskell")
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; listsShow (ListNameParam "thimura/haskell")
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/show.json" [("slug","haskell"),("owner_screen_name","thimura")]
--   
--   &gt;&gt;&gt; listsShow (ListIdParam 20849097)
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/show.json" [("list_id","20849097")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>listsSubscriptions</a> (<a>ListNameParam</a> "thimura/haskell")
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; listsSubscriptions Nothing
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/subscriptions.json" []
--   
--   &gt;&gt;&gt; listsSubscriptions (Just (ScreenNameParam "thimura"))
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/subscriptions.json" [("screen_name","thimura")]
--   
--   &gt;&gt;&gt; listsSubscriptions (Just (UserIdParam 69179963))
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/subscriptions.json" [("user_id","69179963")]
--   </pre>
listsSubscriptions :: Maybe UserParam -> APIRequest ListsSubscriptions (WithCursor Integer ListsCursorKey List)
type ListsMembersDestroyAll = EmptyParams

-- | Adds multiple members to a list.
--   
--   You can perform request by using <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>listsMembersDestroyAll</a> (<a>ListNameParam</a> "thimura/haskell") (<a>ScreenNameListParam</a> ["thimura", "twitterapi"])
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; 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")]
--   
--   &gt;&gt;&gt; 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")]
--   </pre>
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 <a>call</a>:
--   
--   <pre>
--   res &lt;- <a>call</a> twInfo mgr <a>$</a> <a>listsOwnerships</a> (<a>ListNameParam</a> "thimura/haskell")
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; listsOwnerships Nothing
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/ownerships.json" []
--   
--   &gt;&gt;&gt; listsOwnerships (Just (ScreenNameParam "thimura"))
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/ownerships.json" [("screen_name","thimura")]
--   
--   &gt;&gt;&gt; listsOwnerships (Just (UserIdParam 69179963))
--   APIRequest "GET" "https://api.twitter.com/1.1/lists/ownerships.json" [("user_id","69179963")]
--   </pre>
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
--   <a>mediaUpload</a> and <tt>update</tt> successively.
--   
--   First, you should upload media with <a>mediaUpload</a>:
--   
--   <pre>
--   res1 &lt;- <a>call</a> twInfo mgr <a>$</a> <a>mediaUpload</a> (<a>MediaFromFile</a> "/path/to/upload/file1.png")
--   res2 &lt;- <a>call</a> twInfo mgr <a>$</a> <a>mediaUpload</a> (<a>MediaRequestBody</a> "file2.png" "[.. file body ..]")
--   </pre>
--   
--   and then collect the resulting media IDs and update your status by
--   calling <tt>update</tt>:
--   
--   <pre>
--   <a>call</a> twInfo mgr <a>$</a> <tt>update</tt> "Hello World" <tt>&amp;</tt> #media_ids <tt>?~</tt> [<a>uploadedMediaId</a> res1, <a>uploadedMediaId</a> res2]
--   </pre>
--   
--   See:
--   <a>https://dev.twitter.com/docs/api/multiple-media-extended-entities</a>
--   
--   <pre>
--   &gt;&gt;&gt; mediaUpload (MediaFromFile "/home/test/test.png")
--   APIRequestMultipart "POST" "https://upload.twitter.com/1.1/media/upload.json" []
--   </pre>
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
--   <a>https://dev.twitter.com/</a>).
module Web.Twitter.Conduit

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

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

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

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

-- | A wrapper function to perform multiple API request with changing
--   <tt>max_id</tt> parameter.
--   
--   This function cooperate with instances of <tt>HasMaxIdParam</tt>.
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
--   <tt>max_id</tt> parameter. The response of this function is not
--   restrict to <tt>responseType</tt>, so you can choose an arbitrarily
--   type of FromJSON instances.
--   
--   This function cooperate with instances of <tt>HasMaxIdParam</tt>.
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
--   <tt>cursor</tt> parameter.
--   
--   This function cooperate with instances of <tt>HasCursorParam</tt>.
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
--   <tt>cursor</tt> parameter. The response of this function is not
--   restrict to <tt>responseType</tt>, so you can choose an arbitrarily
--   type of FromJSON instances.
--   
--   This function cooperate with instances of <tt>HasCursorParam</tt>.
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
--   <tt>SearchResult</tt>.
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
--   <tt>SearchResult</tt>.
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 <a>def</a> method or <a>newOAuth</a> 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 <a>Manager</a> between multiple
--   threads and requests.
--   
--   Since 0.1.0
data Manager

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