{-# LANGUAGE CPP               #-}
{-# LANGUAGE FlexibleInstances #-}
#define UNSAFE 1

-- |
-- This module also exports
-- @'FromJSON' a => 'FromJSON' ('HM.HashMap' 'Language' a)@
-- orphan-ish instance for @aeson < 1@

module GitHub.Data.Repos where

import GitHub.Data.Definitions
import GitHub.Data.Id          (Id)
import GitHub.Data.Name        (Name)
import GitHub.Data.Request     (IsPathPart (..))
import GitHub.Data.URL         (URL)
import GitHub.Internal.Prelude
import Prelude ()

import qualified Data.HashMap.Strict as HM
import qualified Data.Text as T
#if MIN_VERSION_aeson(1,0,0)
import Data.Aeson.Types (FromJSONKey (..), fromJSONKeyCoerce)
#else
#ifdef UNSAFE
import Unsafe.Coerce (unsafeCoerce)
#endif
#endif

data Repo = Repo
    { Repo -> Id Repo
repoId              :: !(Id Repo)
    , Repo -> Name Repo
repoName            :: !(Name Repo)
    , Repo -> SimpleOwner
repoOwner           :: !SimpleOwner
    , Repo -> Bool
repoPrivate         :: !Bool
    , Repo -> URL
repoHtmlUrl         :: !URL
    , Repo -> Maybe Text
repoDescription     :: !(Maybe Text)
    , Repo -> Maybe Bool
repoFork            :: !(Maybe Bool)
    , Repo -> URL
repoUrl             :: !URL
    , Repo -> Maybe URL
repoGitUrl          :: !(Maybe URL)
    , Repo -> Maybe URL
repoSshUrl          :: !(Maybe URL)
    , Repo -> Maybe URL
repoCloneUrl        :: !(Maybe URL)
    , Repo -> URL
repoHooksUrl        :: !URL
    , Repo -> Maybe URL
repoSvnUrl          :: !(Maybe URL)
    , Repo -> Maybe Text
repoHomepage        :: !(Maybe Text)
    , Repo -> Maybe Language
repoLanguage        :: !(Maybe Language)
    , Repo -> Int
repoForksCount      :: !Int
    , Repo -> Int
repoStargazersCount :: !Int
    , Repo -> Int
repoWatchersCount   :: !Int
    , Repo -> Maybe Int
repoSize            :: !(Maybe Int)
    , Repo -> Maybe Text
repoDefaultBranch   :: !(Maybe Text)
    , Repo -> Int
repoOpenIssuesCount :: !Int
    , Repo -> Maybe Bool
repoHasIssues       :: !(Maybe Bool)
    , Repo -> Maybe Bool
repoHasProjects     :: !(Maybe Bool)
    , Repo -> Maybe Bool
repoHasWiki         :: !(Maybe Bool)
    , Repo -> Maybe Bool
repoHasPages        :: !(Maybe Bool)
    , Repo -> Maybe Bool
repoHasDownloads    :: !(Maybe Bool)
    , Repo -> Bool
repoArchived        :: !Bool
    , Repo -> Bool
repoDisabled        :: !Bool
    , Repo -> Maybe UTCTime
repoPushedAt        :: !(Maybe UTCTime)   -- ^ this is Nothing for new repositories
    , Repo -> Maybe UTCTime
repoCreatedAt       :: !(Maybe UTCTime)
    , Repo -> Maybe UTCTime
repoUpdatedAt       :: !(Maybe UTCTime)
    , Repo -> Maybe RepoPermissions
repoPermissions     :: !(Maybe RepoPermissions) -- ^ Repository permissions as they relate to the authenticated user.
    }
    deriving (Int -> Repo -> ShowS
[Repo] -> ShowS
Repo -> String
(Int -> Repo -> ShowS)
-> (Repo -> String) -> ([Repo] -> ShowS) -> Show Repo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Repo -> ShowS
showsPrec :: Int -> Repo -> ShowS
$cshow :: Repo -> String
show :: Repo -> String
$cshowList :: [Repo] -> ShowS
showList :: [Repo] -> ShowS
Show, Typeable Repo
Typeable Repo =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Repo -> c Repo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Repo)
-> (Repo -> Constr)
-> (Repo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Repo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Repo))
-> ((forall b. Data b => b -> b) -> Repo -> Repo)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Repo -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Repo -> r)
-> (forall u. (forall d. Data d => d -> u) -> Repo -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Repo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Repo -> m Repo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Repo -> m Repo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Repo -> m Repo)
-> Data Repo
Repo -> Constr
Repo -> DataType
(forall b. Data b => b -> b) -> Repo -> Repo
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) -> Repo -> u
forall u. (forall d. Data d => d -> u) -> Repo -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Repo -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Repo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Repo -> m Repo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Repo -> m Repo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Repo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Repo -> c Repo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Repo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Repo)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Repo -> c Repo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Repo -> c Repo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Repo
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Repo
$ctoConstr :: Repo -> Constr
toConstr :: Repo -> Constr
$cdataTypeOf :: Repo -> DataType
dataTypeOf :: Repo -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Repo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Repo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Repo)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Repo)
$cgmapT :: (forall b. Data b => b -> b) -> Repo -> Repo
gmapT :: (forall b. Data b => b -> b) -> Repo -> Repo
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Repo -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Repo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Repo -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Repo -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Repo -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Repo -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Repo -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Repo -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Repo -> m Repo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Repo -> m Repo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Repo -> m Repo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Repo -> m Repo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Repo -> m Repo
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Repo -> m Repo
Data, Typeable, Repo -> Repo -> Bool
(Repo -> Repo -> Bool) -> (Repo -> Repo -> Bool) -> Eq Repo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Repo -> Repo -> Bool
== :: Repo -> Repo -> Bool
$c/= :: Repo -> Repo -> Bool
/= :: Repo -> Repo -> Bool
Eq, Eq Repo
Eq Repo =>
(Repo -> Repo -> Ordering)
-> (Repo -> Repo -> Bool)
-> (Repo -> Repo -> Bool)
-> (Repo -> Repo -> Bool)
-> (Repo -> Repo -> Bool)
-> (Repo -> Repo -> Repo)
-> (Repo -> Repo -> Repo)
-> Ord Repo
Repo -> Repo -> Bool
Repo -> Repo -> Ordering
Repo -> Repo -> Repo
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 :: Repo -> Repo -> Ordering
compare :: Repo -> Repo -> Ordering
$c< :: Repo -> Repo -> Bool
< :: Repo -> Repo -> Bool
$c<= :: Repo -> Repo -> Bool
<= :: Repo -> Repo -> Bool
$c> :: Repo -> Repo -> Bool
> :: Repo -> Repo -> Bool
$c>= :: Repo -> Repo -> Bool
>= :: Repo -> Repo -> Bool
$cmax :: Repo -> Repo -> Repo
max :: Repo -> Repo -> Repo
$cmin :: Repo -> Repo -> Repo
min :: Repo -> Repo -> Repo
Ord, (forall x. Repo -> Rep Repo x)
-> (forall x. Rep Repo x -> Repo) -> Generic Repo
forall x. Rep Repo x -> Repo
forall x. Repo -> Rep Repo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Repo -> Rep Repo x
from :: forall x. Repo -> Rep Repo x
$cto :: forall x. Rep Repo x -> Repo
to :: forall x. Rep Repo x -> Repo
Generic)

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

data CodeSearchRepo = CodeSearchRepo
    { CodeSearchRepo -> Id Repo
codeSearchRepoId              :: !(Id Repo)
    , CodeSearchRepo -> Name Repo
codeSearchRepoName            :: !(Name Repo)
    , CodeSearchRepo -> SimpleOwner
codeSearchRepoOwner           :: !SimpleOwner
    , CodeSearchRepo -> Bool
codeSearchRepoPrivate         :: !Bool
    , CodeSearchRepo -> URL
codeSearchRepoHtmlUrl         :: !URL
    , CodeSearchRepo -> Maybe Text
codeSearchRepoDescription     :: !(Maybe Text)
    , CodeSearchRepo -> Maybe Bool
codeSearchRepoFork            :: !(Maybe Bool)
    , CodeSearchRepo -> URL
codeSearchRepoUrl             :: !URL
    , CodeSearchRepo -> Maybe URL
codeSearchRepoGitUrl          :: !(Maybe URL)
    , CodeSearchRepo -> Maybe URL
codeSearchRepoSshUrl          :: !(Maybe URL)
    , CodeSearchRepo -> Maybe URL
codeSearchRepoCloneUrl        :: !(Maybe URL)
    , CodeSearchRepo -> URL
codeSearchRepoHooksUrl        :: !URL
    , CodeSearchRepo -> Maybe URL
codeSearchRepoSvnUrl          :: !(Maybe URL)
    , CodeSearchRepo -> Maybe Text
codeSearchRepoHomepage        :: !(Maybe Text)
    , CodeSearchRepo -> Maybe Language
codeSearchRepoLanguage        :: !(Maybe Language)
    , CodeSearchRepo -> Maybe Int
codeSearchRepoSize            :: !(Maybe Int)
    , CodeSearchRepo -> Maybe Text
codeSearchRepoDefaultBranch   :: !(Maybe Text)
    , CodeSearchRepo -> Maybe Bool
codeSearchRepoHasIssues       :: !(Maybe Bool)
    , CodeSearchRepo -> Maybe Bool
codeSearchRepoHasProjects     :: !(Maybe Bool)
    , CodeSearchRepo -> Maybe Bool
codeSearchRepoHasWiki         :: !(Maybe Bool)
    , CodeSearchRepo -> Maybe Bool
codeSearchRepoHasPages        :: !(Maybe Bool)
    , CodeSearchRepo -> Maybe Bool
codeSearchRepoHasDownloads    :: !(Maybe Bool)
    , CodeSearchRepo -> Bool
codeSearchRepoArchived        :: !Bool
    , CodeSearchRepo -> Bool
codeSearchRepoDisabled        :: !Bool
    , CodeSearchRepo -> Maybe UTCTime
codeSearchRepoPushedAt        :: !(Maybe UTCTime)   -- ^ this is Nothing for new repositories
    , CodeSearchRepo -> Maybe UTCTime
codeSearchRepoCreatedAt       :: !(Maybe UTCTime)
    , CodeSearchRepo -> Maybe UTCTime
codeSearchRepoUpdatedAt       :: !(Maybe UTCTime)
    , CodeSearchRepo -> Maybe RepoPermissions
codeSearchRepoPermissions     :: !(Maybe RepoPermissions) -- ^ Repository permissions as they relate to the authenticated user.
    }
    deriving (Int -> CodeSearchRepo -> ShowS
[CodeSearchRepo] -> ShowS
CodeSearchRepo -> String
(Int -> CodeSearchRepo -> ShowS)
-> (CodeSearchRepo -> String)
-> ([CodeSearchRepo] -> ShowS)
-> Show CodeSearchRepo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CodeSearchRepo -> ShowS
showsPrec :: Int -> CodeSearchRepo -> ShowS
$cshow :: CodeSearchRepo -> String
show :: CodeSearchRepo -> String
$cshowList :: [CodeSearchRepo] -> ShowS
showList :: [CodeSearchRepo] -> ShowS
Show, Typeable CodeSearchRepo
Typeable CodeSearchRepo =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CodeSearchRepo -> c CodeSearchRepo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CodeSearchRepo)
-> (CodeSearchRepo -> Constr)
-> (CodeSearchRepo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CodeSearchRepo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CodeSearchRepo))
-> ((forall b. Data b => b -> b)
    -> CodeSearchRepo -> CodeSearchRepo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CodeSearchRepo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CodeSearchRepo -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> CodeSearchRepo -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CodeSearchRepo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CodeSearchRepo -> m CodeSearchRepo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CodeSearchRepo -> m CodeSearchRepo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CodeSearchRepo -> m CodeSearchRepo)
