{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE CPP #-}

module GitHub.Data.Content where

import GitHub.Data.GitData
import GitHub.Data.URL
import GitHub.Internal.Prelude
import Prelude ()

import Data.Aeson.Types (Pair)
import qualified Data.Text as T

#if MIN_VERSION_aeson(2,0,0)
import Data.Aeson (Key)
#endif

data Content
  = ContentFile !ContentFileData
  | ContentDirectory !(Vector ContentItem)
 deriving (Int -> Content -> ShowS
[Content] -> ShowS
Content -> String
(Int -> Content -> ShowS)
-> (Content -> String) -> ([Content] -> ShowS) -> Show Content
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Content -> ShowS
showsPrec :: Int -> Content -> ShowS
$cshow :: Content -> String
show :: Content -> String
$cshowList :: [Content] -> ShowS
showList :: [Content] -> ShowS
Show, Typeable Content
Typeable Content =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Content -> c Content)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Content)
-> (Content -> Constr)
-> (Content -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Content))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Content))
-> ((forall b. Data b => b -> b) -> Content -> Content)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Content -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Content -> r)
-> (forall u. (forall d. Data d => d -> u) -> Content -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Content -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Content -> m Content)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Content -> m Content)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Content -> m Content)
-> Data Content
Content -> Constr
Content -> DataType
(forall b. Data b => b -> b) -> Content -> Content
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Content -> u
forall u. (forall d. Data d => d -> u) -> Content -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Content -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Content -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Content -> m Content
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Content -> m Content
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Content
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Content -> c Content
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Content)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Content)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Content -> c Content
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Content -> c Content
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Content
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Content
$ctoConstr :: Content -> Constr
toConstr :: Content -> Constr
$cdataTypeOf :: Content -> DataType
dataTypeOf :: Content -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Content)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Content)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Content)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Content)
$cgmapT :: (forall b. Data b => b -> b) -> Content -> Content
gmapT :: (forall b. Data b => b -> b) -> Content -> Content
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Content -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Content -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Content -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Content -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Content -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Content -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Content -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Content -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Content -> m Content
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Content -> m Content
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Content -> m Content
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Content -> m Content
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Content -> m Content
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Content -> m Content
Data, Typeable, Content -> Content -> Bool
(Content -> Content -> Bool)
-> (Content -> Content -> Bool) -> Eq Content
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Content -> Content -> Bool
== :: Content -> Content -> Bool
$c/= :: Content -> Content -> Bool
/= :: Content -> Content -> Bool
Eq, Eq Content
Eq Content =>
(Content -> Content -> Ordering)
-> (Content -> Content -> Bool)
-> (Content -> Content -> Bool)
-> (Content -> Content -> Bool)
-> (Content -> Content -> Bool)
-> (Content -> Content -> Content)
-> (Content -> Content -> Content)
-> Ord Content
Content -> Content -> Bool
Content -> Content -> Ordering
Content -> Content -> Content
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Content -> Content -> Ordering
compare :: Content -> Content -> Ordering
$c< :: Content -> Content -> Bool
< :: Content -> Content -> Bool
$c<= :: Content -> Content -> Bool
<= :: Content -> Content -> Bool
$c> :: Content -> Content -> Bool
> :: Content -> Content -> Bool
$c>= :: Content -> Content -> Bool
>= :: Content -> Content -> Bool
$cmax :: Content -> Content -> Content
max :: Content -> Content -> Content
$cmin :: Content -> Content -> Content
min :: Content -> Content -> Content
Ord, (forall x. Content -> Rep Content x)
-> (forall x. Rep Content x -> Content) -> Generic Content
forall x. Rep Content x -> Content
forall x. Content -> Rep Content x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Content -> Rep Content x
from :: forall x. Content -> Rep Content x
$cto :: forall x. Rep Content x -> Content
to :: forall x. Rep Content x -> Content
Generic)

instance NFData Content where rnf :: Content -> ()
rnf = Content -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary Content

data ContentFileData = ContentFileData {
   ContentFileData -> ContentInfo
contentFileInfo     :: !ContentInfo
  ,ContentFileData -> Text
contentFileEncoding :: !Text
  ,ContentFileData -> Int
contentFileSize     :: !Int
  ,ContentFileData -> Text
contentFileContent  :: !Text
} deriving (Int -> ContentFileData -> ShowS
[ContentFileData] -> ShowS
ContentFileData -> String
(Int -> ContentFileData -> ShowS)
-> (ContentFileData -> String)
-> ([ContentFileData] -> ShowS)
-> Show ContentFileData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ContentFileData -> ShowS
showsPrec :: Int -> ContentFileData -> ShowS
$cshow :: ContentFileData -> String
show :: ContentFileData -> String
$cshowList :: [ContentFileData] -> ShowS
showList :: [ContentFileData] -> ShowS
Show, Typeable ContentFileData
Typeable ContentFileData =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ContentFileData -> c ContentFileData)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ContentFileData)
-> (ContentFileData -> Constr)
-> (ContentFileData -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ContentFileData))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ContentFileData))
-> ((forall b. Data b => b -> b)
    -> ContentFileData -> ContentFileData)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ContentFileData -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ContentFileData -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ContentFileData -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ContentFileData -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ContentFileData -> m ContentFileData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ContentFileData -> m ContentFileData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ContentFileData -> m ContentFileData)
-> Data ContentFileData
ContentFileData -> Constr
ContentFileData -> DataType
(forall b. Data b => b -> b) -> ContentFileData -> ContentFileData
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ContentFileData -> u
forall u. (forall d. Data d => d -> u) -> ContentFileData -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentFileData -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentFileData -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ContentFileData -> m ContentFileData
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContentFileData -> m ContentFileData
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentFileData
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentFileData -> c ContentFileData
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentFileData)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentFileData)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentFileData -> c ContentFileData
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentFileData -> c ContentFileData
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentFileData
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentFileData
$ctoConstr :: ContentFileData -> Constr
toConstr :: ContentFileData -> Constr
$cdataTypeOf :: ContentFileData -> DataType
dataTypeOf :: ContentFileData -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentFileData)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentFileData)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentFileData)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentFileData)
$cgmapT :: (forall b. Data b => b -> b) -> ContentFileData -> ContentFileData
gmapT :: (forall b. Data b => b -> b) -> ContentFileData -> ContentFileData
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentFileData -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentFileData -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentFileData -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentFileData -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ContentFileData -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ContentFileData -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ContentFileData -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ContentFileData -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ContentFileData -> m ContentFileData
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ContentFileData -> m ContentFileData
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContentFileData -> m ContentFileData
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContentFileData -> m ContentFileData
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContentFileData -> m ContentFileData
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContentFileData -> m ContentFileData
Data, Typeable, ContentFileData -> ContentFileData -> Bool
(ContentFileData -> ContentFileData -> Bool)
-> (ContentFileData -> ContentFileData -> Bool)
-> Eq ContentFileData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ContentFileData -> ContentFileData -> Bool
== :: ContentFileData -> ContentFileData -> Bool
$c/= :: ContentFileData -> ContentFileData -> Bool
/= :: ContentFileData -> ContentFileData -> Bool
Eq, Eq ContentFileData
Eq ContentFileData =>
(ContentFileData -> ContentFileData -> Ordering)
-> (ContentFileData -> ContentFileData -> Bool)
-> (ContentFileData -> ContentFileData -> Bool)
-> (ContentFileData -> ContentFileData -> Bool)
-> (ContentFileData -> ContentFileData -> Bool)
-> (ContentFileData -> ContentFileData -> ContentFileData)
-> (ContentFileData -> ContentFileData -> ContentFileData)
-> Ord ContentFileData
ContentFileData -> ContentFileData -> Bool
ContentFileData -> ContentFileData -> Ordering
ContentFileData -> ContentFileData -> ContentFileData
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ContentFileData -> ContentFileData -> Ordering
compare :: ContentFileData -> ContentFileData -> Ordering
$c< :: ContentFileData -> ContentFileData -> Bool
< :: ContentFileData -> ContentFileData -> Bool
$c<= :: ContentFileData -> ContentFileData -> Bool
<= :: ContentFileData -> ContentFileData -> Bool
$c> :: ContentFileData -> ContentFileData -> Bool
> :: ContentFileData -> ContentFileData -> Bool
$c>= :: ContentFileData -> ContentFileData -> Bool
>= :: ContentFileData -> ContentFileData -> Bool
$cmax :: ContentFileData -> ContentFileData -> ContentFileData
max :: ContentFileData -> ContentFileData -> ContentFileData
$cmin :: ContentFileData -> ContentFileData -> ContentFileData
min :: ContentFileData -> ContentFileData -> ContentFileData
Ord, (forall x. ContentFileData -> Rep ContentFileData x)
-> (forall x. Rep ContentFileData x -> ContentFileData)
-> Generic ContentFileData
forall x. Rep ContentFileData x -> ContentFileData
forall x. ContentFileData -> Rep ContentFileData x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ContentFileData -> Rep ContentFileData x
from :: forall x. ContentFileData -> Rep ContentFileData x
$cto :: forall x. Rep ContentFileData x -> ContentFileData
to :: forall x. Rep ContentFileData x -> ContentFileData
Generic)

