-- 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.6.1

module Web.Twitter.Conduit.Cursor
type IdsCursorKey = "ids"
type UsersCursorKey = "users"
type ListsCursorKey = "lists"
type EventsCursorKey = "events"

-- | 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 "ids" UserId)
--   
--   >>> nextCursor res
--   Just 1234567890
--   
--   >>> contents res
--   [1111111111]
--   
--   
--   
--   >>> let Just res = decode "{\"previous_cursor\": 0, \"next_cursor\": 0, \"users\": [1000]}" :: Maybe (WithCursor Integer "users" UserId)
--   
--   >>> nextCursor res
--   Just 0
--   
--   >>> contents res
--   [1000]
--   
--   
--   
--   >>> let Just res = decode "{\"next_cursor\": \"hogehoge\", \"events\": [1000]}" :: Maybe (WithCursor Text "events" UserId)
--   
--   >>> nextCursor res
--   Just "hogehoge"
--   
--   >>> contents res
--   [1000]
--   
data WithCursor cursorType (cursorKey :: Symbol) wrapped
WithCursor :: Maybe cursorType -> Maybe cursorType -> [wrapped] -> WithCursor cursorType (cursorKey :: Symbol) wrapped
[previousCursor] :: WithCursor cursorType (cursorKey :: Symbol) wrapped -> Maybe cursorType
[nextCursor] :: WithCursor cursorType (cursorKey :: Symbol) wrapped -> Maybe cursorType
[contents] :: WithCursor cursorType (cursorKey :: Symbol) wrapped -> [wrapped]
instance Data.Traversable.Traversable (Web.Twitter.Conduit.Cursor.WithCursor cursorType cursorKey)
instance Data.Foldable.Foldable (Web.Twitter.Conduit.Cursor.WithCursor cursorType cursorKey)
instance GHC.Base.Functor (Web.Twitter.Conduit.Cursor.WithCursor cursorType cursorKey)
instance GHC.Generics.Generic1 (Web.Twitter.Conduit.Cursor.WithCursor cursorType cursorKey)
instance GHC.Generics.Generic (Web.Twitter.Conduit.Cursor.WithCursor cursorType cursorKey wrapped)
instance (GHC.Classes.Eq cursorType, GHC.Classes.Eq wrapped) => GHC.Classes.Eq (Web.Twitter.Conduit.Cursor.WithCursor cursorType cursorKey wrapped)
instance (GHC.Show.Show cursorType, GHC.Show.Show wrapped) => GHC.Show.Show (Web.Twitter.Conduit.Cursor.WithCursor cursorType cursorKey wrapped)
instance (GHC.TypeLits.KnownSymbol cursorKey, Data.Aeson.Types.FromJSON.FromJSON cursorType) => Data.Aeson.Types.FromJSON.FromJSON1 (Web.Twitter.Conduit.Cursor.WithCursor cursorType cursorKey)
instance (GHC.TypeLits.KnownSymbol cursorKey, Data.Aeson.Types.FromJSON.FromJSON cursorType, Data.Aeson.Types.FromJSON.FromJSON wrapped) => Data.Aeson.Types.FromJSON.FromJSON (Web.Twitter.Conduit.Cursor.WithCursor cursorType cursorKey wrapped)
instance (Control.DeepSeq.NFData cursorType, Control.DeepSeq.NFData wrapped) => Control.DeepSeq.NFData (Web.Twitter.Conduit.Cursor.WithCursor cursorType cursorKey wrapped)

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 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.Num.Integer.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.Num.Integer.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.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
data TweetMode
Extended :: TweetMode