-> Data CodeSearchRepo
CodeSearchRepo -> Constr
CodeSearchRepo -> DataType
(forall b. Data b => b -> b) -> CodeSearchRepo -> CodeSearchRepo
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) -> CodeSearchRepo -> u
forall u. (forall d. Data d => d -> u) -> CodeSearchRepo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CodeSearchRepo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CodeSearchRepo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CodeSearchRepo -> m CodeSearchRepo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CodeSearchRepo -> m CodeSearchRepo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CodeSearchRepo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CodeSearchRepo -> c CodeSearchRepo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CodeSearchRepo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CodeSearchRepo)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CodeSearchRepo -> c CodeSearchRepo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CodeSearchRepo -> c CodeSearchRepo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CodeSearchRepo
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CodeSearchRepo
$ctoConstr :: CodeSearchRepo -> Constr
toConstr :: CodeSearchRepo -> Constr
$cdataTypeOf :: CodeSearchRepo -> DataType
dataTypeOf :: CodeSearchRepo -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CodeSearchRepo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CodeSearchRepo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CodeSearchRepo)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CodeSearchRepo)
$cgmapT :: (forall b. Data b => b -> b) -> CodeSearchRepo -> CodeSearchRepo
gmapT :: (forall b. Data b => b -> b) -> CodeSearchRepo -> CodeSearchRepo
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CodeSearchRepo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CodeSearchRepo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CodeSearchRepo -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CodeSearchRepo -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CodeSearchRepo -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CodeSearchRepo -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CodeSearchRepo -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CodeSearchRepo -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CodeSearchRepo -> m CodeSearchRepo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CodeSearchRepo -> m CodeSearchRepo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CodeSearchRepo -> m CodeSearchRepo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CodeSearchRepo -> m CodeSearchRepo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CodeSearchRepo -> m CodeSearchRepo
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CodeSearchRepo -> m CodeSearchRepo
Data, Typeable, CodeSearchRepo -> CodeSearchRepo -> Bool
(CodeSearchRepo -> CodeSearchRepo -> Bool)
-> (CodeSearchRepo -> CodeSearchRepo -> Bool) -> Eq CodeSearchRepo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CodeSearchRepo -> CodeSearchRepo -> Bool
== :: CodeSearchRepo -> CodeSearchRepo -> Bool
$c/= :: CodeSearchRepo -> CodeSearchRepo -> Bool
/= :: CodeSearchRepo -> CodeSearchRepo -> Bool
Eq, Eq CodeSearchRepo
Eq CodeSearchRepo =>
(CodeSearchRepo -> CodeSearchRepo -> Ordering)
-> (CodeSearchRepo -> CodeSearchRepo -> Bool)
-> (CodeSearchRepo -> CodeSearchRepo -> Bool)
-> (CodeSearchRepo -> CodeSearchRepo -> Bool)
-> (CodeSearchRepo -> CodeSearchRepo -> Bool)
-> (CodeSearchRepo -> CodeSearchRepo -> CodeSearchRepo)
-> (CodeSearchRepo -> CodeSearchRepo -> CodeSearchRepo)
-> Ord CodeSearchRepo
CodeSearchRepo -> CodeSearchRepo -> Bool
CodeSearchRepo -> CodeSearchRepo -> Ordering
CodeSearchRepo -> CodeSearchRepo -> CodeSearchRepo
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 :: CodeSearchRepo -> CodeSearchRepo -> Ordering
compare :: CodeSearchRepo -> CodeSearchRepo -> Ordering
$c< :: CodeSearchRepo -> CodeSearchRepo -> Bool
< :: CodeSearchRepo -> CodeSearchRepo -> Bool
$c<= :: CodeSearchRepo -> CodeSearchRepo -> Bool
<= :: CodeSearchRepo -> CodeSearchRepo -> Bool
$c> :: CodeSearchRepo -> CodeSearchRepo -> Bool
> :: CodeSearchRepo -> CodeSearchRepo -> Bool
$c>= :: CodeSearchRepo -> CodeSearchRepo -> Bool
>= :: CodeSearchRepo -> CodeSearchRepo -> Bool
$cmax :: CodeSearchRepo -> CodeSearchRepo -> CodeSearchRepo
max :: CodeSearchRepo -> CodeSearchRepo -> CodeSearchRepo
$cmin :: CodeSearchRepo -> CodeSearchRepo -> CodeSearchRepo
min :: CodeSearchRepo -> CodeSearchRepo -> CodeSearchRepo
Ord, (forall x. CodeSearchRepo -> Rep CodeSearchRepo x)
-> (forall x. Rep CodeSearchRepo x -> CodeSearchRepo)
-> Generic CodeSearchRepo
forall x. Rep CodeSearchRepo x -> CodeSearchRepo
forall x. CodeSearchRepo -> Rep CodeSearchRepo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CodeSearchRepo -> Rep CodeSearchRepo x
from :: forall x. CodeSearchRepo -> Rep CodeSearchRepo x
$cto :: forall x. Rep CodeSearchRepo x -> CodeSearchRepo
to :: forall x. Rep CodeSearchRepo x -> CodeSearchRepo
Generic)

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

-- | Repository permissions, as they relate to the authenticated user.
--
-- Returned by for example 'GitHub.Endpoints.Repos.currentUserReposR'
data RepoPermissions = RepoPermissions
    { RepoPermissions -> Bool
repoPermissionAdmin :: !Bool
    , RepoPermissions -> Bool
repoPermissionPush :: !Bool
    , RepoPermissions -> Bool
repoPermissionPull :: !Bool
    }
    deriving (Int -> RepoPermissions -> ShowS
[RepoPermissions] -> ShowS
RepoPermissions -> String
(Int -> RepoPermissions -> ShowS)
-> (RepoPermissions -> String)
-> ([RepoPermissions] -> ShowS)
-> Show RepoPermissions
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RepoPermissions -> ShowS
showsPrec :: Int -> RepoPermissions -> ShowS
$cshow :: RepoPermissions -> String
show :: RepoPermissions -> String
$cshowList :: [RepoPermissions] -> ShowS
showList :: [RepoPermissions] -> ShowS
Show, Typeable RepoPermissions
Typeable RepoPermissions =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RepoPermissions -> c RepoPermissions)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RepoPermissions)
-> (RepoPermissions -> Constr)
-> (RepoPermissions -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RepoPermissions))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RepoPermissions))
-> ((forall b. Data b => b -> b)
    -> RepoPermissions -> RepoPermissions)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RepoPermissions -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RepoPermissions -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> RepoPermissions -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RepoPermissions -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> RepoPermissions -> m RepoPermissions)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RepoPermissions -> m RepoPermissions)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RepoPermissions -> m RepoPermissions)
-> Data RepoPermissions
RepoPermissions -> Constr
RepoPermissions -> DataType
(forall b. Data b => b -> b) -> RepoPermissions -> RepoPermissions
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) -> RepoPermissions -> u
forall u. (forall d. Data d => d -> u) -> RepoPermissions -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RepoPermissions -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RepoPermissions -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RepoPermissions -> m RepoPermissions
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RepoPermissions -> m RepoPermissions
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RepoPermissions
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RepoPermissions -> c RepoPermissions
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RepoPermissions)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RepoPermissions)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RepoPermissions -> c RepoPermissions
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RepoPermissions -> c RepoPermissions
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RepoPermissions
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RepoPermissions
$ctoConstr :: RepoPermissions -> Constr
toConstr :: RepoPermissions -> Constr
$cdataTypeOf :: RepoPermissions -> DataType
dataTypeOf :: RepoPermissions -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RepoPermissions)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RepoPermissions)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RepoPermissions)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RepoPermissions)
$cgmapT :: (forall b. Data b => b -> b) -> RepoPermissions -> RepoPermissions
gmapT :: (forall b. Data b => b -> b) -> RepoPermissions -> RepoPermissions
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RepoPermissions -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RepoPermissions -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RepoPermissions -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RepoPermissions -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RepoPermissions -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RepoPermissions -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> RepoPermissions -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> RepoPermissions -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RepoPermissions -> m RepoPermissions
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RepoPermissions -> m RepoPermissions
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RepoPermissions -> m RepoPermissions
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RepoPermissions -> m RepoPermissions
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RepoPermissions -> m RepoPermissions
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RepoPermissions -> m RepoPermissions
Data, Typeable, RepoPermissions -> RepoPermissions -> Bool
(RepoPermissions -> RepoPermissions -> Bool)
-> (RepoPermissions -> RepoPermissions -> Bool)
-> Eq RepoPermissions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RepoPermissions -> RepoPermissions -> Bool
== :: RepoPermissions -> RepoPermissions -> Bool
$c/= :: RepoPermissions -> RepoPermissions -> Bool
/= :: RepoPermissions -> RepoPermissions -> Bool
Eq, Eq RepoPermissions
Eq RepoPermissions =>
(RepoPermissions -> RepoPermissions -> Ordering)
-> (RepoPermissions -> RepoPermissions -> Bool)
-> (RepoPermissions -> RepoPermissions -> Bool)
-> (RepoPermissions -> RepoPermissions -> Bool)
-> (RepoPermissions -> RepoPermissions -> Bool)
-> (RepoPermissions -> RepoPermissions -> RepoPermissions)
-> (RepoPermissions -> RepoPermissions -> RepoPermissions)
-> Ord RepoPermissions
RepoPermissions -> RepoPermissions -> Bool
RepoPermissions -> RepoPermissions -> Ordering
RepoPermissions -> RepoPermissions -> RepoPermissions
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 :: RepoPermissions -> RepoPermissions -> Ordering
compare :: RepoPermissions -> RepoPermissions -> Ordering
$c< :: RepoPermissions -> RepoPermissions -> Bool
< :: RepoPermissions -> RepoPermissions -> Bool
$c<= :: RepoPermissions -> RepoPermissions -> Bool
<= :: RepoPermissions -> RepoPermissions -> Bool
$c> :: RepoPermissions -> RepoPermissions -> Bool
> :: RepoPermissions -> RepoPermissions -> Bool
$c>= :: RepoPermissions -> RepoPermissions -> Bool
>= :: RepoPermissions -> RepoPermissions -> Bool
$cmax :: RepoPermissions -> RepoPermissions -> RepoPermissions
max :: RepoPermissions -> RepoPermissions -> RepoPermissions
$cmin :: RepoPermissions -> RepoPermissions -> RepoPermissions
min :: RepoPermissions -> RepoPermissions -> RepoPermissions
Ord, (forall x. RepoPermissions -> Rep RepoPermissions x)
-> (forall x. Rep RepoPermissions x -> RepoPermissions)
-> Generic RepoPermissions
forall x. Rep RepoPermissions x -> RepoPermissions
forall x. RepoPermissions -> Rep RepoPermissions x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RepoPermissions -> Rep RepoPermissions x
from :: forall x. RepoPermissions -> Rep RepoPermissions x
$cto :: forall x. Rep RepoPermissions x -> RepoPermissions
to :: forall x. Rep RepoPermissions x -> RepoPermissions
Generic)

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

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

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

data NewRepo = NewRepo
    { NewRepo -> Name Repo
newRepoName              :: !(Name Repo)
    , NewRepo -> Maybe Text
newRepoDescription       :: !(Maybe Text)
    , NewRepo -> Maybe Text
newRepoHomepage          :: !(Maybe Text)
    , NewRepo -> Maybe Bool
newRepoPrivate           :: !(Maybe Bool)
    , NewRepo -> Maybe Bool
newRepoHasIssues         :: !(Maybe Bool)
    , NewRepo -> Maybe Bool
newRepoHasProjects       :: !(Maybe Bool)
    , NewRepo -> Maybe Bool
newRepoHasWiki           :: !(Maybe Bool)
    , NewRepo -> Maybe Bool
newRepoAutoInit          :: !(Maybe Bool)
    , NewRepo -> Maybe Text
newRepoGitignoreTemplate :: !(Maybe Text)
    , NewRepo -> Maybe Text
newRepoLicenseTemplate   :: !(Maybe Text)
    , NewRepo -> Maybe Bool
newRepoAllowSquashMerge  :: !(Maybe Bool)
    , NewRepo -> Maybe Bool
newRepoAllowMergeCommit  :: !(Maybe Bool)
    , NewRepo -> Maybe Bool
newRepoAllowRebaseMerge  :: !(Maybe Bool)
    } deriving (NewRepo -> NewRepo -> Bool
(NewRepo -> NewRepo -> Bool)
-> (NewRepo -> NewRepo -> Bool) -> Eq NewRepo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NewRepo -> NewRepo -> Bool
== :: NewRepo -> NewRepo -> Bool
$c/= :: NewRepo -> NewRepo -> Bool
/= :: NewRepo -> NewRepo -> Bool
Eq, Eq NewRepo
Eq NewRepo =>
(NewRepo -> NewRepo -> Ordering)
-> (NewRepo -> NewRepo -> Bool)
-> (NewRepo -> NewRepo -> Bool)
-> (NewRepo -> NewRepo -> Bool)
-> (NewRepo -> NewRepo -> Bool)
-> (NewRepo -> NewRepo -> NewRepo)
-> (NewRepo -> NewRepo -> NewRepo)
-> Ord NewRepo
NewRepo -> NewRepo -> Bool
NewRepo -> NewRepo -> Ordering
NewRepo -> NewRepo -> NewRepo
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 :: NewRepo -> NewRepo -> Ordering
compare :: NewRepo -> NewRepo -> Ordering
$c< :: NewRepo -> NewRepo -> Bool
< :: NewRepo -> NewRepo -> Bool
$c<= :: NewRepo -> NewRepo -> Bool
<= :: NewRepo -> NewRepo -> Bool
$c> :: NewRepo -> NewRepo -> Bool
> :: NewRepo -> NewRepo -> Bool
$c>= :: NewRepo -> NewRepo -> Bool
>= :: NewRepo -> NewRepo -> Bool
$cmax :: NewRepo -> NewRepo -> NewRepo
max :: NewRepo -> NewRepo -> NewRepo
$cmin :: NewRepo -> NewRepo -> NewRepo
min :: NewRepo -> NewRepo -> NewRepo
Ord, Int -> NewRepo -> ShowS
[NewRepo] -> ShowS
NewRepo -> String
(Int -> NewRepo -> ShowS)
-> (NewRepo -> String) -> ([NewRepo] -> ShowS) -> Show NewRepo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NewRepo -> ShowS
showsPrec :: Int -> NewRepo -> ShowS
$cshow :: NewRepo -> String
show :: NewRepo -> String
$cshowList :: [NewRepo] -> ShowS
showList :: [NewRepo] -> ShowS
Show, Typeable NewRepo
Typeable NewRepo =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NewRepo -> c NewRepo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NewRepo)
-> (NewRepo -> Constr)
-> (NewRepo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NewRepo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewRepo))
-> ((forall b. Data b => b -> b) -> NewRepo -> NewRepo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NewRepo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NewRepo -> r)
-> (forall u. (forall d. Data d => d -> u) -> NewRepo -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> NewRepo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NewRepo -> m NewRepo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NewRepo -> m NewRepo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NewRepo -> m NewRepo)
-> Data NewRepo
NewRepo -> Constr
NewRepo -> DataType
(forall b. Data b => b -> b) -> NewRepo -> NewRepo
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) -> NewRepo -> u
forall u. (forall d. Data d => d -> u) -> NewRepo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NewRepo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NewRepo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NewRepo -> m NewRepo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NewRepo -> m NewRepo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewRepo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewRepo -> c NewRepo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NewRepo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewRepo)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewRepo -> c NewRepo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewRepo -> c NewRepo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewRepo
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewRepo
$ctoConstr :: NewRepo -> Constr
toConstr :: NewRepo -> Constr
$cdataTypeOf :: NewRepo -> DataType
dataTypeOf :: NewRepo -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NewRepo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NewRepo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewRepo)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewRepo)
$cgmapT :: (forall b. Data b => b -> b) -> NewRepo -> NewRepo
gmapT :: (forall b. Data b => b -> b) -> NewRepo -> NewRepo
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NewRepo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NewRepo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NewRepo -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NewRepo -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NewRepo -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NewRepo -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NewRepo -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NewRepo -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NewRepo -> m NewRepo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NewRepo -> m NewRepo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NewRepo -> m NewRepo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NewRepo -> m NewRepo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NewRepo -> m NewRepo
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NewRepo -> m NewRepo
Data, Typeable, (forall x. NewRepo -> Rep NewRepo x)
-> (forall x. Rep NewRepo x -> NewRepo) -> Generic NewRepo
forall x. Rep NewRepo x -> NewRepo
forall x. NewRepo -> Rep NewRepo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NewRepo -> Rep NewRepo x
from :: forall x. NewRepo -> Rep NewRepo x
$cto :: forall x. Rep NewRepo x -> NewRepo
to :: forall x. Rep NewRepo x -> NewRepo
Generic)

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