instance NFData ContentFileData where rnf :: ContentFileData -> ()
rnf = ContentFileData -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary ContentFileData

-- | An item in a directory listing.
data ContentItem = ContentItem {
   ContentItem -> ContentItemType
contentItemType :: !ContentItemType
  ,ContentItem -> ContentInfo
contentItemInfo :: !ContentInfo
} deriving (Int -> ContentItem -> ShowS
[ContentItem] -> ShowS
ContentItem -> String
(Int -> ContentItem -> ShowS)
-> (ContentItem -> String)
-> ([ContentItem] -> ShowS)
-> Show ContentItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ContentItem -> ShowS
showsPrec :: Int -> ContentItem -> ShowS
$cshow :: ContentItem -> String
show :: ContentItem -> String
$cshowList :: [ContentItem] -> ShowS
showList :: [ContentItem] -> ShowS
Show, Typeable ContentItem
Typeable ContentItem =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ContentItem -> c ContentItem)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ContentItem)
-> (ContentItem -> Constr)
-> (ContentItem -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ContentItem))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ContentItem))
-> ((forall b. Data b => b -> b) -> ContentItem -> ContentItem)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ContentItem -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ContentItem -> r)
-> (forall u. (forall d. Data d => d -> u) -> ContentItem -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ContentItem -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ContentItem -> m ContentItem)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ContentItem -> m ContentItem)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ContentItem -> m ContentItem)
-> Data ContentItem
ContentItem -> Constr
ContentItem -> DataType
(forall b. Data b => b -> b) -> ContentItem -> ContentItem
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ContentItem -> u
forall u. (forall d. Data d => d -> u) -> ContentItem -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentItem -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentItem -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ContentItem -> m ContentItem
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContentItem -> m ContentItem
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentItem
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentItem -> c ContentItem
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentItem)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentItem)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentItem -> c ContentItem
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentItem -> c ContentItem
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentItem
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentItem
$ctoConstr :: ContentItem -> Constr
toConstr :: ContentItem -> Constr
$cdataTypeOf :: ContentItem -> DataType
dataTypeOf :: ContentItem -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentItem)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentItem)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentItem)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentItem)
$cgmapT :: (forall b. Data b => b -> b) -> ContentItem -> ContentItem
gmapT :: (forall b. Data b => b -> b) -> ContentItem -> ContentItem
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentItem -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentItem -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentItem -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentItem -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ContentItem -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ContentItem -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ContentItem -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ContentItem -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ContentItem -> m ContentItem
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ContentItem -> m ContentItem
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContentItem -> m ContentItem
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContentItem -> m ContentItem
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContentItem -> m ContentItem
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContentItem -> m ContentItem
Data, Typeable, ContentItem -> ContentItem -> Bool
(ContentItem -> ContentItem -> Bool)
-> (ContentItem -> ContentItem -> Bool) -> Eq ContentItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ContentItem -> ContentItem -> Bool
== :: ContentItem -> ContentItem -> Bool
$c/= :: ContentItem -> ContentItem -> Bool
/= :: ContentItem -> ContentItem -> Bool
Eq, Eq ContentItem
Eq ContentItem =>
(ContentItem -> ContentItem -> Ordering)
-> (ContentItem -> ContentItem -> Bool)
-> (ContentItem -> ContentItem -> Bool)
-> (ContentItem -> ContentItem -> Bool)
-> (ContentItem -> ContentItem -> Bool)
-> (ContentItem -> ContentItem -> ContentItem)
-> (ContentItem -> ContentItem -> ContentItem)
-> Ord ContentItem
ContentItem -> ContentItem -> Bool
ContentItem -> ContentItem -> Ordering
ContentItem -> ContentItem -> ContentItem
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ContentItem -> ContentItem -> Ordering
compare :: ContentItem -> ContentItem -> Ordering
$c< :: ContentItem -> ContentItem -> Bool
< :: ContentItem -> ContentItem -> Bool
$c<= :: ContentItem -> ContentItem -> Bool
<= :: ContentItem -> ContentItem -> Bool
$c> :: ContentItem -> ContentItem -> Bool
> :: ContentItem -> ContentItem -> Bool
$c>= :: ContentItem -> ContentItem -> Bool
>= :: ContentItem -> ContentItem -> Bool
$cmax :: ContentItem -> ContentItem -> ContentItem
max :: ContentItem -> ContentItem -> ContentItem
$cmin :: ContentItem -> ContentItem -> ContentItem
min :: ContentItem -> ContentItem -> ContentItem
Ord, (forall x. ContentItem -> Rep ContentItem x)
-> (forall x. Rep ContentItem x -> ContentItem)
-> Generic ContentItem
forall x. Rep ContentItem x -> ContentItem
forall x. ContentItem -> Rep ContentItem x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ContentItem -> Rep ContentItem x
from :: forall x. ContentItem -> Rep ContentItem x
$cto :: forall x. Rep ContentItem x -> ContentItem
to :: forall x. Rep ContentItem x -> ContentItem
Generic)

instance NFData ContentItem where rnf :: ContentItem -> ()
rnf = ContentItem -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary ContentItem

data ContentItemType = ItemFile | ItemDir
  deriving (Int -> ContentItemType -> ShowS
[ContentItemType] -> ShowS
ContentItemType -> String
(Int -> ContentItemType -> ShowS)
-> (ContentItemType -> String)
-> ([ContentItemType] -> ShowS)
-> Show ContentItemType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ContentItemType -> ShowS
showsPrec :: Int -> ContentItemType -> ShowS
$cshow :: ContentItemType -> String
show :: ContentItemType -> String
$cshowList :: [ContentItemType] -> ShowS
showList :: [ContentItemType] -> ShowS
Show, Typeable ContentItemType
Typeable ContentItemType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ContentItemType -> c ContentItemType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ContentItemType)
-> (ContentItemType -> Constr)
-> (ContentItemType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ContentItemType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ContentItemType))
-> ((forall b. Data b => b -> b)
    -> ContentItemType -> ContentItemType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ContentItemType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ContentItemType -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ContentItemType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ContentItemType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ContentItemType -> m ContentItemType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ContentItemType -> m ContentItemType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ContentItemType -> m ContentItemType)
-> Data ContentItemType
ContentItemType -> Constr
ContentItemType -> DataType
(forall b. Data b => b -> b) -> ContentItemType -> ContentItemType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ContentItemType -> u
forall u. (forall d. Data d => d -> u) -> ContentItemType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentItemType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentItemType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ContentItemType -> m ContentItemType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContentItemType -> m ContentItemType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentItemType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentItemType -> c ContentItemType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentItemType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentItemType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentItemType -> c ContentItemType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentItemType -> c ContentItemType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentItemType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentItemType
$ctoConstr :: ContentItemType -> Constr
toConstr :: ContentItemType -> Constr
$cdataTypeOf :: ContentItemType -> DataType
dataTypeOf :: ContentItemType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentItemType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentItemType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentItemType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentItemType)
$cgmapT :: (forall b. Data b => b -> b) -> ContentItemType -> ContentItemType
gmapT :: (forall b. Data b => b -> b) -> ContentItemType -> ContentItemType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentItemType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentItemType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentItemType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentItemType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ContentItemType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ContentItemType -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ContentItemType -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ContentItemType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ContentItemType -> m ContentItemType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ContentItemType -> m ContentItemType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContentItemType -> m ContentItemType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContentItemType -> m ContentItemType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContentItemType -> m ContentItemType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContentItemType -> m ContentItemType
Data, Typeable, ContentItemType -> ContentItemType -> Bool
(ContentItemType -> ContentItemType -> Bool)
-> (ContentItemType -> ContentItemType -> Bool)
-> Eq ContentItemType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ContentItemType -> ContentItemType -> Bool
== :: ContentItemType -> ContentItemType -> Bool
$c/= :: ContentItemType -> ContentItemType -> Bool
/= :: ContentItemType -> ContentItemType -> Bool
Eq, Eq ContentItemType
Eq ContentItemType =>
(ContentItemType -> ContentItemType -> Ordering)
-> (ContentItemType -> ContentItemType -> Bool)
-> (ContentItemType -> ContentItemType -> Bool)
-> (ContentItemType -> ContentItemType -> Bool)
-> (ContentItemType -> ContentItemType -> Bool)
-> (ContentItemType -> ContentItemType -> ContentItemType)
-> (ContentItemType -> ContentItemType -> ContentItemType)
-> Ord ContentItemType
ContentItemType -> ContentItemType -> Bool
ContentItemType -> ContentItemType -> Ordering
ContentItemType -> ContentItemType -> ContentItemType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ContentItemType -> ContentItemType -> Ordering
compare :: ContentItemType -> ContentItemType -> Ordering
$c< :: ContentItemType -> ContentItemType -> Bool
< :: ContentItemType -> ContentItemType -> Bool
$c<= :: ContentItemType -> ContentItemType -> Bool
<= :: ContentItemType -> ContentItemType -> Bool
$c> :: ContentItemType -> ContentItemType -> Bool
> :: ContentItemType -> ContentItemType -> Bool
$c>= :: ContentItemType -> ContentItemType -> Bool
>= :: ContentItemType -> ContentItemType -> Bool
$cmax :: ContentItemType -> ContentItemType -> ContentItemType
max :: ContentItemType -> ContentItemType -> ContentItemType
$cmin :: ContentItemType -> ContentItemType -> ContentItemType
min :: ContentItemType -> ContentItemType -> ContentItemType
Ord, (forall x. ContentItemType -> Rep ContentItemType x)
-> (forall x. Rep ContentItemType x -> ContentItemType)
-> Generic ContentItemType
forall x. Rep ContentItemType x -> ContentItemType
forall x. ContentItemType -> Rep ContentItemType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ContentItemType -> Rep ContentItemType x
from :: forall x. ContentItemType -> Rep ContentItemType x
$cto :: forall x. Rep ContentItemType x -> ContentItemType
to :: forall x. Rep ContentItemType x -> ContentItemType
Generic)