-- | 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.UserParam
instance GHC.Show.Show Web.Twitter.Conduit.Parameters.UserParam
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.ListParam
instance GHC.Show.Show Web.Twitter.Conduit.Parameters.ListParam
instance GHC.Classes.Eq Web.Twitter.Conduit.Parameters.TweetMode
instance GHC.Show.Show Web.Twitter.Conduit.Parameters.TweetMode
instance Web.Twitter.Conduit.Request.Internal.ParameterValue Web.Twitter.Conduit.Parameters.TweetMode

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 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 Data.Data.Data Web.Twitter.Conduit.Response.TwitterErrorMessage
instance GHC.Show.Show Web.Twitter.Conduit.Response.TwitterErrorMessage
instance GHC.Classes.Eq Web.Twitter.Conduit.Response.TwitterError
instance GHC.Show.Show Web.Twitter.Conduit.Response.TwitterError
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 "ids" UserId)
--   
--   >>> nextCursor res
--   Just 1234567890
--   
--   >>> contents res
--   [1111111111]
--   
--   
--   
--   >>> let Just res = decode "{\"previous_cursor\": 0, \"next_cursor\": 0, \"users\": [1000]}" :: Maybe (WithCursor Integer "users" UserId)
--   
--   >>> nextCursor res
--   Just 0
--   
--   >>> contents res
--   [1000]
--   
--   
--   
--   >>> let Just res = decode "{\"next_cursor\": \"hogehoge\", \"events\": [1000]}" :: Maybe (WithCursor Text "events" UserId)
--   
--   >>> nextCursor res
--   Just "hogehoge"
--   
--   >>> contents res
--   [1000]
--   
data WithCursor cursorType (cursorKey :: Symbol) 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

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.TWToken
instance GHC.Read.Read Web.Twitter.Conduit.Types.TWToken
instance GHC.Show.Show Web.Twitter.Conduit.Types.TWToken
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 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, KnownSymbol 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, KnownSymbol 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.Api
type StatusesMentionsTimeline = '["count" ':= Integer, "since_id" ':= Integer, "max_id" ':= Integer, "trim_user" ':= Bool, "contributor_details" ':= Bool, "include_entities" ':= Bool, "tweet_mode" ':= TweetMode]

-- | Returns query data asks the most recent mentions for the
--   authenticating user.
--   
--   You can perform a query using call:
--   
--   
--   res <- call mentionsTimeline
--   
--   
--   
--   >>> statusesMentionsTimeline
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/mentions_timeline.json" []
--   
statusesMentionsTimeline :: 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" ':= TweetMode]

-- | 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")
--   
--   
--   
--   >>> statusesUserTimeline (ScreenNameParam "thimura")
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/user_timeline.json" [("screen_name","thimura")]
--   
--   >>> statusesUserTimeline (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")]
--   
statusesUserTimeline :: 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" ':= TweetMode]

-- | 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
--   
--   
--   
--   >>> statusesHomeTimeline
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/home_timeline.json" []
--   
--   >>> statusesHomeTimeline & #count ?~ 200
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/home_timeline.json" [("count","200")]
--   
statusesHomeTimeline :: 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" ':= TweetMode]

-- | 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
--   
--   
--   
--   >>> statusesRetweetsOfMe
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/retweets_of_me.json" []
--   
--   >>> statusesRetweetsOfMe & #count ?~ 100
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/retweets_of_me.json" [("count","100")]
--   
statusesRetweetsOfMe :: APIRequest StatusesRetweetsOfMe [Status]
type StatusesRetweetsId = '["count" ':= Integer, "trim_user" ':= Bool, "tweet_mode" ':= TweetMode]

-- | 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
--   
--   
--   
--   >>> statusesRetweetsId 1234567890
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/retweets/1234567890.json" []
--   
--   >>> statusesRetweetsId 1234567890 & #count ?~ 100
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/retweets/1234567890.json" [("count","100")]
--   
statusesRetweetsId :: StatusId -> APIRequest StatusesRetweetsId [RetweetedStatus]
type StatusesShowId = '["trim_user" ':= Bool, "include_my_retweet" ':= Bool, "include_entities" ':= Bool, "include_ext_alt_text" ':= Bool, "tweet_mode" ':= TweetMode]

-- | 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
--   
--   
--   
--   >>> statusesShowId 1234567890
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/show/1234567890.json" []
--   
--   >>> statusesShowId 1234567890 & #include_my_retweet ?~ True
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/show/1234567890.json" [("include_my_retweet","true")]
--   
statusesShowId :: StatusId -> APIRequest StatusesShowId Status
type StatusesDestroyId = '["trim_user" ':= Bool, "tweet_mode" ':= TweetMode]

-- | 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
--   
--   
--   
--   >>> statusesDestroyId 1234567890
--   APIRequest "POST" "https://api.twitter.com/1.1/statuses/destroy/1234567890.json" []
--   
statusesDestroyId :: StatusId -> APIRequest StatusesDestroyId Status
type StatusesUpdate = '["in_reply_to_status_id" ':= Integer, "display_coordinates" ':= Bool, "trim_user" ':= Bool, "media_ids" ':= [Integer], "tweet_mode" ':= TweetMode]

