    {-# LANGUAGE RankNTypes #-}

    module Web.Twitter.Conduit.Lens
           (
           -- * 'TT.Response'
             TT.Response
           , responseStatus
           , responseBody
           , responseHeaders
           -- * 'TT.TwitterErrorMessage'
           , TT.TwitterErrorMessage
           , twitterErrorMessage
           , twitterErrorCode

           -- * 'TT.WithCursor'
           , TT.WithCursor
           , previousCursor
           , nextCursor
           , contents

           -- * Re-exports
           , TT.TwitterError(..)
           , TT.CursorKey (..)
           , TT.IdsCursorKey
           , TT.UsersCursorKey
           , TT.ListsCursorKey
           ) where

    import Control.Lens
    import Data.Text (Text)
    import Network.HTTP.Types (Status, ResponseHeaders)
    import qualified Web.Twitter.Conduit.Cursor as TT
    import qualified Web.Twitter.Conduit.Response as TT

    -- * Lenses for 'TT.Response'
    responseStatus :: forall responseType. Lens' (TT.Response responseType) Status
    responseStatus :: (Status -> f Status)
    -> Response responseType -> f (Response responseType)
    responseStatus afb :: Status -> f Status
    afb s :: Response responseType
    s = (\b :: Status
    b -> Response responseType
    s { responseStatus :: Status
    TT.responseStatus = Status
    b }) (Status -> Response responseType)
    -> f Status -> f (Response responseType)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Status -> f Status
    afb (Response responseType -> Status
    forall responseType. Response responseType -> Status
    TT.responseStatus Response responseType
    s)

    responseHeaders :: forall responseType. Lens' (TT.Response responseType) ResponseHeaders
    responseHeaders :: (ResponseHeaders -> f ResponseHeaders)
    -> Response responseType -> f (Response responseType)
    responseHeaders afb :: ResponseHeaders -> f ResponseHeaders
    afb s :: Response responseType
    s = (\b :: ResponseHeaders
    b -> Response responseType
    s {responseHeaders :: ResponseHeaders
    TT.responseHeaders = ResponseHeaders
    b }) (ResponseHeaders -> Response responseType)
    -> f ResponseHeaders -> f (Response responseType)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ResponseHeaders -> f ResponseHeaders
    afb (Response responseType -> ResponseHeaders
    forall responseType. Response responseType -> ResponseHeaders
    TT.responseHeaders Response responseType
    s)

    responseBody :: forall a b. Lens (TT.Response a) (TT.Response b) a b
    responseBody :: (a -> f b) -> Response a -> f (Response b)
    responseBody afb :: a -> f b
    afb s :: Response a
    s = (\b :: b
    b -> Response a
    s { responseBody :: b
    TT.responseBody = b
    b }) (b -> Response b) -> f b -> f (Response b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> f b
    afb (Response a -> a
    forall responseType. Response responseType -> responseType
    TT.responseBody Response a
    s)

    -- * Lenses for 'TT.TwitterErrorMessage'

    twitterErrorCode :: Lens' TT.TwitterErrorMessage Int
    twitterErrorCode :: (Int -> f Int) -> TwitterErrorMessage -> f TwitterErrorMessage
    twitterErrorCode afb :: Int -> f Int
    afb s :: TwitterErrorMessage
    s = (\b :: Int
    b -> TwitterErrorMessage
    s { twitterErrorCode :: Int
    TT.twitterErrorCode = Int
    b }) (Int -> TwitterErrorMessage) -> f Int -> f TwitterErrorMessage
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> f Int
    afb (TwitterErrorMessage -> Int
    TT.twitterErrorCode TwitterErrorMessage
    s)

    twitterErrorMessage :: Lens' TT.TwitterErrorMessage Text
    twitterErrorMessage :: (Text -> f Text) -> TwitterErrorMessage -> f TwitterErrorMessage
    twitterErrorMessage afb :: Text -> f Text
    afb s :: TwitterErrorMessage
    s = (\b :: Text
    b -> TwitterErrorMessage
    s { twitterErrorMessage :: Text
    TT.twitterErrorMessage = Text
    b }) (Text -> TwitterErrorMessage) -> f Text -> f TwitterErrorMessage
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text -> f Text
    afb (TwitterErrorMessage -> Text
    TT.twitterErrorMessage TwitterErrorMessage
    s)

    -- * Lenses for 'TT.WithCursor'
    previousCursor :: forall cursorType cursorKey wrapped. Lens' (TT.WithCursor cursorType cursorKey wrapped) (Maybe cursorType)
    previousCursor :: (Maybe cursorType -> f (Maybe cursorType))
    -> WithCursor cursorType cursorKey wrapped
    -> f (WithCursor cursorType cursorKey wrapped)
    previousCursor afb :: Maybe cursorType -> f (Maybe cursorType)
    afb s :: WithCursor cursorType cursorKey wrapped
    s = (\b :: Maybe cursorType
    b -> WithCursor cursorType cursorKey wrapped
    s { previousCursor :: Maybe cursorType
    TT.previousCursor = Maybe cursorType
    b }) (Maybe cursorType -> WithCursor cursorType cursorKey wrapped)
    -> f (Maybe cursorType)
    -> f (WithCursor cursorType cursorKey wrapped)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe cursorType -> f (Maybe cursorType)
    afb (WithCursor cursorType cursorKey wrapped -> Maybe cursorType
    forall cursorType cursorKey wrapped.
    WithCursor cursorType cursorKey wrapped -> Maybe cursorType
    TT.previousCursor WithCursor cursorType cursorKey wrapped
    s)

    nextCursor :: forall cursorType cursorKey wrapped. Lens' (TT.WithCursor cursorType cursorKey wrapped) (Maybe cursorType)
    nextCursor :: (Maybe cursorType -> f (Maybe cursorType))
    -> WithCursor cursorType cursorKey wrapped
    -> f (WithCursor cursorType cursorKey wrapped)
    nextCursor afb :: Maybe cursorType -> f (Maybe cursorType)
    afb s :: WithCursor cursorType cursorKey wrapped
    s = (\b :: Maybe cursorType
    b -> WithCursor cursorType cursorKey wrapped
    s { nextCursor :: Maybe cursorType
    TT.nextCursor = Maybe cursorType
    b }) (Maybe cursorType -> WithCursor cursorType cursorKey wrapped)
    -> f (Maybe cursorType)
    -> f (WithCursor cursorType cursorKey wrapped)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe cursorType -> f (Maybe cursorType)
    afb (WithCursor cursorType cursorKey wrapped -> Maybe cursorType
    forall cursorType cursorKey wrapped.
    WithCursor cursorType cursorKey wrapped -> Maybe cursorType
    TT.nextCursor WithCursor cursorType cursorKey wrapped
    s)

    contents :: forall cursorType cursorKey a b. Lens (TT.WithCursor cursorType cursorKey a) (TT.WithCursor cursorType cursorKey b) [a] [b]
    contents :: ([a] -> f [b])
    -> WithCursor cursorType cursorKey a
    -> f (WithCursor cursorType cursorKey b)
    contents afb :: [a] -> f [b]
    afb s :: WithCursor cursorType cursorKey a
    s = (\b :: [b]
    b -> WithCursor cursorType cursorKey a
    s { contents :: [b]
    TT.contents = [b]
    b }) ([b] -> WithCursor cursorType cursorKey b)
    -> f [b] -> f (WithCursor cursorType cursorKey b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [a] -> f [b]
    afb (WithCursor cursorType cursorKey a -> [a]
    forall cursorType cursorKey wrapped.
    WithCursor cursorType cursorKey wrapped -> [wrapped]
    TT.contents WithCursor cursorType cursorKey a
    s)