instance NFData ContentItemType where rnf :: ContentItemType -> ()
rnf = ContentItemType -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary ContentItemType

-- | Information common to both kinds of Content: files and directories.
data ContentInfo = ContentInfo {
   ContentInfo -> Text
contentName    :: !Text
  ,ContentInfo -> Text
contentPath    :: !Text
  ,ContentInfo -> Text
contentSha     :: !Text
  ,ContentInfo -> URL
contentUrl     :: !URL
  ,ContentInfo -> URL
contentGitUrl  :: !URL
  ,ContentInfo -> URL
contentHtmlUrl :: !URL
} deriving (Int -> ContentInfo -> ShowS
[ContentInfo] -> ShowS
ContentInfo -> String
(Int -> ContentInfo -> ShowS)
-> (ContentInfo -> String)
-> ([ContentInfo] -> ShowS)
-> Show ContentInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ContentInfo -> ShowS
showsPrec :: Int -> ContentInfo -> ShowS
$cshow :: ContentInfo -> String
show :: ContentInfo -> String
$cshowList :: [ContentInfo] -> ShowS
showList :: [ContentInfo] -> ShowS
Show, Typeable ContentInfo
Typeable ContentInfo =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ContentInfo -> c ContentInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ContentInfo)
-> (ContentInfo -> Constr)
-> (ContentInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ContentInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ContentInfo))
-> ((forall b. Data b => b -> b) -> ContentInfo -> ContentInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ContentInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ContentInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> ContentInfo -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ContentInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ContentInfo -> m ContentInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ContentInfo -> m ContentInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ContentInfo -> m ContentInfo)
-> Data ContentInfo
ContentInfo -> Constr
ContentInfo -> DataType
(forall b. Data b => b -> b) -> ContentInfo -> ContentInfo
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ContentInfo -> u
forall u. (forall d. Data d => d -> u) -> ContentInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ContentInfo -> m ContentInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContentInfo -> m ContentInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentInfo -> c ContentInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentInfo)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentInfo -> c ContentInfo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentInfo -> c ContentInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentInfo
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentInfo
$ctoConstr :: ContentInfo -> Constr
toConstr :: ContentInfo -> Constr
$cdataTypeOf :: ContentInfo -> DataType
dataTypeOf :: ContentInfo -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentInfo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentInfo)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentInfo)
$cgmapT :: (forall b. Data b => b -> b) -> ContentInfo -> ContentInfo
gmapT :: (forall b. Data b => b -> b) -> ContentInfo -> ContentInfo
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentInfo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentInfo -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentInfo -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ContentInfo -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ContentInfo -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ContentInfo -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ContentInfo -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ContentInfo -> m ContentInfo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ContentInfo -> m ContentInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContentInfo -> m ContentInfo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContentInfo -> m ContentInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContentInfo -> m ContentInfo
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContentInfo -> m ContentInfo
Data, Typeable, ContentInfo -> ContentInfo -> Bool
(ContentInfo -> ContentInfo -> Bool)
-> (ContentInfo -> ContentInfo -> Bool) -> Eq ContentInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ContentInfo -> ContentInfo -> Bool
== :: ContentInfo -> ContentInfo -> Bool
$c/= :: ContentInfo -> ContentInfo -> Bool
/= :: ContentInfo -> ContentInfo -> Bool
Eq, Eq ContentInfo
Eq ContentInfo =>
(ContentInfo -> ContentInfo -> Ordering)
-> (ContentInfo -> ContentInfo -> Bool)
-> (ContentInfo -> ContentInfo -> Bool)
-> (ContentInfo -> ContentInfo -> Bool)
-> (ContentInfo -> ContentInfo -> Bool)
-> (ContentInfo -> ContentInfo -> ContentInfo)
-> (ContentInfo -> ContentInfo -> ContentInfo)
-> Ord ContentInfo
ContentInfo -> ContentInfo -> Bool
ContentInfo -> ContentInfo -> Ordering
ContentInfo -> ContentInfo -> ContentInfo
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ContentInfo -> ContentInfo -> Ordering
compare :: ContentInfo -> ContentInfo -> Ordering
$c< :: ContentInfo -> ContentInfo -> Bool
< :: ContentInfo -> ContentInfo -> Bool
$c<= :: ContentInfo -> ContentInfo -> Bool
<= :: ContentInfo -> ContentInfo -> Bool
$c> :: ContentInfo -> ContentInfo -> Bool
> :: ContentInfo -> ContentInfo -> Bool
$c>= :: ContentInfo -> ContentInfo -> Bool
>= :: ContentInfo -> ContentInfo -> Bool
$cmax :: ContentInfo -> ContentInfo -> ContentInfo
max :: ContentInfo -> ContentInfo -> ContentInfo
$cmin :: ContentInfo -> ContentInfo -> ContentInfo
min :: ContentInfo -> ContentInfo -> ContentInfo
Ord, (forall x. ContentInfo -> Rep ContentInfo x)
-> (forall x. Rep ContentInfo x -> ContentInfo)
-> Generic ContentInfo
forall x. Rep ContentInfo x -> ContentInfo
forall x. ContentInfo -> Rep ContentInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ContentInfo -> Rep ContentInfo x
from :: forall x. ContentInfo -> Rep ContentInfo x
$cto :: forall x. Rep ContentInfo x -> ContentInfo
to :: forall x. Rep ContentInfo x -> ContentInfo
Generic)

instance NFData ContentInfo where rnf :: ContentInfo -> ()
rnf = ContentInfo -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary ContentInfo

data ContentResultInfo = ContentResultInfo
    { ContentResultInfo -> ContentInfo
contentResultInfo :: !ContentInfo
    , ContentResultInfo -> Int
contentResultSize :: !Int
    } deriving (Int -> ContentResultInfo -> ShowS
[ContentResultInfo] -> ShowS
ContentResultInfo -> String
(Int -> ContentResultInfo -> ShowS)
-> (ContentResultInfo -> String)
-> ([ContentResultInfo] -> ShowS)
-> Show ContentResultInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ContentResultInfo -> ShowS
showsPrec :: Int -> ContentResultInfo -> ShowS
$cshow :: ContentResultInfo -> String
show :: ContentResultInfo -> String
$cshowList :: [ContentResultInfo] -> ShowS
showList :: [ContentResultInfo] -> ShowS
Show, Typeable ContentResultInfo
Typeable ContentResultInfo =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> ContentResultInfo
 -> c ContentResultInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ContentResultInfo)
-> (ContentResultInfo -> Constr)
-> (ContentResultInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ContentResultInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ContentResultInfo))
-> ((forall b. Data b => b -> b)
    -> ContentResultInfo -> ContentResultInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ContentResultInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ContentResultInfo -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ContentResultInfo -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ContentResultInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ContentResultInfo -> m ContentResultInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ContentResultInfo -> m ContentResultInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ContentResultInfo -> m ContentResultInfo)