-- | 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"
--   
--   
--   
--   >>> statusesUpdate "Hello World"
--   APIRequest "POST" "https://api.twitter.com/1.1/statuses/update.json" [("status","Hello World")]
--   
--   >>> statusesUpdate "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")]
--   
statusesUpdate :: Text -> APIRequest StatusesUpdate Status
type StatusesRetweetId = '["trim_user" ':= Bool, "tweet_mode" ':= TweetMode]

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

-- | 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")
--   
--   
--   
--   >>> statusesUpdateWithMedia "Hello World" (MediaFromFile "/home/fuga/test.jpeg")
--   APIRequestMultipart "POST" "https://api.twitter.com/1.1/statuses/update_with_media.json" [("status","Hello World")]
--   
statusesUpdateWithMedia :: Text -> MediaData -> APIRequest StatusesUpdateWithMedia Status
type StatusesLookup = '["include_entities" ':= Bool, "trim_user" ':= Bool, "map" ':= Bool, "tweet_mode" ':= TweetMode]

-- | 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]
--   
--   
--   
--   >>> statusesLookup [10]
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/lookup.json" [("id","10")]
--   
--   >>> statusesLookup [10, 432656548536401920]
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/lookup.json" [("id","10,432656548536401920")]
--   
--   >>> statusesLookup [10, 432656548536401920] & #include_entities ?~ True
--   APIRequest "GET" "https://api.twitter.com/1.1/statuses/lookup.json" [("include_entities","true"),("id","10,432656548536401920")]
--   
statusesLookup :: [StatusId] -> APIRequest StatusesLookup [Status]
type SearchTweets = '["lang" ':= Text, "locale" ':= Text, "result_type" ':= Text, "count" ':= Integer, "until" ':= Day, "since_id" ':= Integer, "max_id" ':= Integer, "include_entities" ':= Bool, "tweet_mode" ':= TweetMode]

-- | 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, "tweet_mode" ':= TweetMode]

-- | 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, "tweet_mode" ':= TweetMode]

-- | Returns post data unfavorites the status specified in the ID parameter
--   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, "tweet_mode" ':= TweetMode]

-- | 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, "tweet_mode" ':= TweetMode]

-- | 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

module Web.Twitter.Conduit.Status

-- | Deprecated: Please use
--   Web.Twitter.Conduit.API.statusesMentionsTimeline
mentionsTimeline :: APIRequest StatusesMentionsTimeline [Status]

-- | Deprecated: Please use
--   Web.Twitter.Conduit.API.statusesUserTimeline
userTimeline :: UserParam -> APIRequest StatusesUserTimeline [Status]

-- | Deprecated: Please use
--   Web.Twitter.Conduit.API.statusesHomeTimeline
homeTimeline :: APIRequest StatusesHomeTimeline [Status]

-- | Deprecated: Please use
--   Web.Twitter.Conduit.API.statusesRetweetsOfMe
retweetsOfMe :: APIRequest StatusesRetweetsOfMe [Status]

-- | Deprecated: Please use
--   Web.Twitter.Conduit.API.statusesRetweetsId
retweetsId :: StatusId -> APIRequest StatusesRetweetsId [RetweetedStatus]

-- | Deprecated: Please use Web.Twitter.Conduit.API.statusesShowId
showId :: StatusId -> APIRequest StatusesShowId Status

-- | Deprecated: Please use
--   Web.Twitter.Conduit.API.statusesDestroyId
destroyId :: StatusId -> APIRequest StatusesDestroyId Status

-- | Deprecated: Please use Web.Twitter.Conduit.API.statusesUpdate
update :: Text -> APIRequest StatusesUpdate Status

-- | Deprecated: Please use
--   Web.Twitter.Conduit.API.statusesRetweetId
retweetId :: StatusId -> APIRequest StatusesRetweetId RetweetedStatus

-- | Deprecated: Please use
--   Web.Twitter.Conduit.API.statusesUpdateWithMedia
updateWithMedia :: Text -> MediaData -> APIRequest StatusesUpdateWithMedia Status

-- | Deprecated: Please use Web.Twitter.Conduit.API.statusesLookup
lookup :: [StatusId] -> APIRequest StatusesLookup [Status]

-- | 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, KnownSymbol 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, KnownSymbol 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 TweetMode
Extended :: TweetMode

-- | 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