newRepo :: Name Repo -> NewRepo
newRepo :: Name Repo -> NewRepo
newRepo Name Repo
name = Name Repo
-> Maybe Text
-> Maybe Text
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Text
-> Maybe Text
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> NewRepo
NewRepo Name Repo
name Maybe Text
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing

data EditRepo = EditRepo
    { EditRepo -> Maybe (Name Repo)
editName             :: !(Maybe (Name Repo))
    , EditRepo -> Maybe Text
editDescription      :: !(Maybe Text)
    , EditRepo -> Maybe Text
editHomepage         :: !(Maybe Text)
    , EditRepo -> Maybe Bool
editPrivate          :: !(Maybe Bool)
    , EditRepo -> Maybe Bool
editHasIssues        :: !(Maybe Bool)
    , EditRepo -> Maybe Bool
editHasProjects      :: !(Maybe Bool)
    , EditRepo -> Maybe Bool
editHasWiki          :: !(Maybe Bool)
    , EditRepo -> Maybe Text
editDefaultBranch    :: !(Maybe Text)
    , EditRepo -> Maybe Bool
editAllowSquashMerge :: !(Maybe Bool)
    , EditRepo -> Maybe Bool
editAllowMergeCommit :: !(Maybe Bool)
    , EditRepo -> Maybe Bool
editAllowRebaseMerge :: !(Maybe Bool)
    , EditRepo -> Maybe Bool
editArchived         :: !(Maybe Bool)
    }
    deriving (EditRepo -> EditRepo -> Bool
(EditRepo -> EditRepo -> Bool)
-> (EditRepo -> EditRepo -> Bool) -> Eq EditRepo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EditRepo -> EditRepo -> Bool
== :: EditRepo -> EditRepo -> Bool
$c/= :: EditRepo -> EditRepo -> Bool
/= :: EditRepo -> EditRepo -> Bool
Eq, Eq EditRepo
Eq EditRepo =>
(EditRepo -> EditRepo -> Ordering)
-> (EditRepo -> EditRepo -> Bool)
-> (EditRepo -> EditRepo -> Bool)
-> (EditRepo -> EditRepo -> Bool)
-> (EditRepo -> EditRepo -> Bool)
-> (EditRepo -> EditRepo -> EditRepo)
-> (EditRepo -> EditRepo -> EditRepo)
-> Ord EditRepo
EditRepo -> EditRepo -> Bool
EditRepo -> EditRepo -> Ordering
EditRepo -> EditRepo -> EditRepo
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 :: EditRepo -> EditRepo -> Ordering
compare :: EditRepo -> EditRepo -> Ordering
$c< :: EditRepo -> EditRepo -> Bool
< :: EditRepo -> EditRepo -> Bool
$c<= :: EditRepo -> EditRepo -> Bool
<= :: EditRepo -> EditRepo -> Bool
$c> :: EditRepo -> EditRepo -> Bool
> :: EditRepo -> EditRepo -> Bool
$c>= :: EditRepo -> EditRepo -> Bool
>= :: EditRepo -> EditRepo -> Bool
$cmax :: EditRepo -> EditRepo -> EditRepo
max :: EditRepo -> EditRepo -> EditRepo
$cmin :: EditRepo -> EditRepo -> EditRepo
min :: EditRepo -> EditRepo -> EditRepo
Ord, Int -> EditRepo -> ShowS
[EditRepo] -> ShowS
EditRepo -> String
(Int -> EditRepo -> ShowS)
-> (EditRepo -> String) -> ([EditRepo] -> ShowS) -> Show EditRepo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EditRepo -> ShowS
showsPrec :: Int -> EditRepo -> ShowS
$cshow :: EditRepo -> String
show :: EditRepo -> String
$cshowList :: [EditRepo] -> ShowS
showList :: [EditRepo] -> ShowS
Show, Typeable EditRepo
Typeable EditRepo =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> EditRepo -> c EditRepo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EditRepo)
-> (EditRepo -> Constr)
-> (EditRepo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EditRepo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EditRepo))
-> ((forall b. Data b => b -> b) -> EditRepo -> EditRepo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EditRepo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EditRepo -> r)
-> (forall u. (forall d. Data d => d -> u) -> EditRepo -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> EditRepo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EditRepo -> m EditRepo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EditRepo -> m EditRepo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EditRepo -> m EditRepo)
-> Data EditRepo
EditRepo -> Constr
EditRepo -> DataType
(forall b. Data b => b -> b) -> EditRepo -> EditRepo
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) -> EditRepo -> u
forall u. (forall d. Data d => d -> u) -> EditRepo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EditRepo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EditRepo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EditRepo -> m EditRepo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EditRepo -> m EditRepo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EditRepo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EditRepo -> c EditRepo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EditRepo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EditRepo)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EditRepo -> c EditRepo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EditRepo -> c EditRepo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EditRepo
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EditRepo
$ctoConstr :: EditRepo -> Constr
toConstr :: EditRepo -> Constr
$cdataTypeOf :: EditRepo -> DataType
dataTypeOf :: EditRepo -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EditRepo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EditRepo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EditRepo)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EditRepo)
$cgmapT :: (forall b. Data b => b -> b) -> EditRepo -> EditRepo
gmapT :: (forall b. Data b => b -> b) -> EditRepo -> EditRepo
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EditRepo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EditRepo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EditRepo -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EditRepo -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EditRepo -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> EditRepo -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EditRepo -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EditRepo -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EditRepo -> m EditRepo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EditRepo -> m EditRepo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EditRepo -> m EditRepo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EditRepo -> m EditRepo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EditRepo -> m EditRepo
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EditRepo -> m EditRepo
Data, Typeable, (forall x. EditRepo -> Rep EditRepo x)
-> (forall x. Rep EditRepo x -> EditRepo) -> Generic EditRepo
forall x. Rep EditRepo x -> EditRepo
forall x. EditRepo -> Rep EditRepo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. EditRepo -> Rep EditRepo x
from :: forall x. EditRepo -> Rep EditRepo x
$cto :: forall x. Rep EditRepo x -> EditRepo
to :: forall x. Rep EditRepo x -> EditRepo
Generic)

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