-> Data ContentResultInfo
ContentResultInfo -> Constr
ContentResultInfo -> DataType
(forall b. Data b => b -> b)
-> ContentResultInfo -> ContentResultInfo
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ContentResultInfo -> u
forall u. (forall d. Data d => d -> u) -> ContentResultInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentResultInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentResultInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ContentResultInfo -> m ContentResultInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContentResultInfo -> m ContentResultInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentResultInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentResultInfo -> c ContentResultInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentResultInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentResultInfo)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentResultInfo -> c ContentResultInfo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentResultInfo -> c ContentResultInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentResultInfo
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentResultInfo
$ctoConstr :: ContentResultInfo -> Constr
toConstr :: ContentResultInfo -> Constr
$cdataTypeOf :: ContentResultInfo -> DataType
dataTypeOf :: ContentResultInfo -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentResultInfo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentResultInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentResultInfo)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentResultInfo)
$cgmapT :: (forall b. Data b => b -> b)
-> ContentResultInfo -> ContentResultInfo
gmapT :: (forall b. Data b => b -> b)
-> ContentResultInfo -> ContentResultInfo
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentResultInfo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentResultInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentResultInfo -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentResultInfo -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ContentResultInfo -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ContentResultInfo -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ContentResultInfo -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ContentResultInfo -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ContentResultInfo -> m ContentResultInfo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ContentResultInfo -> m ContentResultInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContentResultInfo -> m ContentResultInfo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContentResultInfo -> m ContentResultInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContentResultInfo -> m ContentResultInfo
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContentResultInfo -> m ContentResultInfo
Data, Typeable, ContentResultInfo -> ContentResultInfo -> Bool
(ContentResultInfo -> ContentResultInfo -> Bool)
-> (ContentResultInfo -> ContentResultInfo -> Bool)
-> Eq ContentResultInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ContentResultInfo -> ContentResultInfo -> Bool
== :: ContentResultInfo -> ContentResultInfo -> Bool
$c/= :: ContentResultInfo -> ContentResultInfo -> Bool
/= :: ContentResultInfo -> ContentResultInfo -> Bool
Eq, Eq ContentResultInfo
Eq ContentResultInfo =>
(ContentResultInfo -> ContentResultInfo -> Ordering)
-> (ContentResultInfo -> ContentResultInfo -> Bool)
-> (ContentResultInfo -> ContentResultInfo -> Bool)
-> (ContentResultInfo -> ContentResultInfo -> Bool)
-> (ContentResultInfo -> ContentResultInfo -> Bool)
-> (ContentResultInfo -> ContentResultInfo -> ContentResultInfo)
-> (ContentResultInfo -> ContentResultInfo -> ContentResultInfo)
-> Ord ContentResultInfo
ContentResultInfo -> ContentResultInfo -> Bool
ContentResultInfo -> ContentResultInfo -> Ordering
ContentResultInfo -> ContentResultInfo -> ContentResultInfo
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ContentResultInfo -> ContentResultInfo -> Ordering
compare :: ContentResultInfo -> ContentResultInfo -> Ordering
$c< :: ContentResultInfo -> ContentResultInfo -> Bool
< :: ContentResultInfo -> ContentResultInfo -> Bool
$c<= :: ContentResultInfo -> ContentResultInfo -> Bool
<= :: ContentResultInfo -> ContentResultInfo -> Bool
$c> :: ContentResultInfo -> ContentResultInfo -> Bool
> :: ContentResultInfo -> ContentResultInfo -> Bool
$c>= :: ContentResultInfo -> ContentResultInfo -> Bool
>= :: ContentResultInfo -> ContentResultInfo -> Bool
$cmax :: ContentResultInfo -> ContentResultInfo -> ContentResultInfo
max :: ContentResultInfo -> ContentResultInfo -> ContentResultInfo
$cmin :: ContentResultInfo -> ContentResultInfo -> ContentResultInfo
min :: ContentResultInfo -> ContentResultInfo -> ContentResultInfo
Ord, (forall x. ContentResultInfo -> Rep ContentResultInfo x)
-> (forall x. Rep ContentResultInfo x -> ContentResultInfo)
-> Generic ContentResultInfo
forall x. Rep ContentResultInfo x -> ContentResultInfo
forall x. ContentResultInfo -> Rep ContentResultInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ContentResultInfo -> Rep ContentResultInfo x
from :: forall x. ContentResultInfo -> Rep ContentResultInfo x
$cto :: forall x. Rep ContentResultInfo x -> ContentResultInfo
to :: forall x. Rep ContentResultInfo x -> ContentResultInfo
Generic)

instance NFData ContentResultInfo where rnf :: ContentResultInfo -> ()
rnf = ContentResultInfo -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary ContentResultInfo

data ContentResult = ContentResult
    { ContentResult -> ContentResultInfo
contentResultContent  :: !ContentResultInfo
    , ContentResult -> GitCommit
contentResultCommit   :: !GitCommit
    } deriving (Int -> ContentResult -> ShowS
[ContentResult] -> ShowS
ContentResult -> String
(Int -> ContentResult -> ShowS)
-> (ContentResult -> String)
-> ([ContentResult] -> ShowS)
-> Show ContentResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ContentResult -> ShowS
showsPrec :: Int -> ContentResult -> ShowS
$cshow :: ContentResult -> String
show :: ContentResult -> String
$cshowList :: [ContentResult] -> ShowS
showList :: [ContentResult] -> ShowS
Show, Typeable ContentResult
Typeable ContentResult =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ContentResult -> c ContentResult)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ContentResult)
-> (ContentResult -> Constr)
-> (ContentResult -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ContentResult))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ContentResult))
-> ((forall b. Data b => b -> b) -> ContentResult -> ContentResult)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ContentResult -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ContentResult -> r)
-> (forall u. (forall d. Data d => d -> u) -> ContentResult -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ContentResult -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ContentResult -> m ContentResult)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ContentResult -> m ContentResult)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ContentResult -> m ContentResult)
-> Data ContentResult
ContentResult -> Constr
ContentResult -> DataType
(forall b. Data b => b -> b) -> ContentResult -> ContentResult
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ContentResult -> u
forall u. (forall d. Data d => d -> u) -> ContentResult -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentResult -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentResult -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ContentResult -> m ContentResult
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContentResult -> m ContentResult
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentResult
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentResult -> c ContentResult
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentResult)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentResult)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentResult -> c ContentResult
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContentResult -> c ContentResult
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentResult
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContentResult
$ctoConstr :: ContentResult -> Constr
toConstr :: ContentResult -> Constr
$cdataTypeOf :: ContentResult -> DataType
dataTypeOf :: ContentResult -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentResult)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContentResult)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentResult)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContentResult)
$cgmapT :: (forall b. Data b => b -> b) -> ContentResult -> ContentResult
gmapT :: (forall b. Data b => b -> b) -> ContentResult -> ContentResult
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentResult -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContentResult -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentResult -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContentResult -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ContentResult -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ContentResult -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ContentResult -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ContentResult -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ContentResult -> m ContentResult
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ContentResult -> m ContentResult
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContentResult -> m ContentResult
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContentResult -> m ContentResult
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContentResult -> m ContentResult
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContentResult -> m ContentResult
Data, Typeable, ContentResult -> ContentResult -> Bool
(ContentResult -> ContentResult -> Bool)
-> (ContentResult -> ContentResult -> Bool) -> Eq ContentResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ContentResult -> ContentResult -> Bool
== :: ContentResult -> ContentResult -> Bool
$c/= :: ContentResult -> ContentResult -> Bool
/= :: ContentResult -> ContentResult -> Bool
Eq, Eq ContentResult
Eq ContentResult =>
(ContentResult -> ContentResult -> Ordering)
-> (ContentResult -> ContentResult -> Bool)
-> (ContentResult -> ContentResult -> Bool)
-> (ContentResult -> ContentResult -> Bool)
-> (ContentResult -> ContentResult -> Bool)
-> (ContentResult -> ContentResult -> ContentResult)
-> (ContentResult -> ContentResult -> ContentResult)
-> Ord ContentResult
ContentResult -> ContentResult -> Bool
ContentResult -> ContentResult -> Ordering
ContentResult -> ContentResult -> ContentResult
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ContentResult -> ContentResult -> Ordering
compare :: ContentResult -> ContentResult -> Ordering
$c< :: ContentResult -> ContentResult -> Bool
< :: ContentResult -> ContentResult -> Bool
$c<= :: ContentResult -> ContentResult -> Bool
<= :: ContentResult -> ContentResult -> Bool
$c> :: ContentResult -> ContentResult -> Bool
> :: ContentResult -> ContentResult -> Bool
$c>= :: ContentResult -> ContentResult -> Bool
>= :: ContentResult -> ContentResult -> Bool
$cmax :: ContentResult -> ContentResult -> ContentResult
max :: ContentResult -> ContentResult -> ContentResult
$cmin :: ContentResult -> ContentResult -> ContentResult
min :: ContentResult -> ContentResult -> ContentResult
Ord, (forall x. ContentResult -> Rep ContentResult x)
-> (forall x. Rep ContentResult x -> ContentResult)
-> Generic ContentResult
forall x. Rep ContentResult x -> ContentResult
forall x. ContentResult -> Rep ContentResult x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ContentResult -> Rep ContentResult x
from :: forall x. ContentResult -> Rep ContentResult x
$cto :: forall x. Rep ContentResult x -> ContentResult
to :: forall x. Rep ContentResult x -> ContentResult
Generic)