-- | Filter the list of the user's repos using any of these constructors.
data RepoPublicity
    = RepoPublicityAll     -- ^ All repos accessible to the user.
    | RepoPublicityOwner   -- ^ Only repos owned by the user.
    | RepoPublicityPublic  -- ^ Only public repos.
    | RepoPublicityPrivate -- ^ Only private repos.
    | RepoPublicityMember  -- ^ Only repos to which the user is a member but not an owner.
    deriving (Int -> RepoPublicity -> ShowS
[RepoPublicity] -> ShowS
RepoPublicity -> String
(Int -> RepoPublicity -> ShowS)
-> (RepoPublicity -> String)
-> ([RepoPublicity] -> ShowS)
-> Show RepoPublicity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RepoPublicity -> ShowS
showsPrec :: Int -> RepoPublicity -> ShowS
$cshow :: RepoPublicity -> String
show :: RepoPublicity -> String
$cshowList :: [RepoPublicity] -> ShowS
showList :: [RepoPublicity] -> ShowS
Show, RepoPublicity -> RepoPublicity -> Bool
(RepoPublicity -> RepoPublicity -> Bool)
-> (RepoPublicity -> RepoPublicity -> Bool) -> Eq RepoPublicity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RepoPublicity -> RepoPublicity -> Bool
== :: RepoPublicity -> RepoPublicity -> Bool
$c/= :: RepoPublicity -> RepoPublicity -> Bool
/= :: RepoPublicity -> RepoPublicity -> Bool
Eq, Eq RepoPublicity
Eq RepoPublicity =>
(RepoPublicity -> RepoPublicity -> Ordering)
-> (RepoPublicity -> RepoPublicity -> Bool)
-> (RepoPublicity -> RepoPublicity -> Bool)
-> (RepoPublicity -> RepoPublicity -> Bool)
-> (RepoPublicity -> RepoPublicity -> Bool)
-> (RepoPublicity -> RepoPublicity -> RepoPublicity)
-> (RepoPublicity -> RepoPublicity -> RepoPublicity)
-> Ord RepoPublicity
RepoPublicity -> RepoPublicity -> Bool
RepoPublicity -> RepoPublicity -> Ordering
RepoPublicity -> RepoPublicity -> RepoPublicity
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 :: RepoPublicity -> RepoPublicity -> Ordering
compare :: RepoPublicity -> RepoPublicity -> Ordering
$c< :: RepoPublicity -> RepoPublicity -> Bool
< :: RepoPublicity -> RepoPublicity -> Bool
$c<= :: RepoPublicity -> RepoPublicity -> Bool
<= :: RepoPublicity -> RepoPublicity -> Bool
$c> :: RepoPublicity -> RepoPublicity -> Bool
> :: RepoPublicity -> RepoPublicity -> Bool
$c>= :: RepoPublicity -> RepoPublicity -> Bool
>= :: RepoPublicity -> RepoPublicity -> Bool
$cmax :: RepoPublicity -> RepoPublicity -> RepoPublicity
max :: RepoPublicity -> RepoPublicity -> RepoPublicity
$cmin :: RepoPublicity -> RepoPublicity -> RepoPublicity
min :: RepoPublicity -> RepoPublicity -> RepoPublicity
Ord, Int -> RepoPublicity
RepoPublicity -> Int
RepoPublicity -> [RepoPublicity]
RepoPublicity -> RepoPublicity
RepoPublicity -> RepoPublicity -> [RepoPublicity]
RepoPublicity -> RepoPublicity -> RepoPublicity -> [RepoPublicity]
(RepoPublicity -> RepoPublicity)
-> (RepoPublicity -> RepoPublicity)
-> (Int -> RepoPublicity)
-> (RepoPublicity -> Int)
-> (RepoPublicity -> [RepoPublicity])
-> (RepoPublicity -> RepoPublicity -> [RepoPublicity])
-> (RepoPublicity -> RepoPublicity -> [RepoPublicity])
-> (RepoPublicity
    -> RepoPublicity -> RepoPublicity -> [RepoPublicity])
-> Enum RepoPublicity
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: RepoPublicity -> RepoPublicity
succ :: RepoPublicity -> RepoPublicity
$cpred :: RepoPublicity -> RepoPublicity
pred :: RepoPublicity -> RepoPublicity
$ctoEnum :: Int -> RepoPublicity
toEnum :: Int -> RepoPublicity
$cfromEnum :: RepoPublicity -> Int
fromEnum :: RepoPublicity -> Int
$cenumFrom :: RepoPublicity -> [RepoPublicity]
enumFrom :: RepoPublicity -> [RepoPublicity]
$cenumFromThen :: RepoPublicity -> RepoPublicity -> [RepoPublicity]
enumFromThen :: RepoPublicity -> RepoPublicity -> [RepoPublicity]
$cenumFromTo :: RepoPublicity -> RepoPublicity -> [RepoPublicity]
enumFromTo :: RepoPublicity -> RepoPublicity -> [RepoPublicity]
$cenumFromThenTo :: RepoPublicity -> RepoPublicity -> RepoPublicity -> [RepoPublicity]
enumFromThenTo :: RepoPublicity -> RepoPublicity -> RepoPublicity -> [RepoPublicity]
Enum, RepoPublicity
RepoPublicity -> RepoPublicity -> Bounded RepoPublicity
forall a. a -> a -> Bounded a
$cminBound :: RepoPublicity
minBound :: RepoPublicity
$cmaxBound :: RepoPublicity
maxBound :: RepoPublicity
Bounded, Typeable, Typeable RepoPublicity
Typeable RepoPublicity =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RepoPublicity -> c RepoPublicity)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RepoPublicity)
-> (RepoPublicity -> Constr)
-> (RepoPublicity -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RepoPublicity))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RepoPublicity))
-> ((forall b. Data b => b -> b) -> RepoPublicity -> RepoPublicity)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RepoPublicity -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RepoPublicity -> r)
-> (forall u. (forall d. Data d => d -> u) -> RepoPublicity -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RepoPublicity -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RepoPublicity -> m RepoPublicity)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RepoPublicity -> m RepoPublicity)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RepoPublicity -> m RepoPublicity)
-> Data RepoPublicity
RepoPublicity -> Constr
RepoPublicity -> DataType
(forall b. Data b => b -> b) -> RepoPublicity -> RepoPublicity
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) -> RepoPublicity -> u
forall u. (forall d. Data d => d -> u) -> RepoPublicity -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RepoPublicity -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RepoPublicity -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RepoPublicity -> m RepoPublicity
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RepoPublicity -> m RepoPublicity
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RepoPublicity
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RepoPublicity -> c RepoPublicity
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RepoPublicity)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RepoPublicity)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RepoPublicity -> c RepoPublicity
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RepoPublicity -> c RepoPublicity
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RepoPublicity
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RepoPublicity
$ctoConstr :: RepoPublicity -> Constr
toConstr :: RepoPublicity -> Constr
$cdataTypeOf :: RepoPublicity -> DataType
dataTypeOf :: RepoPublicity -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RepoPublicity)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RepoPublicity)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RepoPublicity)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RepoPublicity)
$cgmapT :: (forall b. Data b => b -> b) -> RepoPublicity -> RepoPublicity
gmapT :: (forall b. Data b => b -> b) -> RepoPublicity -> RepoPublicity
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RepoPublicity -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RepoPublicity -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RepoPublicity -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RepoPublicity -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RepoPublicity -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RepoPublicity -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RepoPublicity -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RepoPublicity -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RepoPublicity -> m RepoPublicity
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RepoPublicity -> m RepoPublicity
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RepoPublicity -> m RepoPublicity
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RepoPublicity -> m RepoPublicity
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RepoPublicity -> m RepoPublicity
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RepoPublicity -> m RepoPublicity
Data, (forall x. RepoPublicity -> Rep RepoPublicity x)
-> (forall x. Rep RepoPublicity x -> RepoPublicity)
-> Generic RepoPublicity
forall x. Rep RepoPublicity x -> RepoPublicity
forall x. RepoPublicity -> Rep RepoPublicity x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RepoPublicity -> Rep RepoPublicity x
from :: forall x. RepoPublicity -> Rep RepoPublicity x
$cto :: forall x. Rep RepoPublicity x -> RepoPublicity
to :: forall x. Rep RepoPublicity x -> RepoPublicity
Generic)

-- | The value is the number of bytes of code written in that language.
type Languages = HM.HashMap Language Int

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

getLanguage :: Language -> Text
getLanguage :: Language -> Text
getLanguage (Language Text
l) = Text
l

instance NFData Language where rnf :: Language -> ()
rnf = Language -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary Language
instance Hashable Language where
    hashWithSalt :: Int -> Language -> Int
hashWithSalt Int
salt (Language Text
l) = Int -> Text -> Int
forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
salt Text
l
instance IsString Language where
    fromString :: String -> Language
fromString = Text -> Language
Language (Text -> Language) -> (String -> Text) -> String -> Language
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
forall a. IsString a => String -> a
fromString

data Contributor
    -- | An existing Github user, with their number of contributions, avatar
    -- URL, login, URL, ID, and Gravatar ID.
    = KnownContributor !Int !URL !(Name User) !URL !(Id User) !Text
    -- | An unknown Github user with their number of contributions and recorded name.
    | AnonymousContributor !Int !Text
   deriving (Int -> Contributor -> ShowS
[Contributor] -> ShowS
Contributor -> String
(Int -> Contributor -> ShowS)
-> (Contributor -> String)
-> ([Contributor] -> ShowS)
-> Show Contributor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Contributor -> ShowS
showsPrec :: Int -> Contributor -> ShowS
$cshow :: Contributor -> String
show :: Contributor -> String
$cshowList :: [Contributor] -> ShowS
showList :: [Contributor] -> ShowS
Show, Typeable Contributor
Typeable Contributor =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Contributor -> c Contributor)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Contributor)
-> (Contributor -> Constr)
-> (Contributor -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Contributor))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Contributor))
-> ((forall b. Data b => b -> b) -> Contributor -> Contributor)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Contributor -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Contributor -> r)
-> (forall u. (forall d. Data d => d -> u) -> Contributor -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Contributor -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Contributor -> m Contributor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Contributor -> m Contributor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Contributor -> m Contributor)
-> Data Contributor
Contributor -> Constr
Contributor -> DataType
(forall b. Data b => b -> b) -> Contributor -> Contributor
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) -> Contributor -> u
forall u. (forall d. Data d => d -> u) -> Contributor -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Contributor -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Contributor -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Contributor -> m Contributor
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Contributor -> m Contributor
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Contributor
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Contributor -> c Contributor
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Contributor)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Contributor)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Contributor -> c Contributor
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Contributor -> c Contributor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Contributor
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Contributor
$ctoConstr :: Contributor -> Constr
toConstr :: Contributor -> Constr
$cdataTypeOf :: Contributor -> DataType
dataTypeOf :: Contributor -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Contributor)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Contributor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Contributor)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Contributor)
$cgmapT :: (forall b. Data b => b -> b) -> Contributor -> Contributor
gmapT :: (forall b. Data b => b -> b) -> Contributor -> Contributor
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Contributor -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Contributor -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Contributor -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Contributor -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Contributor -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Contributor -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Contributor -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Contributor -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Contributor -> m Contributor
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Contributor -> m Contributor
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Contributor -> m Contributor
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Contributor -> m Contributor
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Contributor -> m Contributor
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Contributor -> m Contributor
Data, Typeable, Contributor -> Contributor -> Bool
(Contributor -> Contributor -> Bool)
-> (Contributor -> Contributor -> Bool) -> Eq Contributor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Contributor -> Contributor -> Bool
== :: Contributor -> Contributor -> Bool
$c/= :: Contributor -> Contributor -> Bool
/= :: Contributor -> Contributor -> Bool
Eq, Eq Contributor
Eq Contributor =>
(Contributor -> Contributor -> Ordering)
-> (Contributor -> Contributor -> Bool)
-> (Contributor -> Contributor -> Bool)
-> (Contributor -> Contributor -> Bool)
-> (Contributor -> Contributor -> Bool)
-> (Contributor -> Contributor -> Contributor)
-> (Contributor -> Contributor -> Contributor)
-> Ord Contributor
Contributor -> Contributor -> Bool
Contributor -> Contributor -> Ordering
Contributor -> Contributor -> Contributor
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 :: Contributor -> Contributor -> Ordering
compare :: Contributor -> Contributor -> Ordering
$c< :: Contributor -> Contributor -> Bool
< :: Contributor -> Contributor -> Bool
$c<= :: Contributor -> Contributor -> Bool
<= :: Contributor -> Contributor -> Bool
$c> :: Contributor -> Contributor -> Bool
> :: Contributor -> Contributor -> Bool
$c>= :: Contributor -> Contributor -> Bool
>= :: Contributor -> Contributor -> Bool
$cmax :: Contributor -> Contributor -> Contributor
max :: Contributor -> Contributor -> Contributor
$cmin :: Contributor -> Contributor -> Contributor
min :: Contributor -> Contributor -> Contributor
Ord, (forall x. Contributor -> Rep Contributor x)
-> (forall x. Rep Contributor x -> Contributor)
-> Generic Contributor
forall x. Rep Contributor x -> Contributor
forall x. Contributor -> Rep Contributor x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Contributor -> Rep Contributor x
from :: forall x. Contributor -> Rep Contributor x
$cto :: forall x. Rep Contributor x -> Contributor
to :: forall x. Rep Contributor x -> Contributor
Generic)

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

contributorToSimpleUser :: Contributor -> Maybe SimpleUser
contributorToSimpleUser :: Contributor -> Maybe SimpleUser
contributorToSimpleUser (AnonymousContributor Int
_ Text
_) = Maybe SimpleUser
forall a. Maybe a
Nothing
contributorToSimpleUser (KnownContributor Int
_contributions URL
avatarUrl Name User
name URL
url Id User
uid Text
_gravatarid) =
    SimpleUser -> Maybe SimpleUser
forall a. a -> Maybe a
Just (SimpleUser -> Maybe SimpleUser) -> SimpleUser -> Maybe SimpleUser
forall a b. (a -> b) -> a -> b
$ Id User -> Name User -> URL -> URL -> SimpleUser
SimpleUser Id User
uid Name User
name URL
avatarUrl URL
url

-- | The permission of a collaborator on a repository.
-- See <https://developer.github.com/v3/repos/collaborators/#review-a-users-permission-level>
data CollaboratorPermission
    = CollaboratorPermissionAdmin
    | CollaboratorPermissionWrite
    | CollaboratorPermissionRead
    | CollaboratorPermissionNone
    deriving (Int -> CollaboratorPermission -> ShowS
[CollaboratorPermission] -> ShowS
CollaboratorPermission -> String
(Int -> CollaboratorPermission -> ShowS)
-> (CollaboratorPermission -> String)
-> ([CollaboratorPermission] -> ShowS)
-> Show CollaboratorPermission
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CollaboratorPermission -> ShowS
showsPrec :: Int -> CollaboratorPermission -> ShowS
$cshow :: CollaboratorPermission -> String
show :: CollaboratorPermission -> String
$cshowList :: [CollaboratorPermission] -> ShowS
showList :: [CollaboratorPermission] -> ShowS
Show, Typeable CollaboratorPermission
Typeable CollaboratorPermission =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> CollaboratorPermission
 -> c CollaboratorPermission)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CollaboratorPermission)
-> (CollaboratorPermission -> Constr)
-> (CollaboratorPermission -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CollaboratorPermission))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CollaboratorPermission))
-> ((forall b. Data b => b -> b)
    -> CollaboratorPermission -> CollaboratorPermission)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> CollaboratorPermission
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> CollaboratorPermission
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> CollaboratorPermission -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CollaboratorPermission -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CollaboratorPermission -> m CollaboratorPermission)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CollaboratorPermission -> m CollaboratorPermission)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CollaboratorPermission -> m CollaboratorPermission)
-> Data CollaboratorPermission
CollaboratorPermission -> Constr
CollaboratorPermission -> DataType
(forall b. Data b => b -> b)
-> CollaboratorPermission -> CollaboratorPermission
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) -> CollaboratorPermission -> u
forall u.
(forall d. Data d => d -> u) -> CollaboratorPermission -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> CollaboratorPermission
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> CollaboratorPermission
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CollaboratorPermission -> m CollaboratorPermission
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CollaboratorPermission -> m CollaboratorPermission
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CollaboratorPermission
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CollaboratorPermission
-> c CollaboratorPermission
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CollaboratorPermission)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CollaboratorPermission)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CollaboratorPermission
-> c CollaboratorPermission
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CollaboratorPermission
-> c CollaboratorPermission
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CollaboratorPermission
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CollaboratorPermission
$ctoConstr :: CollaboratorPermission -> Constr
toConstr :: CollaboratorPermission -> Constr
$cdataTypeOf :: CollaboratorPermission -> DataType
dataTypeOf :: CollaboratorPermission -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CollaboratorPermission)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CollaboratorPermission)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CollaboratorPermission)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CollaboratorPermission)
$cgmapT :: (forall b. Data b => b -> b)
-> CollaboratorPermission -> CollaboratorPermission
gmapT :: (forall b. Data b => b -> b)
-> CollaboratorPermission -> CollaboratorPermission
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> CollaboratorPermission
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> CollaboratorPermission
-> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> CollaboratorPermission
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> CollaboratorPermission
-> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> CollaboratorPermission -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> CollaboratorPermission -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CollaboratorPermission -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CollaboratorPermission -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CollaboratorPermission -> m CollaboratorPermission
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CollaboratorPermission -> m CollaboratorPermission
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CollaboratorPermission -> m CollaboratorPermission
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CollaboratorPermission -> m CollaboratorPermission
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CollaboratorPermission -> m CollaboratorPermission
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CollaboratorPermission -> m CollaboratorPermission
Data, Int -> CollaboratorPermission
CollaboratorPermission -> Int
CollaboratorPermission -> [CollaboratorPermission]
CollaboratorPermission -> CollaboratorPermission
CollaboratorPermission
-> CollaboratorPermission -> [CollaboratorPermission]
CollaboratorPermission
-> CollaboratorPermission
-> CollaboratorPermission
-> [CollaboratorPermission]
(CollaboratorPermission -> CollaboratorPermission)
-> (CollaboratorPermission -> CollaboratorPermission)
-> (Int -> CollaboratorPermission)
-> (CollaboratorPermission -> Int)
-> (CollaboratorPermission -> [CollaboratorPermission])
-> (CollaboratorPermission
    -> CollaboratorPermission -> [CollaboratorPermission])
-> (CollaboratorPermission
    -> CollaboratorPermission -> [CollaboratorPermission])
-> (CollaboratorPermission
    -> CollaboratorPermission
    -> CollaboratorPermission
    -> [CollaboratorPermission])
-> Enum CollaboratorPermission
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: CollaboratorPermission -> CollaboratorPermission
succ :: CollaboratorPermission -> CollaboratorPermission
$cpred :: CollaboratorPermission -> CollaboratorPermission
pred :: CollaboratorPermission -> CollaboratorPermission
$ctoEnum :: Int -> CollaboratorPermission
toEnum :: Int -> CollaboratorPermission
$cfromEnum :: CollaboratorPermission -> Int
fromEnum :: CollaboratorPermission -> Int
$cenumFrom :: CollaboratorPermission -> [CollaboratorPermission]
enumFrom :: CollaboratorPermission -> [CollaboratorPermission]
$cenumFromThen :: CollaboratorPermission
-> CollaboratorPermission -> [CollaboratorPermission]
enumFromThen :: CollaboratorPermission
-> CollaboratorPermission -> [CollaboratorPermission]
$cenumFromTo :: CollaboratorPermission
-> CollaboratorPermission -> [CollaboratorPermission]
enumFromTo :: CollaboratorPermission
-> CollaboratorPermission -> [CollaboratorPermission]
$cenumFromThenTo :: CollaboratorPermission
-> CollaboratorPermission
-> CollaboratorPermission
-> [CollaboratorPermission]
enumFromThenTo :: CollaboratorPermission
-> CollaboratorPermission
-> CollaboratorPermission
-> [CollaboratorPermission]
Enum, CollaboratorPermission
CollaboratorPermission
-> CollaboratorPermission -> Bounded CollaboratorPermission
forall a. a -> a -> Bounded a
$cminBound :: CollaboratorPermission
minBound :: CollaboratorPermission
$cmaxBound :: CollaboratorPermission
maxBound :: CollaboratorPermission
Bounded, Typeable, CollaboratorPermission -> CollaboratorPermission -> Bool
(CollaboratorPermission -> CollaboratorPermission -> Bool)
-> (CollaboratorPermission -> CollaboratorPermission -> Bool)
-> Eq CollaboratorPermission
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CollaboratorPermission -> CollaboratorPermission -> Bool
== :: CollaboratorPermission -> CollaboratorPermission -> Bool
$c/= :: CollaboratorPermission -> CollaboratorPermission -> Bool
/= :: CollaboratorPermission -> CollaboratorPermission -> Bool
Eq, Eq CollaboratorPermission
Eq CollaboratorPermission =>
(CollaboratorPermission -> CollaboratorPermission -> Ordering)
-> (CollaboratorPermission -> CollaboratorPermission -> Bool)
-> (CollaboratorPermission -> CollaboratorPermission -> Bool)
-> (CollaboratorPermission -> CollaboratorPermission -> Bool)
-> (CollaboratorPermission -> CollaboratorPermission -> Bool)
-> (CollaboratorPermission
    -> CollaboratorPermission -> CollaboratorPermission)
-> (CollaboratorPermission
    -> CollaboratorPermission -> CollaboratorPermission)
-> Ord CollaboratorPermission
CollaboratorPermission -> CollaboratorPermission -> Bool
CollaboratorPermission -> CollaboratorPermission -> Ordering
CollaboratorPermission
-> CollaboratorPermission -> CollaboratorPermission
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 :: CollaboratorPermission -> CollaboratorPermission -> Ordering
compare :: CollaboratorPermission -> CollaboratorPermission -> Ordering
$c< :: CollaboratorPermission -> CollaboratorPermission -> Bool
< :: CollaboratorPermission -> CollaboratorPermission -> Bool
$c<= :: CollaboratorPermission -> CollaboratorPermission -> Bool
<= :: CollaboratorPermission -> CollaboratorPermission -> Bool
$c> :: CollaboratorPermission -> CollaboratorPermission -> Bool
> :: CollaboratorPermission -> CollaboratorPermission -> Bool
$c>= :: CollaboratorPermission -> CollaboratorPermission -> Bool
>= :: CollaboratorPermission -> CollaboratorPermission -> Bool
$cmax :: CollaboratorPermission
-> CollaboratorPermission -> CollaboratorPermission
max :: CollaboratorPermission
-> CollaboratorPermission -> CollaboratorPermission
$cmin :: CollaboratorPermission
-> CollaboratorPermission -> CollaboratorPermission
min :: CollaboratorPermission
-> CollaboratorPermission -> CollaboratorPermission
Ord, (forall x. CollaboratorPermission -> Rep CollaboratorPermission x)
-> (forall x.
    Rep CollaboratorPermission x -> CollaboratorPermission)
-> Generic CollaboratorPermission
forall x. Rep CollaboratorPermission x -> CollaboratorPermission
forall x. CollaboratorPermission -> Rep CollaboratorPermission x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CollaboratorPermission -> Rep CollaboratorPermission x
from :: forall x. CollaboratorPermission -> Rep CollaboratorPermission x
$cto :: forall x. Rep CollaboratorPermission x -> CollaboratorPermission
to :: forall x. Rep CollaboratorPermission x -> CollaboratorPermission
Generic)

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

-- | A collaborator and its permission on a repository.
-- See <https://developer.github.com/v3/repos/collaborators/#review-a-users-permission-level>
data CollaboratorWithPermission
    = CollaboratorWithPermission SimpleUser CollaboratorPermission
    deriving (Int -> CollaboratorWithPermission -> ShowS
[CollaboratorWithPermission] -> ShowS
CollaboratorWithPermission -> String
(Int -> CollaboratorWithPermission -> ShowS)
-> (CollaboratorWithPermission -> String)
-> ([CollaboratorWithPermission] -> ShowS)
-> Show CollaboratorWithPermission
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CollaboratorWithPermission -> ShowS
showsPrec :: Int -> CollaboratorWithPermission -> ShowS
$cshow :: CollaboratorWithPermission -> String
show :: CollaboratorWithPermission -> String
$cshowList :: [CollaboratorWithPermission] -> ShowS
showList :: [CollaboratorWithPermission] -> ShowS
Show, Typeable CollaboratorWithPermission
Typeable CollaboratorWithPermission =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> CollaboratorWithPermission
 -> c CollaboratorWithPermission)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CollaboratorWithPermission)
-> (CollaboratorWithPermission -> Constr)
-> (CollaboratorWithPermission -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c CollaboratorWithPermission))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CollaboratorWithPermission))
-> ((forall b. Data b => b -> b)
    -> CollaboratorWithPermission -> CollaboratorWithPermission)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> CollaboratorWithPermission
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> CollaboratorWithPermission
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> CollaboratorWithPermission -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u) -> CollaboratorWithPermission -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CollaboratorWithPermission -> m CollaboratorWithPermission)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CollaboratorWithPermission -> m CollaboratorWithPermission)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CollaboratorWithPermission -> m CollaboratorWithPermission)
-> Data CollaboratorWithPermission
CollaboratorWithPermission -> Constr
CollaboratorWithPermission -> DataType
(forall b. Data b => b -> b)
-> CollaboratorWithPermission -> CollaboratorWithPermission
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) -> CollaboratorWithPermission -> u
forall u.
(forall d. Data d => d -> u) -> CollaboratorWithPermission -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> CollaboratorWithPermission
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> CollaboratorWithPermission
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CollaboratorWithPermission -> m CollaboratorWithPermission
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CollaboratorWithPermission -> m CollaboratorWithPermission
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CollaboratorWithPermission
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CollaboratorWithPermission
-> c CollaboratorWithPermission
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c CollaboratorWithPermission)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CollaboratorWithPermission)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CollaboratorWithPermission
-> c CollaboratorWithPermission
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CollaboratorWithPermission
-> c CollaboratorWithPermission
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CollaboratorWithPermission
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CollaboratorWithPermission
$ctoConstr :: CollaboratorWithPermission -> Constr
toConstr :: CollaboratorWithPermission -> Constr
$cdataTypeOf :: CollaboratorWithPermission -> DataType
dataTypeOf :: CollaboratorWithPermission -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c CollaboratorWithPermission)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c CollaboratorWithPermission)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CollaboratorWithPermission)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CollaboratorWithPermission)
$cgmapT :: (forall b. Data b => b -> b)
-> CollaboratorWithPermission -> CollaboratorWithPermission
gmapT :: (forall b. Data b => b -> b)
-> CollaboratorWithPermission -> CollaboratorWithPermission
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> CollaboratorWithPermission
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> CollaboratorWithPermission
-> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> CollaboratorWithPermission
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> CollaboratorWithPermission
-> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> CollaboratorWithPermission -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> CollaboratorWithPermission -> [u]
$cgmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> CollaboratorWithPermission -> u
gmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> CollaboratorWithPermission -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CollaboratorWithPermission -> m CollaboratorWithPermission
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CollaboratorWithPermission -> m CollaboratorWithPermission
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CollaboratorWithPermission -> m CollaboratorWithPermission
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CollaboratorWithPermission -> m CollaboratorWithPermission
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CollaboratorWithPermission -> m CollaboratorWithPermission
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CollaboratorWithPermission -> m CollaboratorWithPermission
Data, Typeable, CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
(CollaboratorWithPermission -> CollaboratorWithPermission -> Bool)
-> (CollaboratorWithPermission
    -> CollaboratorWithPermission -> Bool)
-> Eq CollaboratorWithPermission
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
== :: CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
$c/= :: CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
/= :: CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
Eq, Eq CollaboratorWithPermission
Eq CollaboratorWithPermission =>
(CollaboratorWithPermission
 -> CollaboratorWithPermission -> Ordering)
-> (CollaboratorWithPermission
    -> CollaboratorWithPermission -> Bool)
-> (CollaboratorWithPermission
    -> CollaboratorWithPermission -> Bool)
-> (CollaboratorWithPermission
    -> CollaboratorWithPermission -> Bool)
-> (CollaboratorWithPermission
    -> CollaboratorWithPermission -> Bool)
-> (CollaboratorWithPermission
    -> CollaboratorWithPermission -> CollaboratorWithPermission)
-> (CollaboratorWithPermission
    -> CollaboratorWithPermission -> CollaboratorWithPermission)
-> Ord CollaboratorWithPermission
CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
CollaboratorWithPermission
-> CollaboratorWithPermission -> Ordering
CollaboratorWithPermission
-> CollaboratorWithPermission -> CollaboratorWithPermission
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 :: CollaboratorWithPermission
-> CollaboratorWithPermission -> Ordering
compare :: CollaboratorWithPermission
-> CollaboratorWithPermission -> Ordering
$c< :: CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
< :: CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
$c<= :: CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
<= :: CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
$c> :: CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
> :: CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
$c>= :: CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
>= :: CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
$cmax :: CollaboratorWithPermission
-> CollaboratorWithPermission -> CollaboratorWithPermission
max :: CollaboratorWithPermission
-> CollaboratorWithPermission -> CollaboratorWithPermission
$cmin :: CollaboratorWithPermission
-> CollaboratorWithPermission -> CollaboratorWithPermission
min :: CollaboratorWithPermission
-> CollaboratorWithPermission -> CollaboratorWithPermission
Ord, (forall x.
 CollaboratorWithPermission -> Rep CollaboratorWithPermission x)