instance NFData ContentResult where rnf :: ContentResult -> ()
rnf = ContentResult -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary ContentResult

data Author = Author
    { Author -> Text
authorName  :: !Text
    , Author -> Text
authorEmail :: !Text
    }
    deriving (Author -> Author -> Bool
(Author -> Author -> Bool)
-> (Author -> Author -> Bool) -> Eq Author
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Author -> Author -> Bool
== :: Author -> Author -> Bool
$c/= :: Author -> Author -> Bool
/= :: Author -> Author -> Bool
Eq, Eq Author
Eq Author =>
(Author -> Author -> Ordering)
-> (Author -> Author -> Bool)
-> (Author -> Author -> Bool)
-> (Author -> Author -> Bool)
-> (Author -> Author -> Bool)
-> (Author -> Author -> Author)
-> (Author -> Author -> Author)
-> Ord Author
Author -> Author -> Bool
Author -> Author -> Ordering
Author -> Author -> Author
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Author -> Author -> Ordering
compare :: Author -> Author -> Ordering
$c< :: Author -> Author -> Bool
< :: Author -> Author -> Bool
$c<= :: Author -> Author -> Bool
<= :: Author -> Author -> Bool
$c> :: Author -> Author -> Bool
> :: Author -> Author -> Bool
$c>= :: Author -> Author -> Bool
>= :: Author -> Author -> Bool
$cmax :: Author -> Author -> Author
max :: Author -> Author -> Author
$cmin :: Author -> Author -> Author
min :: Author -> Author -> Author
Ord, Int -> Author -> ShowS
[Author] -> ShowS
Author -> String
(Int -> Author -> ShowS)
-> (Author -> String) -> ([Author] -> ShowS) -> Show Author
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Author -> ShowS
showsPrec :: Int -> Author -> ShowS
$cshow :: Author -> String
show :: Author -> String
$cshowList :: [Author] -> ShowS
showList :: [Author] -> ShowS
Show, Typeable Author
Typeable Author =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Author -> c Author)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Author)
-> (Author -> Constr)
-> (Author -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Author))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Author))
-> ((forall b. Data b => b -> b) -> Author -> Author)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Author -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Author -> r)
-> (forall u. (forall d. Data d => d -> u) -> Author -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Author -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Author -> m Author)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Author -> m Author)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Author -> m Author)
-> Data Author
Author -> Constr
Author -> DataType
(forall b. Data b => b -> b) -> Author -> Author
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Author -> u
forall u. (forall d. Data d => d -> u) -> Author -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Author -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Author -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Author -> m Author
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Author -> m Author
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Author
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Author -> c Author
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Author)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Author)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Author -> c Author
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Author -> c Author
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Author
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Author
$ctoConstr :: Author -> Constr
toConstr :: Author -> Constr
$cdataTypeOf :: Author -> DataType
dataTypeOf :: Author -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Author)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Author)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Author)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Author)
$cgmapT :: (forall b. Data b => b -> b) -> Author -> Author
gmapT :: (forall b. Data b => b -> b) -> Author -> Author
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Author -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Author -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Author -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Author -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Author -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Author -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Author -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Author -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Author -> m Author
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Author -> m Author
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Author -> m Author
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Author -> m Author
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Author -> m Author
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Author -> m Author
Data, Typeable, (forall x. Author -> Rep Author x)
-> (forall x. Rep Author x -> Author) -> Generic Author
forall x. Rep Author x -> Author
forall x. Author -> Rep Author x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Author -> Rep Author x
from :: forall x. Author -> Rep Author x
$cto :: forall x. Rep Author x -> Author
to :: forall x. Rep Author x -> Author
Generic)

instance NFData Author where rnf :: Author -> ()
rnf = Author -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary Author

data CreateFile = CreateFile
    { CreateFile -> Text
createFilePath      :: !Text
    , CreateFile -> Text
createFileMessage   :: !Text
    , CreateFile -> Text
createFileContent   :: !Text
    , CreateFile -> Maybe Text
createFileBranch    :: !(Maybe Text)
    , CreateFile -> Maybe Author
createFileAuthor    :: !(Maybe Author)
    , CreateFile -> Maybe Author
createFileCommitter :: !(Maybe Author)
    }
    deriving (CreateFile -> CreateFile -> Bool
(CreateFile -> CreateFile -> Bool)
-> (CreateFile -> CreateFile -> Bool) -> Eq CreateFile
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CreateFile -> CreateFile -> Bool
== :: CreateFile -> CreateFile -> Bool
$c/= :: CreateFile -> CreateFile -> Bool
/= :: CreateFile -> CreateFile -> Bool
Eq, Eq CreateFile
Eq CreateFile =>
(CreateFile -> CreateFile -> Ordering)
-> (CreateFile -> CreateFile -> Bool)
-> (CreateFile -> CreateFile -> Bool)
-> (CreateFile -> CreateFile -> Bool)
-> (CreateFile -> CreateFile -> Bool)
-> (CreateFile -> CreateFile -> CreateFile)
-> (CreateFile -> CreateFile -> CreateFile)
-> Ord CreateFile
CreateFile -> CreateFile -> Bool
CreateFile -> CreateFile -> Ordering
CreateFile -> CreateFile -> CreateFile
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CreateFile -> CreateFile -> Ordering
compare :: CreateFile -> CreateFile -> Ordering
$c< :: CreateFile -> CreateFile -> Bool
< :: CreateFile -> CreateFile -> Bool
$c<= :: CreateFile -> CreateFile -> Bool
<= :: CreateFile -> CreateFile -> Bool
$c> :: CreateFile -> CreateFile -> Bool
> :: CreateFile -> CreateFile -> Bool
$c>= :: CreateFile -> CreateFile -> Bool
>= :: CreateFile -> CreateFile -> Bool
$cmax :: CreateFile -> CreateFile -> CreateFile
max :: CreateFile -> CreateFile -> CreateFile
$cmin :: CreateFile -> CreateFile -> CreateFile
min :: CreateFile -> CreateFile -> CreateFile
Ord, Int -> CreateFile -> ShowS
[CreateFile] -> ShowS
CreateFile -> String
(Int -> CreateFile -> ShowS)
-> (CreateFile -> String)
-> ([CreateFile] -> ShowS)
-> Show CreateFile
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CreateFile -> ShowS
showsPrec :: Int -> CreateFile -> ShowS
$cshow :: CreateFile -> String
show :: CreateFile -> String
$cshowList :: [CreateFile] -> ShowS
showList :: [CreateFile] -> ShowS
Show, Typeable CreateFile
Typeable CreateFile =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CreateFile -> c CreateFile)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CreateFile)
-> (CreateFile -> Constr)
-> (CreateFile -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CreateFile))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CreateFile))
-> ((forall b. Data b => b -> b) -> CreateFile -> CreateFile)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CreateFile -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CreateFile -> r)
-> (forall u. (forall d. Data d => d -> u) -> CreateFile -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CreateFile -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CreateFile -> m CreateFile)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CreateFile -> m CreateFile)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CreateFile -> m CreateFile)
-> Data CreateFile
CreateFile -> Constr
CreateFile -> DataType
(forall b. Data b => b -> b) -> CreateFile -> CreateFile
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CreateFile -> u
forall u. (forall d. Data d => d -> u) -> CreateFile -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CreateFile -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CreateFile -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CreateFile -> m CreateFile
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CreateFile -> m CreateFile
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CreateFile
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CreateFile -> c CreateFile
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CreateFile)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CreateFile)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CreateFile -> c CreateFile
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CreateFile -> c CreateFile
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CreateFile
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CreateFile
$ctoConstr :: CreateFile -> Constr
toConstr :: CreateFile -> Constr
$cdataTypeOf :: CreateFile -> DataType
dataTypeOf :: CreateFile -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CreateFile)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CreateFile)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CreateFile)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CreateFile)
$cgmapT :: (forall b. Data b => b -> b) -> CreateFile -> CreateFile
gmapT :: (forall b. Data b => b -> b) -> CreateFile -> CreateFile
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CreateFile -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CreateFile -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CreateFile -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CreateFile -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CreateFile -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CreateFile -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CreateFile -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CreateFile -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CreateFile -> m CreateFile
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CreateFile -> m CreateFile
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CreateFile -> m CreateFile
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CreateFile -> m CreateFile
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CreateFile -> m CreateFile
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CreateFile -> m CreateFile
Data, Typeable, (forall x. CreateFile -> Rep CreateFile x)
-> (forall x. Rep CreateFile x -> CreateFile) -> Generic CreateFile
forall x. Rep CreateFile x -> CreateFile
forall x. CreateFile -> Rep CreateFile x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CreateFile -> Rep CreateFile x
from :: forall x. CreateFile -> Rep CreateFile x
$cto :: forall x. Rep CreateFile x -> CreateFile
to :: forall x. Rep CreateFile x -> CreateFile
Generic)

instance NFData CreateFile where rnf :: CreateFile -> ()
rnf = CreateFile -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary CreateFile

data UpdateFile = UpdateFile
    { UpdateFile -> Text
updateFilePath      :: !Text
    , UpdateFile -> Text
updateFileMessage   :: !Text
    , UpdateFile -> Text
updateFileContent   :: !Text
    , UpdateFile -> Text
updateFileSHA       :: !Text
    , UpdateFile -> Maybe Text
updateFileBranch    :: !(Maybe Text)
    , UpdateFile -> Maybe Author
updateFileAuthor    :: !(Maybe Author)
    , UpdateFile -> Maybe Author
updateFileCommitter :: !(Maybe Author)
    }
    deriving (UpdateFile -> UpdateFile -> Bool
(UpdateFile -> UpdateFile -> Bool)
-> (UpdateFile -> UpdateFile -> Bool) -> Eq UpdateFile
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UpdateFile -> UpdateFile -> Bool
== :: UpdateFile -> UpdateFile -> Bool
$c/= :: UpdateFile -> UpdateFile -> Bool
/= :: UpdateFile -> UpdateFile -> Bool
Eq, Eq UpdateFile
Eq UpdateFile =>
(UpdateFile -> UpdateFile -> Ordering)
-> (UpdateFile -> UpdateFile -> Bool)
-> (UpdateFile -> UpdateFile -> Bool)
-> (UpdateFile -> UpdateFile -> Bool)
-> (UpdateFile -> UpdateFile -> Bool)
-> (UpdateFile -> UpdateFile -> UpdateFile)
-> (UpdateFile -> UpdateFile -> UpdateFile)
-> Ord UpdateFile
UpdateFile -> UpdateFile -> Bool
UpdateFile -> UpdateFile -> Ordering
UpdateFile -> UpdateFile -> UpdateFile
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: UpdateFile -> UpdateFile -> Ordering
compare :: UpdateFile -> UpdateFile -> Ordering
$c< :: UpdateFile -> UpdateFile -> Bool
< :: UpdateFile -> UpdateFile -> Bool
$c<= :: UpdateFile -> UpdateFile -> Bool
<= :: UpdateFile -> UpdateFile -> Bool
$c> :: UpdateFile -> UpdateFile -> Bool
> :: UpdateFile -> UpdateFile -> Bool
$c>= :: UpdateFile -> UpdateFile -> Bool
>= :: UpdateFile -> UpdateFile -> Bool
$cmax :: UpdateFile -> UpdateFile -> UpdateFile
max :: UpdateFile -> UpdateFile -> UpdateFile
$cmin :: UpdateFile -> UpdateFile -> UpdateFile
min :: UpdateFile -> UpdateFile -> UpdateFile
Ord, Int -> UpdateFile -> ShowS
[UpdateFile] -> ShowS
UpdateFile -> String
(Int -> UpdateFile -> ShowS)
-> (UpdateFile -> String)
-> ([UpdateFile] -> ShowS)
-> Show UpdateFile
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UpdateFile -> ShowS
showsPrec :: Int -> UpdateFile -> ShowS
$cshow :: UpdateFile -> String
show :: UpdateFile -> String
$cshowList :: [UpdateFile] -> ShowS
showList :: [UpdateFile] -> ShowS
Show, Typeable UpdateFile
Typeable UpdateFile =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> UpdateFile -> c UpdateFile)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c UpdateFile)
-> (UpdateFile -> Constr)
-> (UpdateFile -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c UpdateFile))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c UpdateFile))
-> ((forall b. Data b => b -> b) -> UpdateFile -> UpdateFile)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> UpdateFile -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> UpdateFile -> r)
-> (forall u. (forall d. Data d => d -> u) -> UpdateFile -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> UpdateFile -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> UpdateFile -> m UpdateFile)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UpdateFile -> m UpdateFile)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UpdateFile -> m UpdateFile)
-> Data UpdateFile
UpdateFile -> Constr
UpdateFile -> DataType
(forall b. Data b => b -> b) -> UpdateFile -> UpdateFile
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> UpdateFile -> u
forall u. (forall d. Data d => d -> u) -> UpdateFile -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UpdateFile -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UpdateFile -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UpdateFile -> m UpdateFile
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UpdateFile -> m UpdateFile
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UpdateFile
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UpdateFile -> c UpdateFile
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UpdateFile)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UpdateFile)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UpdateFile -> c UpdateFile
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UpdateFile -> c UpdateFile
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UpdateFile
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UpdateFile
$ctoConstr :: UpdateFile -> Constr
toConstr :: UpdateFile -> Constr
$cdataTypeOf :: UpdateFile -> DataType
dataTypeOf :: UpdateFile -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UpdateFile)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UpdateFile)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UpdateFile)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UpdateFile)
$cgmapT :: (forall b. Data b => b -> b) -> UpdateFile -> UpdateFile
gmapT :: (forall b. Data b => b -> b) -> UpdateFile -> UpdateFile
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UpdateFile -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UpdateFile -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UpdateFile -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UpdateFile -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UpdateFile -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> UpdateFile -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UpdateFile -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UpdateFile -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UpdateFile -> m UpdateFile
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UpdateFile -> m UpdateFile
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UpdateFile -> m UpdateFile
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UpdateFile -> m UpdateFile
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UpdateFile -> m UpdateFile
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UpdateFile -> m UpdateFile
Data, Typeable, (forall x. UpdateFile -> Rep UpdateFile x)
-> (forall x. Rep UpdateFile x -> UpdateFile) -> Generic UpdateFile
forall x. Rep UpdateFile x -> UpdateFile
forall x. UpdateFile -> Rep UpdateFile x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UpdateFile -> Rep UpdateFile x
from :: forall x. UpdateFile -> Rep UpdateFile x
$cto :: forall x. Rep UpdateFile x -> UpdateFile
to :: forall x. Rep UpdateFile x -> UpdateFile
Generic)

instance NFData UpdateFile where rnf :: UpdateFile -> ()
rnf = UpdateFile -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary UpdateFile