-> (forall x.
    Rep CollaboratorWithPermission x -> CollaboratorWithPermission)
-> Generic CollaboratorWithPermission
forall x.
Rep CollaboratorWithPermission x -> CollaboratorWithPermission
forall x.
CollaboratorWithPermission -> Rep CollaboratorWithPermission x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
CollaboratorWithPermission -> Rep CollaboratorWithPermission x
from :: forall x.
CollaboratorWithPermission -> Rep CollaboratorWithPermission x
$cto :: forall x.
Rep CollaboratorWithPermission x -> CollaboratorWithPermission
to :: forall x.
Rep CollaboratorWithPermission x -> CollaboratorWithPermission
Generic)

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

-- JSON instances

instance FromJSON Repo where
    parseJSON :: Value -> Parser Repo
parseJSON = String -> (Object -> Parser Repo) -> Value -> Parser Repo
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Repo" ((Object -> Parser Repo) -> Value -> Parser Repo)
-> (Object -> Parser Repo) -> Value -> Parser Repo
forall a b. (a -> b) -> a -> b
$ \Object
o -> Id Repo
-> Name Repo
-> SimpleOwner
-> Bool
-> URL
-> Maybe Text
-> Maybe Bool
-> URL
-> Maybe URL
-> Maybe URL
-> Maybe URL
-> URL
-> Maybe URL
-> Maybe Text
-> Maybe Language
-> Int
-> Int
-> Int
-> Maybe Int
-> Maybe Text
-> Int
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Bool
-> Bool
-> Maybe UTCTime
-> Maybe UTCTime
-> Maybe UTCTime
-> Maybe RepoPermissions
-> Repo
Repo (Id Repo
 -> Name Repo
 -> SimpleOwner
 -> Bool
 -> URL
 -> Maybe Text
 -> Maybe Bool
 -> URL
 -> Maybe URL
 -> Maybe URL
 -> Maybe URL
 -> URL
 -> Maybe URL
 -> Maybe Text
 -> Maybe Language
 -> Int
 -> Int
 -> Int
 -> Maybe Int
 -> Maybe Text
 -> Int
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Bool
 -> Bool
 -> Bool
 -> Maybe UTCTime
 -> Maybe UTCTime
 -> Maybe UTCTime
 -> Maybe RepoPermissions
 -> Repo)
-> Parser (Id Repo)
-> Parser
     (Name Repo
      -> SimpleOwner
      -> Bool
      -> URL
      -> Maybe Text
      -> Maybe Bool
      -> URL
      -> Maybe URL
      -> Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Int
      -> Int
      -> Int
      -> Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Id Repo)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
        Parser
  (Name Repo
   -> SimpleOwner
   -> Bool
   -> URL
   -> Maybe Text
   -> Maybe Bool
   -> URL
   -> Maybe URL
   -> Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Int
   -> Int
   -> Int
   -> Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser (Name Repo)
-> Parser
     (SimpleOwner
      -> Bool
      -> URL
      -> Maybe Text
      -> Maybe Bool
      -> URL
      -> Maybe URL
      -> Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Int
      -> Int
      -> Int
      -> Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 (Name Repo)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
        Parser
  (SimpleOwner
   -> Bool
   -> URL
   -> Maybe Text
   -> Maybe Bool
   -> URL
   -> Maybe URL
   -> Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Int
   -> Int
   -> Int
   -> Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser SimpleOwner
-> Parser
     (Bool
      -> URL
      -> Maybe Text
      -> Maybe Bool
      -> URL
      -> Maybe URL
      -> Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Int
      -> Int
      -> Int
      -> Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 SimpleOwner
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner"
        Parser
  (Bool
   -> URL
   -> Maybe Text
   -> Maybe Bool
   -> URL
   -> Maybe URL
   -> Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Int
   -> Int
   -> Int
   -> Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser Bool
-> Parser
     (URL
      -> Maybe Text
      -> Maybe Bool
      -> URL
      -> Maybe URL
      -> Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Int
      -> Int
      -> Int
      -> Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"private"
        Parser
  (URL
   -> Maybe Text
   -> Maybe Bool
   -> URL
   -> Maybe URL
   -> Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Int
   -> Int
   -> Int
   -> Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser URL
-> Parser
     (Maybe Text
      -> Maybe Bool
      -> URL
      -> Maybe URL
      -> Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Int
      -> Int
      -> Int
      -> Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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"
        Parser
  (Maybe Text
   -> Maybe Bool
   -> URL
   -> Maybe URL
   -> Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Int
   -> Int
   -> Int
   -> Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser (Maybe Text)
-> Parser
     (Maybe Bool
      -> URL
      -> Maybe URL
      -> Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Int
      -> Int
      -> Int
      -> Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"description"
        Parser
  (Maybe Bool
   -> URL
   -> Maybe URL
   -> Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Int
   -> Int
   -> Int
   -> Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser (Maybe Bool)
-> Parser
     (URL
      -> Maybe URL
      -> Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Int
      -> Int
      -> Int
      -> Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"fork"
        Parser
  (URL
   -> Maybe URL
   -> Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Int
   -> Int
   -> Int
   -> Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser URL
-> Parser
     (Maybe URL
      -> Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Int
      -> Int
      -> Int
      -> Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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
  (Maybe URL
   -> Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Int
   -> Int
   -> Int
   -> Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser (Maybe URL)
-> Parser
     (Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Int
      -> Int
      -> Int
      -> Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 (Maybe URL)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"git_url"
        Parser
  (Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Int
   -> Int
   -> Int
   -> Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser (Maybe URL)
-> Parser
     (Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Int
      -> Int
      -> Int
      -> Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 (Maybe URL)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"ssh_url"
        Parser
  (Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Int
   -> Int
   -> Int
   -> Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser (Maybe URL)
-> Parser
     (URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Int
      -> Int
      -> Int
      -> Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 (Maybe URL)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"clone_url"
        Parser
  (URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Int
   -> Int
   -> Int
   -> Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser URL
-> Parser
     (Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Int
      -> Int
      -> Int
      -> Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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
"hooks_url"
        Parser
  (Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Int
   -> Int
   -> Int
   -> Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser (Maybe URL)
-> Parser
     (Maybe Text
      -> Maybe Language
      -> Int
      -> Int
      -> Int
      -> Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 (Maybe URL)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"svn_url"
        Parser
  (Maybe Text
   -> Maybe Language
   -> Int
   -> Int
   -> Int
   -> Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser (Maybe Text)
-> Parser
     (Maybe Language
      -> Int
      -> Int
      -> Int
      -> Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"homepage"
        Parser
  (Maybe Language
   -> Int
   -> Int
   -> Int
   -> Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser (Maybe Language)
-> Parser
     (Int
      -> Int
      -> Int
      -> Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 (Maybe Language)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"language"
        Parser
  (Int
   -> Int
   -> Int
   -> Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser Int
-> Parser
     (Int
      -> Int
      -> Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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
"forks_count"
        Parser
  (Int
   -> Int
   -> Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser Int
-> Parser
     (Int
      -> Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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
"stargazers_count"
        Parser
  (Int
   -> Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser Int
-> Parser
     (Maybe Int
      -> Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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
"watchers_count"
        Parser
  (Maybe Int
   -> Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser (Maybe Int)
-> Parser
     (Maybe Text
      -> Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 (Maybe Int)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"size"
        Parser
  (Maybe Text
   -> Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser (Maybe Text)
-> Parser
     (Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"default_branch"
        Parser
  (Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser Int
-> Parser
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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
"open_issues_count"
        Parser
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"has_issues"
        Parser
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"has_projects"
        Parser
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"has_wiki"
        Parser
  (Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"has_pages"
        Parser
  (Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser (Maybe Bool)
-> Parser
     (Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"has_downloads"
        Parser
  (Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser Bool
-> Parser
     (Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> Repo)
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 (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"archived" Parser (Maybe Bool) -> Bool -> Parser Bool
forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False
        Parser
  (Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> Repo)
-> Parser Bool
-> Parser
     (Maybe UTCTime
      -> Maybe UTCTime -> Maybe UTCTime -> Maybe RepoPermissions -> Repo)
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 (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"disabled" Parser (Maybe Bool) -> Bool -> Parser Bool
forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False
        Parser
  (Maybe UTCTime
   -> Maybe UTCTime -> Maybe UTCTime -> Maybe RepoPermissions -> Repo)
-> Parser (Maybe UTCTime)
-> Parser
     (Maybe UTCTime -> Maybe UTCTime -> Maybe RepoPermissions -> Repo)
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 (Maybe UTCTime)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"pushed_at"
        Parser
  (Maybe UTCTime -> Maybe UTCTime -> Maybe RepoPermissions -> Repo)
-> Parser (Maybe UTCTime)
-> Parser (Maybe UTCTime -> Maybe RepoPermissions -> Repo)
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 (Maybe UTCTime)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"created_at"
        Parser (Maybe UTCTime -> Maybe RepoPermissions -> Repo)
-> Parser (Maybe UTCTime) -> Parser (Maybe RepoPermissions -> Repo)
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 (Maybe UTCTime)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"updated_at"
        Parser (Maybe RepoPermissions -> Repo)
-> Parser (Maybe RepoPermissions) -> Parser Repo
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 (Maybe RepoPermissions)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"permissions"

instance FromJSON CodeSearchRepo where
    parseJSON :: Value -> Parser CodeSearchRepo
parseJSON = String
-> (Object -> Parser CodeSearchRepo)
-> Value
-> Parser CodeSearchRepo
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Repo" ((Object -> Parser CodeSearchRepo)
 -> Value -> Parser CodeSearchRepo)
-> (Object -> Parser CodeSearchRepo)
-> Value
-> Parser CodeSearchRepo
forall a b. (a -> b) -> a -> b
$ \Object
o -> Id Repo
-> Name Repo
-> SimpleOwner
-> Bool
-> URL
-> Maybe Text
-> Maybe Bool
-> URL
-> Maybe URL
-> Maybe URL
-> Maybe URL
-> URL
-> Maybe URL
-> Maybe Text
-> Maybe Language
-> Maybe Int
-> Maybe Text
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Bool
-> Bool
-> Maybe UTCTime
-> Maybe UTCTime
-> Maybe UTCTime
-> Maybe RepoPermissions
-> CodeSearchRepo
CodeSearchRepo (Id Repo
 -> Name Repo
 -> SimpleOwner
 -> Bool
 -> URL
 -> Maybe Text
 -> Maybe Bool
 -> URL
 -> Maybe URL
 -> Maybe URL
 -> Maybe URL
 -> URL
 -> Maybe URL
 -> Maybe Text
 -> Maybe Language
 -> Maybe Int
 -> Maybe Text
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Bool
 -> Bool
 -> Bool
 -> Maybe UTCTime
 -> Maybe UTCTime
 -> Maybe UTCTime
 -> Maybe RepoPermissions
 -> CodeSearchRepo)
-> Parser (Id Repo)
-> Parser
     (Name Repo
      -> SimpleOwner
      -> Bool
      -> URL
      -> Maybe Text
      -> Maybe Bool
      -> URL
      -> Maybe URL
      -> Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Maybe Int
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Id Repo)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
        Parser
  (Name Repo
   -> SimpleOwner
   -> Bool
   -> URL
   -> Maybe Text
   -> Maybe Bool
   -> URL
   -> Maybe URL
   -> Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Maybe Int
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser (Name Repo)
-> Parser
     (SimpleOwner
      -> Bool
      -> URL
      -> Maybe Text
      -> Maybe Bool
      -> URL
      -> Maybe URL
      -> Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Maybe Int
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Name Repo)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
        Parser
  (SimpleOwner
   -> Bool
   -> URL
   -> Maybe Text
   -> Maybe Bool
   -> URL
   -> Maybe URL
   -> Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Maybe Int
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser SimpleOwner
-> Parser
     (Bool
      -> URL
      -> Maybe Text
      -> Maybe Bool
      -> URL
      -> Maybe URL
      -> Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Maybe Int
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 SimpleOwner
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner"
        Parser
  (Bool
   -> URL
   -> Maybe Text
   -> Maybe Bool
   -> URL
   -> Maybe URL
   -> Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Maybe Int
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser Bool
-> Parser
     (URL
      -> Maybe Text
      -> Maybe Bool
      -> URL
      -> Maybe URL
      -> Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Maybe Int
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"private"
        Parser
  (URL
   -> Maybe Text
   -> Maybe Bool
   -> URL
   -> Maybe URL
   -> Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Maybe Int
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser URL
-> Parser
     (Maybe Text
      -> Maybe Bool
      -> URL
      -> Maybe URL
      -> Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Maybe Int
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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"
        Parser
  (Maybe Text
   -> Maybe Bool
   -> URL
   -> Maybe URL
   -> Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Maybe Int
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser (Maybe Text)
-> Parser
     (Maybe Bool
      -> URL
      -> Maybe URL
      -> Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Maybe Int
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"description"
        Parser
  (Maybe Bool
   -> URL
   -> Maybe URL
   -> Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Maybe Int
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser (Maybe Bool)
-> Parser
     (URL
      -> Maybe URL
      -> Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Maybe Int
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"fork"
        Parser
  (URL
   -> Maybe URL
   -> Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Maybe Int
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser URL
-> Parser
     (Maybe URL
      -> Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Maybe Int
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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
  (Maybe URL
   -> Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Maybe Int
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser (Maybe URL)
-> Parser
     (Maybe URL
      -> Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Maybe Int
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Maybe URL)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"git_url"
        Parser
  (Maybe URL
   -> Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Maybe Int
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser (Maybe URL)
-> Parser
     (Maybe URL
      -> URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Maybe Int
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Maybe URL)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"ssh_url"
        Parser
  (Maybe URL
   -> URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Maybe Int
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser (Maybe URL)
-> Parser
     (URL
      -> Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Maybe Int
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Maybe URL)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"clone_url"
        Parser
  (URL
   -> Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Maybe Int
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser URL
-> Parser
     (Maybe URL
      -> Maybe Text
      -> Maybe Language
      -> Maybe Int
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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
"hooks_url"
        Parser
  (Maybe URL
   -> Maybe Text
   -> Maybe Language
   -> Maybe Int
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser (Maybe URL)
-> Parser
     (Maybe Text
      -> Maybe Language
      -> Maybe Int
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Maybe URL)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"svn_url"
        Parser
  (Maybe Text
   -> Maybe Language
   -> Maybe Int
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser (Maybe Text)
-> Parser
     (Maybe Language
      -> Maybe Int
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"homepage"
        Parser
  (Maybe Language
   -> Maybe Int
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser (Maybe Language)
-> Parser
     (Maybe Int
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Maybe Language)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"language"
        Parser
  (Maybe Int
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser (Maybe Int)
-> Parser
     (Maybe Text
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Maybe Int)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"size"
        Parser
  (Maybe Text
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser (Maybe Text)
-> Parser
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"default_branch"
        Parser
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"has_issues"
        Parser
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"has_projects"
        Parser
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Bool
      -> Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"has_wiki"
        Parser
  (Maybe Bool
   -> Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Bool
      -> Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"has_pages"
        Parser
  (Maybe Bool
   -> Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser (Maybe Bool)
-> Parser
     (Bool
      -> Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"has_downloads"
        Parser
  (Bool
   -> Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser Bool
-> Parser
     (Bool
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"archived" Parser (Maybe Bool) -> Bool -> Parser Bool
forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False
        Parser
  (Bool
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser Bool
-> Parser
     (Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe UTCTime
      -> Maybe RepoPermissions
      -> CodeSearchRepo)
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 (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"disabled" Parser (Maybe Bool) -> Bool -> Parser Bool
forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False
        Parser
  (Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe UTCTime
   -> Maybe RepoPermissions
   -> CodeSearchRepo)
-> Parser (Maybe UTCTime)
-> Parser
     (Maybe UTCTime
      -> Maybe UTCTime -> Maybe RepoPermissions -> CodeSearchRepo)
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 (Maybe UTCTime)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"pushed_at"
        Parser
  (Maybe UTCTime
   -> Maybe UTCTime -> Maybe RepoPermissions -> CodeSearchRepo)
-> Parser (Maybe UTCTime)
-> Parser
     (Maybe UTCTime -> Maybe RepoPermissions -> CodeSearchRepo)
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 (Maybe UTCTime)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"created_at"
        Parser (Maybe UTCTime -> Maybe RepoPermissions -> CodeSearchRepo)
-> Parser (Maybe UTCTime)
-> Parser (Maybe RepoPermissions -> CodeSearchRepo)
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 (Maybe UTCTime)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"updated_at"
        Parser (Maybe RepoPermissions -> CodeSearchRepo)
-> Parser (Maybe RepoPermissions) -> Parser CodeSearchRepo
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 (Maybe RepoPermissions)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"permissions"

instance ToJSON NewRepo where
  toJSON :: NewRepo -> Value
toJSON (NewRepo { newRepoName :: NewRepo -> Name Repo
newRepoName              = Name Repo
name
                  , newRepoDescription :: NewRepo -> Maybe Text
newRepoDescription       = Maybe Text
description
                  , newRepoHomepage :: NewRepo -> Maybe Text
newRepoHomepage          = Maybe Text
homepage
                  , newRepoPrivate :: NewRepo -> Maybe Bool
newRepoPrivate           = Maybe Bool
private
                  , newRepoHasIssues :: NewRepo -> Maybe Bool
newRepoHasIssues         = Maybe Bool
hasIssues
                  , newRepoHasProjects :: NewRepo -> Maybe Bool
newRepoHasProjects       = Maybe Bool
hasProjects
                  , newRepoHasWiki :: NewRepo -> Maybe Bool
newRepoHasWiki           = Maybe Bool
hasWiki
                  , newRepoAutoInit :: NewRepo -> Maybe Bool
newRepoAutoInit          = Maybe Bool
autoInit
                  , newRepoGitignoreTemplate :: NewRepo -> Maybe Text
newRepoGitignoreTemplate = Maybe Text
gitignoreTemplate
                  , newRepoLicenseTemplate :: NewRepo -> Maybe Text
newRepoLicenseTemplate   = Maybe Text
licenseTemplate
                  , newRepoAllowSquashMerge :: NewRepo -> Maybe Bool
newRepoAllowSquashMerge  = Maybe Bool
allowSquashMerge
                  , newRepoAllowMergeCommit :: NewRepo -> Maybe Bool
newRepoAllowMergeCommit  = Maybe Bool
allowMergeCommit
                  , newRepoAllowRebaseMerge :: NewRepo -> Maybe Bool
newRepoAllowRebaseMerge  = Maybe Bool
allowRebaseMerge
                  }) = [Pair] -> Value
object
                  [ Key
"name"                Key -> Name Repo -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Name Repo
name
                  , Key
"description"         Key -> Maybe Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Text
description
                  , Key
"homepage"            Key -> Maybe Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Text
homepage
                  , Key
"private"             Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Bool
private
                  , Key
"has_issues"          Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Bool
hasIssues
                  , Key
"has_projects"        Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Bool
hasProjects
                  , Key
"has_wiki"            Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Bool
hasWiki
                  , Key
"auto_init"           Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Bool
autoInit
                  , Key
"gitignore_template"  Key -> Maybe Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Text
gitignoreTemplate
                  , Key
"license_template"    Key -> Maybe Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Text
licenseTemplate
                  , Key
"allow_squash_merge"  Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Bool
allowSquashMerge
                  , Key
"allow_merge_commit"  Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Bool
allowMergeCommit
                  , Key
"allow_rebase_merge"  Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Bool
allowRebaseMerge
                  ]

instance ToJSON EditRepo where
  toJSON :: EditRepo -> Value
toJSON (EditRepo { editName :: EditRepo -> Maybe (Name Repo)
editName             = Maybe (Name Repo)
name
                   , editDescription :: EditRepo -> Maybe Text
editDescription      = Maybe Text
description
                   , editHomepage :: EditRepo -> Maybe Text
editHomepage         = Maybe Text
homepage
                   , editPrivate :: EditRepo -> Maybe Bool
editPrivate          = Maybe Bool
private
                   , editHasIssues :: EditRepo -> Maybe Bool
editHasIssues        = Maybe Bool
hasIssues
                   , editHasProjects :: EditRepo -> Maybe Bool
editHasProjects      = Maybe Bool
hasProjects
                   , editHasWiki :: EditRepo -> Maybe Bool
editHasWiki          = Maybe Bool
hasWiki
                   , editDefaultBranch :: EditRepo -> Maybe Text
editDefaultBranch    = Maybe Text
defaultBranch
                   , editAllowSquashMerge :: EditRepo -> Maybe Bool
editAllowSquashMerge = Maybe Bool
allowSquashMerge
                   , editAllowMergeCommit :: EditRepo -> Maybe Bool
editAllowMergeCommit = Maybe Bool
allowMergeCommit
                   , editAllowRebaseMerge :: EditRepo -> Maybe Bool
editAllowRebaseMerge = Maybe Bool
allowRebaseMerge
                   , editArchived :: EditRepo -> Maybe Bool
editArchived         = Maybe Bool
archived
                   }) = [Pair] -> Value
object
                   [ Key
"name"               Key -> Maybe (Name Repo) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe (Name Repo)
name
                   , Key
"description"        Key -> Maybe Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Text
description
                   , Key
"homepage"           Key -> Maybe Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Text
homepage
                   , Key
"private"            Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Bool
private
                   , Key
"has_issues"         Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Bool
hasIssues
                   , Key
"has_projects"       Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Bool
hasProjects
                   , Key
"has_wiki"           Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Bool
hasWiki
                   , Key
"default_branch"     Key -> Maybe Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Text
defaultBranch
                   , Key
"allow_squash_merge" Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Bool
allowSquashMerge
                   , Key
"allow_merge_commit" Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Bool
allowMergeCommit
                   , Key
"allow_rebase_merge" Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Bool
allowRebaseMerge
                   , Key
"archived"           Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Maybe Bool
archived
                   ]

instance FromJSON RepoPermissions where
  parseJSON :: Value -> Parser RepoPermissions
parseJSON = String
-> (Object -> Parser RepoPermissions)
-> Value
-> Parser RepoPermissions
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"RepoPermissions" ((Object -> Parser RepoPermissions)
 -> Value -> Parser RepoPermissions)
-> (Object -> Parser RepoPermissions)
-> Value
-> Parser RepoPermissions
forall a b. (a -> b) -> a -> b
$ \Object
o -> Bool -> Bool -> Bool -> RepoPermissions
RepoPermissions
        (Bool -> Bool -> Bool -> RepoPermissions)
-> Parser Bool -> Parser (Bool -> Bool -> RepoPermissions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"admin"
        Parser (Bool -> Bool -> RepoPermissions)
-> Parser Bool -> Parser (Bool -> RepoPermissions)
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 Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"push"
        Parser (Bool -> RepoPermissions)
-> Parser Bool -> Parser RepoPermissions
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 Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"pull"

instance FromJSON RepoRef where
    parseJSON :: Value -> Parser RepoRef
parseJSON = String -> (Object -> Parser RepoRef) -> Value -> Parser RepoRef
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"RepoRef" ((Object -> Parser RepoRef) -> Value -> Parser RepoRef)
-> (Object -> Parser RepoRef) -> Value -> Parser RepoRef
forall a b. (a -> b) -> a -> b
$ \Object
o -> SimpleOwner -> Name Repo -> RepoRef
RepoRef
        (SimpleOwner -> Name Repo -> RepoRef)
-> Parser SimpleOwner -> Parser (Name Repo -> RepoRef)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser SimpleOwner
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner"
        Parser (Name Repo -> RepoRef)
-> Parser (Name Repo) -> Parser RepoRef
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 (Name Repo)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"

instance FromJSON Contributor where
    parseJSON :: Value -> Parser Contributor
parseJSON = String
-> (Object -> Parser Contributor) -> Value -> Parser Contributor
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Contributor" ((Object -> Parser Contributor) -> Value -> Parser Contributor)
-> (Object -> Parser Contributor) -> Value -> Parser Contributor
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
        Text
t <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
        case (Text
t :: Text) of
            Text
"Anonymous" -> Int -> Text -> Contributor
AnonymousContributor
                (Int -> Text -> Contributor)
-> Parser Int -> Parser (Text -> Contributor)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"contributions"
                Parser (Text -> Contributor) -> Parser Text -> Parser Contributor
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
"name"
            Text
_  -> Int -> URL -> Name User -> URL -> Id User -> Text -> Contributor
KnownContributor
                (Int -> URL -> Name User -> URL -> Id User -> Text -> Contributor)
-> Parser Int
-> Parser
     (URL -> Name User -> URL -> Id User -> Text -> Contributor)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"contributions"
                Parser (URL -> Name User -> URL -> Id User -> Text -> Contributor)
-> Parser URL
-> Parser (Name User -> URL -> Id User -> Text -> Contributor)
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
"avatar_url"
                Parser (Name User -> URL -> Id User -> Text -> Contributor)
-> Parser (Name User)
-> Parser (URL -> Id User -> Text -> Contributor)
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 (Name User)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"login"
                Parser (URL -> Id User -> Text -> Contributor)
-> Parser URL -> Parser (Id User -> Text -> Contributor)
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 (Id User -> Text -> Contributor)
-> Parser (Id User) -> Parser (Text -> Contributor)
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 (Id User)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
                Parser (Text -> Contributor) -> Parser Text -> Parser Contributor
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
"gravatar_id"

instance FromJSON Language where
    parseJSON :: Value -> Parser Language
parseJSON = String -> (Text -> Parser Language) -> Value -> Parser Language
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"Language" (Language -> Parser Language
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Language -> Parser Language)
-> (Text -> Language) -> Text -> Parser Language
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Language
Language)

instance ToJSON Language where
    toJSON :: Language -> Value
toJSON = Text -> Value
forall a. ToJSON a => a -> Value
toJSON (Text -> Value) -> (Language -> Text) -> Language -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Language -> Text
getLanguage

#if MIN_VERSION_aeson(1,0,0)
instance FromJSONKey Language where
    fromJSONKey :: FromJSONKeyFunction Language
fromJSONKey = FromJSONKeyFunction Language
forall a. Coercible Text a => FromJSONKeyFunction a
fromJSONKeyCoerce
#else
instance FromJSON a => FromJSON (HM.HashMap Language a) where
    parseJSON = fmap mapKeyLanguage . parseJSON
      where
        mapKeyLanguage :: HM.HashMap Text a -> HM.HashMap Language a
#ifdef UNSAFE
        mapKeyLanguage = unsafeCoerce
#else
        mapKeyLanguage = mapKey Language
        mapKey :: (Eq k2, Hashable k2) => (k1 -> k2) -> HM.HashMap k1 a -> HM.HashMap k2 a
        mapKey f = HM.fromList . map (first f) . HM.toList
#endif
#endif

data ArchiveFormat
    = ArchiveFormatTarball -- ^ ".tar.gz" format
    | ArchiveFormatZipball -- ^ ".zip" format
    deriving (Int -> ArchiveFormat -> ShowS
[ArchiveFormat] -> ShowS
ArchiveFormat -> String
(Int -> ArchiveFormat -> ShowS)
-> (ArchiveFormat -> String)
-> ([ArchiveFormat] -> ShowS)
-> Show ArchiveFormat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ArchiveFormat -> ShowS
showsPrec :: Int -> ArchiveFormat -> ShowS
$cshow :: ArchiveFormat -> String
show :: ArchiveFormat -> String
$cshowList :: [ArchiveFormat] -> ShowS
showList :: [ArchiveFormat] -> ShowS
Show, ArchiveFormat -> ArchiveFormat -> Bool
(ArchiveFormat -> ArchiveFormat -> Bool)
-> (ArchiveFormat -> ArchiveFormat -> Bool) -> Eq ArchiveFormat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ArchiveFormat -> ArchiveFormat -> Bool
== :: ArchiveFormat -> ArchiveFormat -> Bool
$c/= :: ArchiveFormat -> ArchiveFormat -> Bool
/= :: ArchiveFormat -> ArchiveFormat -> Bool
Eq, Eq ArchiveFormat
Eq ArchiveFormat =>
(ArchiveFormat -> ArchiveFormat -> Ordering)
-> (ArchiveFormat -> ArchiveFormat -> Bool)
-> (ArchiveFormat -> ArchiveFormat -> Bool)
-> (ArchiveFormat -> ArchiveFormat -> Bool)
-> (ArchiveFormat -> ArchiveFormat -> Bool)
-> (ArchiveFormat -> ArchiveFormat -> ArchiveFormat)
-> (ArchiveFormat -> ArchiveFormat -> ArchiveFormat)
-> Ord ArchiveFormat
ArchiveFormat -> ArchiveFormat -> Bool
ArchiveFormat -> ArchiveFormat -> Ordering
ArchiveFormat -> ArchiveFormat -> ArchiveFormat
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 :: ArchiveFormat -> ArchiveFormat -> Ordering
compare :: ArchiveFormat -> ArchiveFormat -> Ordering
$c< :: ArchiveFormat -> ArchiveFormat -> Bool
< :: ArchiveFormat -> ArchiveFormat -> Bool
$c<= :: ArchiveFormat -> ArchiveFormat -> Bool
<= :: ArchiveFormat -> ArchiveFormat -> Bool
$c> :: ArchiveFormat -> ArchiveFormat -> Bool
> :: ArchiveFormat -> ArchiveFormat -> Bool
$c>= :: ArchiveFormat -> ArchiveFormat -> Bool
>= :: ArchiveFormat -> ArchiveFormat -> Bool
$cmax :: ArchiveFormat -> ArchiveFormat -> ArchiveFormat
max :: ArchiveFormat -> ArchiveFormat -> ArchiveFormat
$cmin :: ArchiveFormat -> ArchiveFormat -> ArchiveFormat
min :: ArchiveFormat -> ArchiveFormat -> ArchiveFormat
Ord, Int -> ArchiveFormat
ArchiveFormat -> Int
ArchiveFormat -> [ArchiveFormat]
ArchiveFormat -> ArchiveFormat
ArchiveFormat -> ArchiveFormat -> [ArchiveFormat]
ArchiveFormat -> ArchiveFormat -> ArchiveFormat -> [ArchiveFormat]
(ArchiveFormat -> ArchiveFormat)
-> (ArchiveFormat -> ArchiveFormat)
-> (Int -> ArchiveFormat)
-> (ArchiveFormat -> Int)
-> (ArchiveFormat -> [ArchiveFormat])
-> (ArchiveFormat -> ArchiveFormat -> [ArchiveFormat])
-> (ArchiveFormat -> ArchiveFormat -> [ArchiveFormat])
-> (ArchiveFormat
    -> ArchiveFormat -> ArchiveFormat -> [ArchiveFormat])
-> Enum ArchiveFormat
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ArchiveFormat -> ArchiveFormat
succ :: ArchiveFormat -> ArchiveFormat
$cpred :: ArchiveFormat -> ArchiveFormat
pred :: ArchiveFormat -> ArchiveFormat
$ctoEnum :: Int -> ArchiveFormat
toEnum :: Int -> ArchiveFormat
$cfromEnum :: ArchiveFormat -> Int
fromEnum :: ArchiveFormat -> Int
$cenumFrom :: ArchiveFormat -> [ArchiveFormat]
enumFrom :: ArchiveFormat -> [ArchiveFormat]
$cenumFromThen :: ArchiveFormat -> ArchiveFormat -> [ArchiveFormat]
enumFromThen :: ArchiveFormat -> ArchiveFormat -> [ArchiveFormat]
$cenumFromTo :: ArchiveFormat -> ArchiveFormat -> [ArchiveFormat]
enumFromTo :: ArchiveFormat -> ArchiveFormat -> [ArchiveFormat]
$cenumFromThenTo :: ArchiveFormat -> ArchiveFormat -> ArchiveFormat -> [ArchiveFormat]
enumFromThenTo :: ArchiveFormat -> ArchiveFormat -> ArchiveFormat -> [ArchiveFormat]
Enum, ArchiveFormat
ArchiveFormat -> ArchiveFormat -> Bounded ArchiveFormat
forall a. a -> a -> Bounded a
$cminBound :: ArchiveFormat
minBound :: ArchiveFormat
$cmaxBound :: ArchiveFormat
maxBound :: ArchiveFormat
Bounded, Typeable, Typeable ArchiveFormat
Typeable ArchiveFormat =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ArchiveFormat -> c ArchiveFormat)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ArchiveFormat)
-> (ArchiveFormat -> Constr)
-> (ArchiveFormat -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ArchiveFormat))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ArchiveFormat))
-> ((forall b. Data b => b -> b) -> ArchiveFormat -> ArchiveFormat)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ArchiveFormat -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ArchiveFormat -> r)
-> (forall u. (forall d. Data d => d -> u) -> ArchiveFormat -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ArchiveFormat -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ArchiveFormat -> m ArchiveFormat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ArchiveFormat -> m ArchiveFormat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ArchiveFormat -> m ArchiveFormat)
-> Data ArchiveFormat
ArchiveFormat -> Constr
ArchiveFormat -> DataType
(forall b. Data b => b -> b) -> ArchiveFormat -> ArchiveFormat
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) -> ArchiveFormat -> u
forall u. (forall d. Data d => d -> u) -> ArchiveFormat -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArchiveFormat -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArchiveFormat -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArchiveFormat -> m ArchiveFormat
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArchiveFormat -> m ArchiveFormat
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArchiveFormat
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArchiveFormat -> c ArchiveFormat
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArchiveFormat)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ArchiveFormat)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArchiveFormat -> c ArchiveFormat
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArchiveFormat -> c ArchiveFormat
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArchiveFormat
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArchiveFormat
$ctoConstr :: ArchiveFormat -> Constr
toConstr :: ArchiveFormat -> Constr
$cdataTypeOf :: ArchiveFormat -> DataType
dataTypeOf :: ArchiveFormat -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArchiveFormat)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArchiveFormat)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ArchiveFormat)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ArchiveFormat)
$cgmapT :: (forall b. Data b => b -> b) -> ArchiveFormat -> ArchiveFormat
gmapT :: (forall b. Data b => b -> b) -> ArchiveFormat -> ArchiveFormat
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArchiveFormat -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArchiveFormat -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArchiveFormat -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArchiveFormat -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ArchiveFormat -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ArchiveFormat -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ArchiveFormat -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ArchiveFormat -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArchiveFormat -> m ArchiveFormat
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArchiveFormat -> m ArchiveFormat
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArchiveFormat -> m ArchiveFormat
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArchiveFormat -> m ArchiveFormat
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArchiveFormat -> m ArchiveFormat
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArchiveFormat -> m ArchiveFormat
Data, (forall x. ArchiveFormat -> Rep ArchiveFormat x)
-> (forall x. Rep ArchiveFormat x -> ArchiveFormat)
-> Generic ArchiveFormat
forall x. Rep ArchiveFormat x -> ArchiveFormat
forall x. ArchiveFormat -> Rep ArchiveFormat x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ArchiveFormat -> Rep ArchiveFormat x
from :: forall x. ArchiveFormat -> Rep ArchiveFormat x
$cto :: forall x. Rep ArchiveFormat x -> ArchiveFormat
to :: forall x. Rep ArchiveFormat x -> ArchiveFormat
Generic)

instance IsPathPart ArchiveFormat where
    toPathPart :: ArchiveFormat -> Text
toPathPart ArchiveFormat
af = case ArchiveFormat
af of
        ArchiveFormat
ArchiveFormatTarball -> Text
"tarball"
        ArchiveFormat
ArchiveFormatZipball -> Text
"zipball"

instance FromJSON CollaboratorPermission where
    parseJSON :: Value -> Parser CollaboratorPermission
parseJSON = String
-> (Text -> Parser CollaboratorPermission)
-> Value
-> Parser CollaboratorPermission
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"CollaboratorPermission" ((Text -> Parser CollaboratorPermission)
 -> Value -> Parser CollaboratorPermission)
-> (Text -> Parser CollaboratorPermission)
-> Value
-> Parser CollaboratorPermission
forall a b. (a -> b) -> a -> b
$ \Text
t -> case Text -> Text
T.toLower Text
t of
        Text
"admin" -> CollaboratorPermission -> Parser CollaboratorPermission
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure CollaboratorPermission
CollaboratorPermissionAdmin
        Text
"write" -> CollaboratorPermission -> Parser CollaboratorPermission
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure CollaboratorPermission
CollaboratorPermissionWrite
        Text
"read"  -> CollaboratorPermission -> Parser CollaboratorPermission
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure CollaboratorPermission
CollaboratorPermissionRead
        Text
"none"  -> CollaboratorPermission -> Parser CollaboratorPermission
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure CollaboratorPermission
CollaboratorPermissionNone
        Text
_       -> String -> Parser CollaboratorPermission
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser CollaboratorPermission)
-> String -> Parser CollaboratorPermission
forall a b. (a -> b) -> a -> b
$ String
"Unknown CollaboratorPermission: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Text -> String
T.unpack Text
t

instance ToJSON CollaboratorPermission where
    toJSON :: CollaboratorPermission -> Value
toJSON CollaboratorPermission
CollaboratorPermissionAdmin = Value
"admin"
    toJSON CollaboratorPermission
CollaboratorPermissionWrite = Value
"write"
    toJSON CollaboratorPermission
CollaboratorPermissionRead  = Value
"read"
    toJSON CollaboratorPermission
CollaboratorPermissionNone  = Value
"none"

instance FromJSON CollaboratorWithPermission where
    parseJSON :: Value -> Parser CollaboratorWithPermission
parseJSON = String
-> (Object -> Parser CollaboratorWithPermission)
-> Value
-> Parser CollaboratorWithPermission
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"CollaboratorWithPermission" ((Object -> Parser CollaboratorWithPermission)
 -> Value -> Parser CollaboratorWithPermission)
-> (Object -> Parser CollaboratorWithPermission)
-> Value
-> Parser CollaboratorWithPermission
forall a b. (a -> b) -> a -> b
$ \Object
o -> SimpleUser -> CollaboratorPermission -> CollaboratorWithPermission
CollaboratorWithPermission
        (SimpleUser
 -> CollaboratorPermission -> CollaboratorWithPermission)
-> Parser SimpleUser
-> Parser (CollaboratorPermission -> CollaboratorWithPermission)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser SimpleUser
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user"
        Parser (CollaboratorPermission -> CollaboratorWithPermission)
-> Parser CollaboratorPermission
-> Parser CollaboratorWithPermission
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 CollaboratorPermission
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"permission"