data DeleteFile = DeleteFile
    { DeleteFile -> Text
deleteFilePath      :: !Text
    , DeleteFile -> Text
deleteFileMessage   :: !Text
    , DeleteFile -> Text
deleteFileSHA       :: !Text
    , DeleteFile -> Maybe Text
deleteFileBranch    :: !(Maybe Text)
    , DeleteFile -> Maybe Author
deleteFileAuthor    :: !(Maybe Author)
    , DeleteFile -> Maybe Author
deleteFileCommitter :: !(Maybe Author)
    }
    deriving (DeleteFile -> DeleteFile -> Bool
(DeleteFile -> DeleteFile -> Bool)
-> (DeleteFile -> DeleteFile -> Bool) -> Eq DeleteFile
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeleteFile -> DeleteFile -> Bool
== :: DeleteFile -> DeleteFile -> Bool
$c/= :: DeleteFile -> DeleteFile -> Bool
/= :: DeleteFile -> DeleteFile -> Bool
Eq, Eq DeleteFile
Eq DeleteFile =>
(DeleteFile -> DeleteFile -> Ordering)
-> (DeleteFile -> DeleteFile -> Bool)
-> (DeleteFile -> DeleteFile -> Bool)
-> (DeleteFile -> DeleteFile -> Bool)
-> (DeleteFile -> DeleteFile -> Bool)
-> (DeleteFile -> DeleteFile -> DeleteFile)
-> (DeleteFile -> DeleteFile -> DeleteFile)
-> Ord DeleteFile
DeleteFile -> DeleteFile -> Bool
DeleteFile -> DeleteFile -> Ordering
DeleteFile -> DeleteFile -> DeleteFile
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DeleteFile -> DeleteFile -> Ordering
compare :: DeleteFile -> DeleteFile -> Ordering
$c< :: DeleteFile -> DeleteFile -> Bool
< :: DeleteFile -> DeleteFile -> Bool
$c<= :: DeleteFile -> DeleteFile -> Bool
<= :: DeleteFile -> DeleteFile -> Bool
$c> :: DeleteFile -> DeleteFile -> Bool
> :: DeleteFile -> DeleteFile -> Bool
$c>= :: DeleteFile -> DeleteFile -> Bool
>= :: DeleteFile -> DeleteFile -> Bool
$cmax :: DeleteFile -> DeleteFile -> DeleteFile
max :: DeleteFile -> DeleteFile -> DeleteFile
$cmin :: DeleteFile -> DeleteFile -> DeleteFile
min :: DeleteFile -> DeleteFile -> DeleteFile
Ord, Int -> DeleteFile -> ShowS
[DeleteFile] -> ShowS
DeleteFile -> String
(Int -> DeleteFile -> ShowS)
-> (DeleteFile -> String)
-> ([DeleteFile] -> ShowS)
-> Show DeleteFile
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DeleteFile -> ShowS
showsPrec :: Int -> DeleteFile -> ShowS
$cshow :: DeleteFile -> String
show :: DeleteFile -> String
$cshowList :: [DeleteFile] -> ShowS
showList :: [DeleteFile] -> ShowS
Show, Typeable DeleteFile
Typeable DeleteFile =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DeleteFile -> c DeleteFile)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DeleteFile)
-> (DeleteFile -> Constr)
-> (DeleteFile -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DeleteFile))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DeleteFile))
-> ((forall b. Data b => b -> b) -> DeleteFile -> DeleteFile)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DeleteFile -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DeleteFile -> r)
-> (forall u. (forall d. Data d => d -> u) -> DeleteFile -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DeleteFile -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DeleteFile -> m DeleteFile)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeleteFile -> m DeleteFile)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeleteFile -> m DeleteFile)
-> Data DeleteFile
DeleteFile -> Constr
DeleteFile -> DataType
(forall b. Data b => b -> b) -> DeleteFile -> DeleteFile
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DeleteFile -> u
forall u. (forall d. Data d => d -> u) -> DeleteFile -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DeleteFile -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DeleteFile -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DeleteFile -> m DeleteFile
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DeleteFile -> m DeleteFile
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DeleteFile
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DeleteFile -> c DeleteFile
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DeleteFile)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeleteFile)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DeleteFile -> c DeleteFile
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DeleteFile -> c DeleteFile
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DeleteFile
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DeleteFile
$ctoConstr :: DeleteFile -> Constr
toConstr :: DeleteFile -> Constr
$cdataTypeOf :: DeleteFile -> DataType
dataTypeOf :: DeleteFile -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DeleteFile)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DeleteFile)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeleteFile)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeleteFile)
$cgmapT :: (forall b. Data b => b -> b) -> DeleteFile -> DeleteFile
gmapT :: (forall b. Data b => b -> b) -> DeleteFile -> DeleteFile
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DeleteFile -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DeleteFile -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DeleteFile -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DeleteFile -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DeleteFile -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DeleteFile -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DeleteFile -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DeleteFile -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DeleteFile -> m DeleteFile
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DeleteFile -> m DeleteFile
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DeleteFile -> m DeleteFile
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DeleteFile -> m DeleteFile
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DeleteFile -> m DeleteFile
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DeleteFile -> m DeleteFile
Data, Typeable, (forall x. DeleteFile -> Rep DeleteFile x)
-> (forall x. Rep DeleteFile x -> DeleteFile) -> Generic DeleteFile
forall x. Rep DeleteFile x -> DeleteFile
forall x. DeleteFile -> Rep DeleteFile x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DeleteFile -> Rep DeleteFile x
from :: forall x. DeleteFile -> Rep DeleteFile x
$cto :: forall x. Rep DeleteFile x -> DeleteFile
to :: forall x. Rep DeleteFile x -> DeleteFile
Generic)

instance NFData DeleteFile where rnf :: DeleteFile -> ()
rnf = DeleteFile -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary DeleteFile

instance FromJSON Content where
  parseJSON :: Value -> Parser Content
parseJSON o :: Value
o@(Object Object
_) = ContentFileData -> Content
ContentFile (ContentFileData -> Content)
-> Parser ContentFileData -> Parser Content
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser ContentFileData
forall a. FromJSON a => Value -> Parser a
parseJSON Value
o
  parseJSON (Array Array
os) = Vector ContentItem -> Content
ContentDirectory (Vector ContentItem -> Content)
-> Parser (Vector ContentItem) -> Parser Content
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value -> Parser ContentItem)
-> Array -> Parser (Vector ContentItem)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector a -> f (Vector b)
traverse Value -> Parser ContentItem
forall a. FromJSON a => Value -> Parser a
parseJSON Array
os
  parseJSON Value
_ = String -> Parser Content
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Could not build a Content"

instance FromJSON ContentFileData where
  parseJSON :: Value -> Parser ContentFileData
parseJSON = String
-> (Object -> Parser ContentFileData)
-> Value
-> Parser ContentFileData
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ContentFileData" ((Object -> Parser ContentFileData)
 -> Value -> Parser ContentFileData)
-> (Object -> Parser ContentFileData)
-> Value
-> Parser ContentFileData
forall a b. (a -> b) -> a -> b
$ \Object
o ->
    ContentInfo -> Text -> Int -> Text -> ContentFileData
ContentFileData (ContentInfo -> Text -> Int -> Text -> ContentFileData)
-> Parser ContentInfo
-> Parser (Text -> Int -> Text -> ContentFileData)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser ContentInfo
forall a. FromJSON a => Value -> Parser a
parseJSON (Object -> Value
Object Object
o)
                    Parser (Text -> Int -> Text -> ContentFileData)
-> Parser Text -> Parser (Int -> Text -> ContentFileData)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"encoding"
                    Parser (Int -> Text -> ContentFileData)
-> Parser Int -> Parser (Text -> ContentFileData)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"size"
                    Parser (Text -> ContentFileData)
-> Parser Text -> Parser ContentFileData
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"content"

instance FromJSON ContentItem where
  parseJSON :: Value -> Parser ContentItem
parseJSON = String
-> (Object -> Parser ContentItem) -> Value -> Parser ContentItem
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ContentItem" ((Object -> Parser ContentItem) -> Value -> Parser ContentItem)
-> (Object -> Parser ContentItem) -> Value -> Parser ContentItem
forall a b. (a -> b) -> a -> b
$ \Object
o ->
    ContentItemType -> ContentInfo -> ContentItem
ContentItem (ContentItemType -> ContentInfo -> ContentItem)
-> Parser ContentItemType -> Parser (ContentInfo -> ContentItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser ContentItemType
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
                Parser (ContentInfo -> ContentItem)
-> Parser ContentInfo -> Parser ContentItem
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Value -> Parser ContentInfo
forall a. FromJSON a => Value -> Parser a
parseJSON (Object -> Value
Object Object
o)

instance FromJSON ContentItemType where
  parseJSON :: Value -> Parser ContentItemType
parseJSON = String
-> (Text -> Parser ContentItemType)
-> Value
-> Parser ContentItemType
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"ContentItemType" ((Text -> Parser ContentItemType)
 -> Value -> Parser ContentItemType)
-> (Text -> Parser ContentItemType)
-> Value
-> Parser ContentItemType
forall a b. (a -> b) -> a -> b
$ \Text
t -> case Text -> Text
T.toLower Text
t of
    Text
"file" -> ContentItemType -> Parser ContentItemType
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ContentItemType
ItemFile
    Text
"dir"  -> ContentItemType -> Parser ContentItemType
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ContentItemType
ItemDir
    Text
_      -> String -> Parser ContentItemType
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser ContentItemType)
-> String -> Parser ContentItemType
forall a b. (a -> b) -> a -> b
$ String
"Unknown ContentItemType: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Text -> String
T.unpack Text
t

instance FromJSON ContentInfo where
  parseJSON :: Value -> Parser ContentInfo
parseJSON = String
-> (Object -> Parser ContentInfo) -> Value -> Parser ContentInfo
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ContentInfo" ((Object -> Parser ContentInfo) -> Value -> Parser ContentInfo)
-> (Object -> Parser ContentInfo) -> Value -> Parser ContentInfo
forall a b. (a -> b) -> a -> b
$ \Object
o ->
    Text -> Text -> Text -> URL -> URL -> URL -> ContentInfo
ContentInfo (Text -> Text -> Text -> URL -> URL -> URL -> ContentInfo)
-> Parser Text
-> Parser (Text -> Text -> URL -> URL -> URL -> ContentInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
                Parser (Text -> Text -> URL -> URL -> URL -> ContentInfo)
-> Parser Text -> Parser (Text -> URL -> URL -> URL -> ContentInfo)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path"
                Parser (Text -> URL -> URL -> URL -> ContentInfo)
-> Parser Text -> Parser (URL -> URL -> URL -> ContentInfo)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sha"
                Parser (URL -> URL -> URL -> ContentInfo)
-> Parser URL -> Parser (URL -> URL -> ContentInfo)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
                Parser (URL -> URL -> ContentInfo)
-> Parser URL -> Parser (URL -> ContentInfo)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"git_url"
                Parser (URL -> ContentInfo) -> Parser URL -> Parser ContentInfo
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"html_url"

instance FromJSON ContentResultInfo where
  parseJSON :: Value -> Parser ContentResultInfo
parseJSON = String
-> (Object -> Parser ContentResultInfo)
-> Value
-> Parser ContentResultInfo
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ContentResultInfo" ((Object -> Parser ContentResultInfo)
 -> Value -> Parser ContentResultInfo)
-> (Object -> Parser ContentResultInfo)
-> Value
-> Parser ContentResultInfo
forall a b. (a -> b) -> a -> b
$ \Object
o ->
    ContentInfo -> Int -> ContentResultInfo
ContentResultInfo (ContentInfo -> Int -> ContentResultInfo)
-> Parser ContentInfo -> Parser (Int -> ContentResultInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser ContentInfo
forall a. FromJSON a => Value -> Parser a
parseJSON (Object -> Value
Object Object
o)
                  Parser (Int -> ContentResultInfo)
-> Parser Int -> Parser ContentResultInfo
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"size"

instance FromJSON ContentResult where
  parseJSON :: Value -> Parser ContentResult
parseJSON = String
-> (Object -> Parser ContentResult)
-> Value
-> Parser ContentResult
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ContentResult" ((Object -> Parser ContentResult) -> Value -> Parser ContentResult)
-> (Object -> Parser ContentResult)
-> Value
-> Parser ContentResult
forall a b. (a -> b) -> a -> b
$ \Object
o ->
    ContentResultInfo -> GitCommit -> ContentResult
ContentResult (ContentResultInfo -> GitCommit -> ContentResult)
-> Parser ContentResultInfo -> Parser (GitCommit -> ContentResult)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser ContentResultInfo
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"content"
                  Parser (GitCommit -> ContentResult)
-> Parser GitCommit -> Parser ContentResult
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser GitCommit
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"commit"

instance ToJSON Author where
  toJSON :: Author -> Value
toJSON Author {Text
authorName :: Author -> Text
authorEmail :: Author -> Text
authorName :: Text
authorEmail :: Text
..} = [Pair] -> Value
object
    [ Key
"name"  Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
authorName
    , Key
"email" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
authorEmail
    ]

instance ToJSON CreateFile where
  toJSON :: CreateFile -> Value
toJSON CreateFile {Maybe Text
Maybe Author
Text
createFilePath :: CreateFile -> Text
createFileMessage :: CreateFile -> Text
createFileContent :: CreateFile -> Text
createFileBranch :: CreateFile -> Maybe Text
createFileAuthor :: CreateFile -> Maybe Author
createFileCommitter :: CreateFile -> Maybe Author
createFilePath :: Text
createFileMessage :: Text
createFileContent :: Text
createFileBranch :: Maybe Text
createFileAuthor :: Maybe Author
createFileCommitter :: Maybe Author
..} = [Pair] -> Value
object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$
    [ Key
"path"       Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
createFilePath
    , Key
"message"    Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
createFileMessage
    , Key
"content"    Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
createFileContent
    ]
    [Pair] -> [Pair] -> [Pair]
forall a. [a] -> [a] -> [a]
++ Key
"branch"    Key -> Maybe Text -> [Pair]
forall v. ToJSON v => Key -> Maybe v -> [Pair]
.=? Maybe Text
createFileBranch
    [Pair] -> [Pair] -> [Pair]
forall a. [a] -> [a] -> [a]
++ Key
"author"    Key -> Maybe Author -> [Pair]
forall v. ToJSON v => Key -> Maybe v -> [Pair]
.=? Maybe Author
createFileAuthor
    [Pair] -> [Pair] -> [Pair]
forall a. [a] -> [a] -> [a]
++ Key
"committer" Key -> Maybe Author -> [Pair]
forall v. ToJSON v => Key -> Maybe v -> [Pair]
.=? Maybe Author
createFileCommitter

instance ToJSON UpdateFile where
  toJSON :: UpdateFile -> Value
toJSON UpdateFile {Maybe Text
Maybe Author
Text
updateFilePath :: UpdateFile -> Text
updateFileMessage :: UpdateFile -> Text
updateFileContent :: UpdateFile -> Text
updateFileSHA :: UpdateFile -> Text
updateFileBranch :: UpdateFile -> Maybe Text
updateFileAuthor :: UpdateFile -> Maybe Author
updateFileCommitter :: UpdateFile -> Maybe Author
updateFilePath :: Text
updateFileMessage :: Text
updateFileContent :: Text
updateFileSHA :: Text
updateFileBranch :: Maybe Text
updateFileAuthor :: Maybe Author
updateFileCommitter :: Maybe Author
..} = [Pair] -> Value
object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$
    [ Key
"path"       Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
updateFilePath
    , Key
"message"    Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
updateFileMessage
    , Key
"content"    Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
updateFileContent
    , Key
"sha"        Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
updateFileSHA
    ]
    [Pair] -> [Pair] -> [Pair]
forall a. [a] -> [a] -> [a]
++ Key
"branch"    Key -> Maybe Text -> [Pair]
forall v. ToJSON v => Key -> Maybe v -> [Pair]
.=? Maybe Text
updateFileBranch
    [Pair] -> [Pair] -> [Pair]
forall a. [a] -> [a] -> [a]
++ Key
"author"    Key -> Maybe Author -> [Pair]
forall v. ToJSON v => Key -> Maybe v -> [Pair]
.=? Maybe Author
updateFileAuthor
    [Pair] -> [Pair] -> [Pair]
forall a. [a] -> [a] -> [a]
++ Key
"committer" Key -> Maybe Author -> [Pair]
forall v. ToJSON v => Key -> Maybe v -> [Pair]
.=? Maybe Author
updateFileCommitter

instance ToJSON DeleteFile where
  toJSON :: DeleteFile -> Value
toJSON DeleteFile {Maybe Text
Maybe Author
Text
deleteFilePath :: DeleteFile -> Text
deleteFileMessage :: DeleteFile -> Text
deleteFileSHA :: DeleteFile -> Text
deleteFileBranch :: DeleteFile -> Maybe Text
deleteFileAuthor :: DeleteFile -> Maybe Author
deleteFileCommitter :: DeleteFile -> Maybe Author
deleteFilePath :: Text
deleteFileMessage :: Text
deleteFileSHA :: Text
deleteFileBranch :: Maybe Text
deleteFileAuthor :: Maybe Author
deleteFileCommitter :: Maybe Author
..} = [Pair] -> Value
object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$
    [ Key
"path"       Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
deleteFilePath
    , Key
"message"    Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
deleteFileMessage
    , Key
"sha"        Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
deleteFileSHA
    ]
    [Pair] -> [Pair] -> [Pair]
forall a. [a] -> [a] -> [a]
++ Key
"branch"    Key -> Maybe Text -> [Pair]
forall v. ToJSON v => Key -> Maybe v -> [Pair]
.=? Maybe Text
deleteFileBranch
    [Pair] -> [Pair] -> [Pair]
forall a. [a] -> [a] -> [a]
++ Key
"author"    Key -> Maybe Author -> [Pair]
forall v. ToJSON v => Key -> Maybe v -> [Pair]
.=? Maybe Author
deleteFileAuthor
    [Pair] -> [Pair] -> [Pair]
forall a. [a] -> [a] -> [a]
++ Key
"committer" Key -> Maybe Author -> [Pair]
forall v. ToJSON v => Key -> Maybe v -> [Pair]
.=? Maybe Author
deleteFileCommitter

#if MIN_VERSION_aeson(2,0,0)
(.=?) :: ToJSON v => Key -> Maybe v -> [Pair]
#else
(.=?) :: ToJSON v => Text -> Maybe v -> [Pair]
#endif
Key
name .=? :: forall v. ToJSON v => Key -> Maybe v -> [Pair]
.=? Maybe v
value = [Pair] -> (v -> [Pair]) -> Maybe v -> [Pair]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (Pair -> [Pair]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Pair -> [Pair]) -> (v -> Pair) -> v -> [Pair]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Key
name Key -> v -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.=)) Maybe v
value