{-# LANGUAGE CPP               #-}
{-# LANGUAGE FlexibleInstances #-}
#define UNSAFE 1
-----------------------------------------------------------------------------
-- |
-- License     :  BSD-3-Clause
-- Maintainer  :  Oleg Grenrus <oleg.grenrus@iki.fi>
--
-- 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
showList :: [Repo] -> ShowS
$cshowList :: [Repo] -> ShowS
show :: Repo -> String
$cshow :: Repo -> String
showsPrec :: Int -> Repo -> ShowS
$cshowsPrec :: Int -> 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 -> DataType
Repo -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Repo -> m Repo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Repo -> m Repo
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Repo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Repo -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Repo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Repo -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Repo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Repo -> r
gmapT :: (forall b. Data b => b -> b) -> Repo -> Repo
$cgmapT :: (forall b. Data b => b -> b) -> Repo -> Repo
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Repo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Repo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Repo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Repo)
dataTypeOf :: Repo -> DataType
$cdataTypeOf :: Repo -> DataType
toConstr :: Repo -> Constr
$ctoConstr :: Repo -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Repo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Repo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Repo -> c Repo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Repo -> c Repo
Data, Typeable, Repo -> Repo -> Bool
(Repo -> Repo -> Bool) -> (Repo -> Repo -> Bool) -> Eq Repo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Repo -> Repo -> Bool
$c/= :: Repo -> Repo -> Bool
== :: Repo -> Repo -> Bool
$c== :: 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
min :: Repo -> Repo -> Repo
$cmin :: Repo -> Repo -> Repo
max :: Repo -> Repo -> Repo
$cmax :: Repo -> Repo -> Repo
>= :: Repo -> Repo -> Bool
$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
compare :: Repo -> Repo -> Ordering
$ccompare :: Repo -> Repo -> Ordering
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
$cto :: forall x. Rep Repo x -> Repo
$cfrom :: forall x. Repo -> Rep Repo x
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
showList :: [CodeSearchRepo] -> ShowS
$cshowList :: [CodeSearchRepo] -> ShowS
show :: CodeSearchRepo -> String
$cshow :: CodeSearchRepo -> String
showsPrec :: Int -> CodeSearchRepo -> ShowS
$cshowsPrec :: Int -> 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 -> DataType
CodeSearchRepo -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CodeSearchRepo -> m CodeSearchRepo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CodeSearchRepo -> m CodeSearchRepo
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CodeSearchRepo -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CodeSearchRepo -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CodeSearchRepo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CodeSearchRepo -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CodeSearchRepo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CodeSearchRepo -> r
gmapT :: (forall b. Data b => b -> b) -> CodeSearchRepo -> CodeSearchRepo
$cgmapT :: (forall b. Data b => b -> b) -> CodeSearchRepo -> CodeSearchRepo
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CodeSearchRepo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CodeSearchRepo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CodeSearchRepo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CodeSearchRepo)
dataTypeOf :: CodeSearchRepo -> DataType
$cdataTypeOf :: CodeSearchRepo -> DataType
toConstr :: CodeSearchRepo -> Constr
$ctoConstr :: CodeSearchRepo -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CodeSearchRepo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CodeSearchRepo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CodeSearchRepo -> c CodeSearchRepo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CodeSearchRepo -> c CodeSearchRepo
Data, Typeable, CodeSearchRepo -> CodeSearchRepo -> Bool
(CodeSearchRepo -> CodeSearchRepo -> Bool)
-> (CodeSearchRepo -> CodeSearchRepo -> Bool) -> Eq CodeSearchRepo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CodeSearchRepo -> CodeSearchRepo -> Bool
$c/= :: CodeSearchRepo -> CodeSearchRepo -> Bool
== :: CodeSearchRepo -> CodeSearchRepo -> Bool
$c== :: 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
min :: CodeSearchRepo -> CodeSearchRepo -> CodeSearchRepo
$cmin :: CodeSearchRepo -> CodeSearchRepo -> CodeSearchRepo
max :: CodeSearchRepo -> CodeSearchRepo -> CodeSearchRepo
$cmax :: CodeSearchRepo -> CodeSearchRepo -> CodeSearchRepo
>= :: CodeSearchRepo -> CodeSearchRepo -> Bool
$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
compare :: CodeSearchRepo -> CodeSearchRepo -> Ordering
$ccompare :: CodeSearchRepo -> CodeSearchRepo -> Ordering
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
$cto :: forall x. Rep CodeSearchRepo x -> CodeSearchRepo
$cfrom :: forall x. CodeSearchRepo -> Rep CodeSearchRepo x
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
showList :: [RepoPermissions] -> ShowS
$cshowList :: [RepoPermissions] -> ShowS
show :: RepoPermissions -> String
$cshow :: RepoPermissions -> String
showsPrec :: Int -> RepoPermissions -> ShowS
$cshowsPrec :: Int -> 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 -> DataType
RepoPermissions -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RepoPermissions -> m RepoPermissions
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RepoPermissions -> m RepoPermissions
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> RepoPermissions -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> RepoPermissions -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> RepoPermissions -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RepoPermissions -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RepoPermissions -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RepoPermissions -> r
gmapT :: (forall b. Data b => b -> b) -> RepoPermissions -> RepoPermissions
$cgmapT :: (forall b. Data b => b -> b) -> RepoPermissions -> RepoPermissions
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RepoPermissions)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RepoPermissions)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RepoPermissions)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RepoPermissions)
dataTypeOf :: RepoPermissions -> DataType
$cdataTypeOf :: RepoPermissions -> DataType
toConstr :: RepoPermissions -> Constr
$ctoConstr :: RepoPermissions -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RepoPermissions
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RepoPermissions
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RepoPermissions -> c RepoPermissions
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RepoPermissions -> c RepoPermissions
Data, Typeable, RepoPermissions -> RepoPermissions -> Bool
(RepoPermissions -> RepoPermissions -> Bool)
-> (RepoPermissions -> RepoPermissions -> Bool)
-> Eq RepoPermissions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoPermissions -> RepoPermissions -> Bool
$c/= :: RepoPermissions -> RepoPermissions -> Bool
== :: RepoPermissions -> RepoPermissions -> Bool
$c== :: 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
min :: RepoPermissions -> RepoPermissions -> RepoPermissions
$cmin :: RepoPermissions -> RepoPermissions -> RepoPermissions
max :: RepoPermissions -> RepoPermissions -> RepoPermissions
$cmax :: RepoPermissions -> RepoPermissions -> RepoPermissions
>= :: RepoPermissions -> RepoPermissions -> Bool
$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
compare :: RepoPermissions -> RepoPermissions -> Ordering
$ccompare :: RepoPermissions -> RepoPermissions -> Ordering
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
$cto :: forall x. Rep RepoPermissions x -> RepoPermissions
$cfrom :: forall x. RepoPermissions -> Rep RepoPermissions x
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
showList :: [RepoRef] -> ShowS
$cshowList :: [RepoRef] -> ShowS
show :: RepoRef -> String
$cshow :: RepoRef -> String
showsPrec :: Int -> RepoRef -> ShowS
$cshowsPrec :: Int -> 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 -> DataType
RepoRef -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RepoRef -> m RepoRef
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RepoRef -> m RepoRef
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RepoRef -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RepoRef -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> RepoRef -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RepoRef -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RepoRef -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RepoRef -> r
gmapT :: (forall b. Data b => b -> b) -> RepoRef -> RepoRef
$cgmapT :: (forall b. Data b => b -> b) -> RepoRef -> RepoRef
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RepoRef)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RepoRef)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RepoRef)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RepoRef)
dataTypeOf :: RepoRef -> DataType
$cdataTypeOf :: RepoRef -> DataType
toConstr :: RepoRef -> Constr
$ctoConstr :: RepoRef -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RepoRef
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RepoRef
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RepoRef -> c RepoRef
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RepoRef -> c RepoRef
Data, Typeable, RepoRef -> RepoRef -> Bool
(RepoRef -> RepoRef -> Bool)
-> (RepoRef -> RepoRef -> Bool) -> Eq RepoRef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoRef -> RepoRef -> Bool
$c/= :: RepoRef -> RepoRef -> Bool
== :: RepoRef -> RepoRef -> Bool
$c== :: 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
min :: RepoRef -> RepoRef -> RepoRef
$cmin :: RepoRef -> RepoRef -> RepoRef
max :: RepoRef -> RepoRef -> RepoRef
$cmax :: RepoRef -> RepoRef -> RepoRef
>= :: RepoRef -> RepoRef -> Bool
$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
compare :: RepoRef -> RepoRef -> Ordering
$ccompare :: RepoRef -> RepoRef -> Ordering
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
$cto :: forall x. Rep RepoRef x -> RepoRef
$cfrom :: forall x. RepoRef -> Rep RepoRef x
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
/= :: NewRepo -> NewRepo -> Bool
$c/= :: NewRepo -> NewRepo -> Bool
== :: NewRepo -> NewRepo -> Bool
$c== :: 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
min :: NewRepo -> NewRepo -> NewRepo
$cmin :: NewRepo -> NewRepo -> NewRepo
max :: NewRepo -> NewRepo -> NewRepo
$cmax :: NewRepo -> NewRepo -> NewRepo
>= :: NewRepo -> NewRepo -> Bool
$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
compare :: NewRepo -> NewRepo -> Ordering
$ccompare :: NewRepo -> NewRepo -> Ordering
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
showList :: [NewRepo] -> ShowS
$cshowList :: [NewRepo] -> ShowS
show :: NewRepo -> String
$cshow :: NewRepo -> String
showsPrec :: Int -> NewRepo -> ShowS
$cshowsPrec :: Int -> 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 -> DataType
NewRepo -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NewRepo -> m NewRepo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NewRepo -> m NewRepo
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NewRepo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NewRepo -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> NewRepo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NewRepo -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NewRepo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NewRepo -> r
gmapT :: (forall b. Data b => b -> b) -> NewRepo -> NewRepo
$cgmapT :: (forall b. Data b => b -> b) -> NewRepo -> NewRepo
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewRepo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewRepo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NewRepo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NewRepo)
dataTypeOf :: NewRepo -> DataType
$cdataTypeOf :: NewRepo -> DataType
toConstr :: NewRepo -> Constr
$ctoConstr :: NewRepo -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewRepo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewRepo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewRepo -> c NewRepo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewRepo -> c 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
$cto :: forall x. Rep NewRepo x -> NewRepo
$cfrom :: forall x. NewRepo -> Rep NewRepo x
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
/= :: EditRepo -> EditRepo -> Bool
$c/= :: EditRepo -> EditRepo -> Bool
== :: EditRepo -> EditRepo -> Bool
$c== :: 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
min :: EditRepo -> EditRepo -> EditRepo
$cmin :: EditRepo -> EditRepo -> EditRepo
max :: EditRepo -> EditRepo -> EditRepo
$cmax :: EditRepo -> EditRepo -> EditRepo
>= :: EditRepo -> EditRepo -> Bool
$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
compare :: EditRepo -> EditRepo -> Ordering
$ccompare :: EditRepo -> EditRepo -> Ordering
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
showList :: [EditRepo] -> ShowS
$cshowList :: [EditRepo] -> ShowS
show :: EditRepo -> String
$cshow :: EditRepo -> String
showsPrec :: Int -> EditRepo -> ShowS
$cshowsPrec :: Int -> 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 -> DataType
EditRepo -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EditRepo -> m EditRepo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EditRepo -> m EditRepo
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EditRepo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EditRepo -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> EditRepo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EditRepo -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EditRepo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EditRepo -> r
gmapT :: (forall b. Data b => b -> b) -> EditRepo -> EditRepo
$cgmapT :: (forall b. Data b => b -> b) -> EditRepo -> EditRepo
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EditRepo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EditRepo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EditRepo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EditRepo)
dataTypeOf :: EditRepo -> DataType
$cdataTypeOf :: EditRepo -> DataType
toConstr :: EditRepo -> Constr
$ctoConstr :: EditRepo -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EditRepo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EditRepo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EditRepo -> c EditRepo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EditRepo -> c 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
$cto :: forall x. Rep EditRepo x -> EditRepo
$cfrom :: forall x. EditRepo -> Rep EditRepo x
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
showList :: [RepoPublicity] -> ShowS
$cshowList :: [RepoPublicity] -> ShowS
show :: RepoPublicity -> String
$cshow :: RepoPublicity -> String
showsPrec :: Int -> RepoPublicity -> ShowS
$cshowsPrec :: Int -> RepoPublicity -> ShowS
Show, RepoPublicity -> RepoPublicity -> Bool
(RepoPublicity -> RepoPublicity -> Bool)
-> (RepoPublicity -> RepoPublicity -> Bool) -> Eq RepoPublicity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoPublicity -> RepoPublicity -> Bool
$c/= :: RepoPublicity -> RepoPublicity -> Bool
== :: RepoPublicity -> RepoPublicity -> Bool
$c== :: 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
min :: RepoPublicity -> RepoPublicity -> RepoPublicity
$cmin :: RepoPublicity -> RepoPublicity -> RepoPublicity
max :: RepoPublicity -> RepoPublicity -> RepoPublicity
$cmax :: RepoPublicity -> RepoPublicity -> RepoPublicity
>= :: RepoPublicity -> RepoPublicity -> Bool
$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
compare :: RepoPublicity -> RepoPublicity -> Ordering
$ccompare :: RepoPublicity -> RepoPublicity -> Ordering
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
enumFromThenTo :: RepoPublicity -> RepoPublicity -> RepoPublicity -> [RepoPublicity]
$cenumFromThenTo :: RepoPublicity -> RepoPublicity -> RepoPublicity -> [RepoPublicity]
enumFromTo :: RepoPublicity -> RepoPublicity -> [RepoPublicity]
$cenumFromTo :: RepoPublicity -> RepoPublicity -> [RepoPublicity]
enumFromThen :: RepoPublicity -> RepoPublicity -> [RepoPublicity]
$cenumFromThen :: RepoPublicity -> RepoPublicity -> [RepoPublicity]
enumFrom :: RepoPublicity -> [RepoPublicity]
$cenumFrom :: RepoPublicity -> [RepoPublicity]
fromEnum :: RepoPublicity -> Int
$cfromEnum :: RepoPublicity -> Int
toEnum :: Int -> RepoPublicity
$ctoEnum :: Int -> RepoPublicity
pred :: RepoPublicity -> RepoPublicity
$cpred :: RepoPublicity -> RepoPublicity
succ :: RepoPublicity -> RepoPublicity
$csucc :: RepoPublicity -> RepoPublicity
Enum, RepoPublicity
RepoPublicity -> RepoPublicity -> Bounded RepoPublicity
forall a. a -> a -> Bounded a
maxBound :: RepoPublicity
$cmaxBound :: RepoPublicity
minBound :: RepoPublicity
$cminBound :: 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 -> DataType
RepoPublicity -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RepoPublicity -> m RepoPublicity
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RepoPublicity -> m RepoPublicity
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RepoPublicity -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RepoPublicity -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> RepoPublicity -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RepoPublicity -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RepoPublicity -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RepoPublicity -> r
gmapT :: (forall b. Data b => b -> b) -> RepoPublicity -> RepoPublicity
$cgmapT :: (forall b. Data b => b -> b) -> RepoPublicity -> RepoPublicity
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RepoPublicity)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RepoPublicity)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RepoPublicity)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RepoPublicity)
dataTypeOf :: RepoPublicity -> DataType
$cdataTypeOf :: RepoPublicity -> DataType
toConstr :: RepoPublicity -> Constr
$ctoConstr :: RepoPublicity -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RepoPublicity
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RepoPublicity
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RepoPublicity -> c RepoPublicity
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RepoPublicity -> c 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
$cto :: forall x. Rep RepoPublicity x -> RepoPublicity
$cfrom :: forall x. RepoPublicity -> Rep RepoPublicity x
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
showList :: [Language] -> ShowS
$cshowList :: [Language] -> ShowS
show :: Language -> String
$cshow :: Language -> String
showsPrec :: Int -> Language -> ShowS
$cshowsPrec :: Int -> 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 -> DataType
Language -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Language -> m Language
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Language -> m Language
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Language -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Language -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Language -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Language -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Language -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Language -> r
gmapT :: (forall b. Data b => b -> b) -> Language -> Language
$cgmapT :: (forall b. Data b => b -> b) -> Language -> Language
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Language)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Language)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Language)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Language)
dataTypeOf :: Language -> DataType
$cdataTypeOf :: Language -> DataType
toConstr :: Language -> Constr
$ctoConstr :: Language -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Language
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Language
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Language -> c Language
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Language -> c Language
Data, Typeable, Language -> Language -> Bool
(Language -> Language -> Bool)
-> (Language -> Language -> Bool) -> Eq Language
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Language -> Language -> Bool
$c/= :: Language -> Language -> Bool
== :: Language -> Language -> Bool
$c== :: 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
min :: Language -> Language -> Language
$cmin :: Language -> Language -> Language
max :: Language -> Language -> Language
$cmax :: Language -> Language -> Language
>= :: Language -> Language -> Bool
$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
compare :: Language -> Language -> Ordering
$ccompare :: Language -> Language -> Ordering
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
$cto :: forall x. Rep Language x -> Language
$cfrom :: forall x. Language -> Rep Language x
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
showList :: [Contributor] -> ShowS
$cshowList :: [Contributor] -> ShowS
show :: Contributor -> String
$cshow :: Contributor -> String
showsPrec :: Int -> Contributor -> ShowS
$cshowsPrec :: Int -> 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 -> DataType
Contributor -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Contributor -> m Contributor
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Contributor -> m Contributor
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Contributor -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Contributor -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Contributor -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Contributor -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Contributor -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Contributor -> r
gmapT :: (forall b. Data b => b -> b) -> Contributor -> Contributor
$cgmapT :: (forall b. Data b => b -> b) -> Contributor -> Contributor
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Contributor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Contributor)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Contributor)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Contributor)
dataTypeOf :: Contributor -> DataType
$cdataTypeOf :: Contributor -> DataType
toConstr :: Contributor -> Constr
$ctoConstr :: Contributor -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Contributor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Contributor
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Contributor -> c Contributor
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Contributor -> c Contributor
Data, Typeable, Contributor -> Contributor -> Bool
(Contributor -> Contributor -> Bool)
-> (Contributor -> Contributor -> Bool) -> Eq Contributor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Contributor -> Contributor -> Bool
$c/= :: Contributor -> Contributor -> Bool
== :: Contributor -> Contributor -> Bool
$c== :: 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
min :: Contributor -> Contributor -> Contributor
$cmin :: Contributor -> Contributor -> Contributor
max :: Contributor -> Contributor -> Contributor
$cmax :: Contributor -> Contributor -> Contributor
>= :: Contributor -> Contributor -> Bool
$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
compare :: Contributor -> Contributor -> Ordering
$ccompare :: Contributor -> Contributor -> Ordering
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
$cto :: forall x. Rep Contributor x -> Contributor
$cfrom :: forall x. Contributor -> Rep Contributor x
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
showList :: [CollaboratorPermission] -> ShowS
$cshowList :: [CollaboratorPermission] -> ShowS
show :: CollaboratorPermission -> String
$cshow :: CollaboratorPermission -> String
showsPrec :: Int -> CollaboratorPermission -> ShowS
$cshowsPrec :: Int -> 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 -> DataType
CollaboratorPermission -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CollaboratorPermission -> m CollaboratorPermission
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CollaboratorPermission -> m CollaboratorPermission
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CollaboratorPermission -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CollaboratorPermission -> u
gmapQ :: forall u.
(forall d. Data d => d -> u) -> CollaboratorPermission -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> CollaboratorPermission -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> CollaboratorPermission
-> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> CollaboratorPermission
-> r
gmapT :: (forall b. Data b => b -> b)
-> CollaboratorPermission -> CollaboratorPermission
$cgmapT :: (forall b. Data b => b -> b)
-> CollaboratorPermission -> CollaboratorPermission
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CollaboratorPermission)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CollaboratorPermission)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CollaboratorPermission)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CollaboratorPermission)
dataTypeOf :: CollaboratorPermission -> DataType
$cdataTypeOf :: CollaboratorPermission -> DataType
toConstr :: CollaboratorPermission -> Constr
$ctoConstr :: CollaboratorPermission -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CollaboratorPermission
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CollaboratorPermission
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CollaboratorPermission
-> c CollaboratorPermission
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CollaboratorPermission
-> c 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
enumFromThenTo :: CollaboratorPermission
-> CollaboratorPermission
-> CollaboratorPermission
-> [CollaboratorPermission]
$cenumFromThenTo :: CollaboratorPermission
-> CollaboratorPermission
-> CollaboratorPermission
-> [CollaboratorPermission]
enumFromTo :: CollaboratorPermission
-> CollaboratorPermission -> [CollaboratorPermission]
$cenumFromTo :: CollaboratorPermission
-> CollaboratorPermission -> [CollaboratorPermission]
enumFromThen :: CollaboratorPermission
-> CollaboratorPermission -> [CollaboratorPermission]
$cenumFromThen :: CollaboratorPermission
-> CollaboratorPermission -> [CollaboratorPermission]
enumFrom :: CollaboratorPermission -> [CollaboratorPermission]
$cenumFrom :: CollaboratorPermission -> [CollaboratorPermission]
fromEnum :: CollaboratorPermission -> Int
$cfromEnum :: CollaboratorPermission -> Int
toEnum :: Int -> CollaboratorPermission
$ctoEnum :: Int -> CollaboratorPermission
pred :: CollaboratorPermission -> CollaboratorPermission
$cpred :: CollaboratorPermission -> CollaboratorPermission
succ :: CollaboratorPermission -> CollaboratorPermission
$csucc :: CollaboratorPermission -> CollaboratorPermission
Enum, CollaboratorPermission
CollaboratorPermission
-> CollaboratorPermission -> Bounded CollaboratorPermission
forall a. a -> a -> Bounded a
maxBound :: CollaboratorPermission
$cmaxBound :: CollaboratorPermission
minBound :: CollaboratorPermission
$cminBound :: CollaboratorPermission
Bounded, Typeable, CollaboratorPermission -> CollaboratorPermission -> Bool
(CollaboratorPermission -> CollaboratorPermission -> Bool)
-> (CollaboratorPermission -> CollaboratorPermission -> Bool)
-> Eq CollaboratorPermission
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CollaboratorPermission -> CollaboratorPermission -> Bool
$c/= :: CollaboratorPermission -> CollaboratorPermission -> Bool
== :: CollaboratorPermission -> CollaboratorPermission -> Bool
$c== :: 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
min :: CollaboratorPermission
-> CollaboratorPermission -> CollaboratorPermission
$cmin :: CollaboratorPermission
-> CollaboratorPermission -> CollaboratorPermission
max :: CollaboratorPermission
-> CollaboratorPermission -> CollaboratorPermission
$cmax :: CollaboratorPermission
-> CollaboratorPermission -> CollaboratorPermission
>= :: CollaboratorPermission -> CollaboratorPermission -> Bool
$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
compare :: CollaboratorPermission -> CollaboratorPermission -> Ordering
$ccompare :: CollaboratorPermission -> CollaboratorPermission -> Ordering
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
$cto :: forall x. Rep CollaboratorPermission x -> CollaboratorPermission
$cfrom :: forall x. CollaboratorPermission -> Rep CollaboratorPermission x
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
showList :: [CollaboratorWithPermission] -> ShowS
$cshowList :: [CollaboratorWithPermission] -> ShowS
show :: CollaboratorWithPermission -> String
$cshow :: CollaboratorWithPermission -> String
showsPrec :: Int -> CollaboratorWithPermission -> ShowS
$cshowsPrec :: Int -> 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 -> DataType
CollaboratorWithPermission -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CollaboratorWithPermission -> m CollaboratorWithPermission
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CollaboratorWithPermission -> m CollaboratorWithPermission
gmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> CollaboratorWithPermission -> u
$cgmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> CollaboratorWithPermission -> u
gmapQ :: forall u.
(forall d. Data d => d -> u) -> CollaboratorWithPermission -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> CollaboratorWithPermission -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> CollaboratorWithPermission
-> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> CollaboratorWithPermission
-> r
gmapT :: (forall b. Data b => b -> b)
-> CollaboratorWithPermission -> CollaboratorWithPermission
$cgmapT :: (forall b. Data b => b -> b)
-> CollaboratorWithPermission -> CollaboratorWithPermission
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CollaboratorWithPermission)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CollaboratorWithPermission)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c CollaboratorWithPermission)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c CollaboratorWithPermission)
dataTypeOf :: CollaboratorWithPermission -> DataType
$cdataTypeOf :: CollaboratorWithPermission -> DataType
toConstr :: CollaboratorWithPermission -> Constr
$ctoConstr :: CollaboratorWithPermission -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CollaboratorWithPermission
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CollaboratorWithPermission
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CollaboratorWithPermission
-> c CollaboratorWithPermission
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CollaboratorWithPermission
-> c CollaboratorWithPermission
Data, Typeable, CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
(CollaboratorWithPermission -> CollaboratorWithPermission -> Bool)
-> (CollaboratorWithPermission
    -> CollaboratorWithPermission -> Bool)
-> Eq CollaboratorWithPermission
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
$c/= :: CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
== :: CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
$c== :: 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
min :: CollaboratorWithPermission
-> CollaboratorWithPermission -> CollaboratorWithPermission
$cmin :: CollaboratorWithPermission
-> CollaboratorWithPermission -> CollaboratorWithPermission
max :: CollaboratorWithPermission
-> CollaboratorWithPermission -> CollaboratorWithPermission
$cmax :: CollaboratorWithPermission
-> CollaboratorWithPermission -> CollaboratorWithPermission
>= :: CollaboratorWithPermission -> CollaboratorWithPermission -> Bool
$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
compare :: CollaboratorWithPermission
-> CollaboratorWithPermission -> Ordering
$ccompare :: CollaboratorWithPermission
-> CollaboratorWithPermission -> Ordering
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
$cto :: forall x.
Rep CollaboratorWithPermission x -> CollaboratorWithPermission
$cfrom :: forall x.
CollaboratorWithPermission -> Rep CollaboratorWithPermission x
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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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
.= Name Repo
name
                  , Key
"description"         Key -> Maybe Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
description
                  , Key
"homepage"            Key -> Maybe Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
homepage
                  , Key
"private"             Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Bool
private
                  , Key
"has_issues"          Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Bool
hasIssues
                  , Key
"has_projects"        Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Bool
hasProjects
                  , Key
"has_wiki"            Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Bool
hasWiki
                  , Key
"auto_init"           Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Bool
autoInit
                  , Key
"gitignore_template"  Key -> Maybe Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
gitignoreTemplate
                  , Key
"license_template"    Key -> Maybe Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
licenseTemplate
                  , Key
"allow_squash_merge"  Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Bool
allowSquashMerge
                  , Key
"allow_merge_commit"  Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Bool
allowMergeCommit
                  , Key
"allow_rebase_merge"  Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= 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
.= Maybe (Name Repo)
name
                   , Key
"description"        Key -> Maybe Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
description
                   , Key
"homepage"           Key -> Maybe Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
homepage
                   , Key
"private"            Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Bool
private
                   , Key
"has_issues"         Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Bool
hasIssues
                   , Key
"has_projects"       Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Bool
hasProjects
                   , Key
"has_wiki"           Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Bool
hasWiki
                   , Key
"default_branch"     Key -> Maybe Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
defaultBranch
                   , Key
"allow_squash_merge" Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Bool
allowSquashMerge
                   , Key
"allow_merge_commit" Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Bool
allowMergeCommit
                   , Key
"allow_rebase_merge" Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Bool
allowRebaseMerge
                   , Key
"archived"           Key -> Maybe Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= 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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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
showList :: [ArchiveFormat] -> ShowS
$cshowList :: [ArchiveFormat] -> ShowS
show :: ArchiveFormat -> String
$cshow :: ArchiveFormat -> String
showsPrec :: Int -> ArchiveFormat -> ShowS
$cshowsPrec :: Int -> ArchiveFormat -> ShowS
Show, ArchiveFormat -> ArchiveFormat -> Bool
(ArchiveFormat -> ArchiveFormat -> Bool)
-> (ArchiveFormat -> ArchiveFormat -> Bool) -> Eq ArchiveFormat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ArchiveFormat -> ArchiveFormat -> Bool
$c/= :: ArchiveFormat -> ArchiveFormat -> Bool
== :: ArchiveFormat -> ArchiveFormat -> Bool
$c== :: 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
min :: ArchiveFormat -> ArchiveFormat -> ArchiveFormat
$cmin :: ArchiveFormat -> ArchiveFormat -> ArchiveFormat
max :: ArchiveFormat -> ArchiveFormat -> ArchiveFormat
$cmax :: ArchiveFormat -> ArchiveFormat -> ArchiveFormat
>= :: ArchiveFormat -> ArchiveFormat -> Bool
$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
compare :: ArchiveFormat -> ArchiveFormat -> Ordering
$ccompare :: ArchiveFormat -> ArchiveFormat -> Ordering
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
enumFromThenTo :: ArchiveFormat -> ArchiveFormat -> ArchiveFormat -> [ArchiveFormat]
$cenumFromThenTo :: ArchiveFormat -> ArchiveFormat -> ArchiveFormat -> [ArchiveFormat]
enumFromTo :: ArchiveFormat -> ArchiveFormat -> [ArchiveFormat]
$cenumFromTo :: ArchiveFormat -> ArchiveFormat -> [ArchiveFormat]
enumFromThen :: ArchiveFormat -> ArchiveFormat -> [ArchiveFormat]
$cenumFromThen :: ArchiveFormat -> ArchiveFormat -> [ArchiveFormat]
enumFrom :: ArchiveFormat -> [ArchiveFormat]
$cenumFrom :: ArchiveFormat -> [ArchiveFormat]
fromEnum :: ArchiveFormat -> Int
$cfromEnum :: ArchiveFormat -> Int
toEnum :: Int -> ArchiveFormat
$ctoEnum :: Int -> ArchiveFormat
pred :: ArchiveFormat -> ArchiveFormat
$cpred :: ArchiveFormat -> ArchiveFormat
succ :: ArchiveFormat -> ArchiveFormat
$csucc :: ArchiveFormat -> ArchiveFormat
Enum, ArchiveFormat
ArchiveFormat -> ArchiveFormat -> Bounded ArchiveFormat
forall a. a -> a -> Bounded a
maxBound :: ArchiveFormat
$cmaxBound :: ArchiveFormat
minBound :: ArchiveFormat
$cminBound :: 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 -> DataType
ArchiveFormat -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArchiveFormat -> m ArchiveFormat
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArchiveFormat -> m ArchiveFormat
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ArchiveFormat -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ArchiveFormat -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ArchiveFormat -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ArchiveFormat -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArchiveFormat -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArchiveFormat -> r
gmapT :: (forall b. Data b => b -> b) -> ArchiveFormat -> ArchiveFormat
$cgmapT :: (forall b. Data b => b -> b) -> ArchiveFormat -> ArchiveFormat
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ArchiveFormat)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ArchiveFormat)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArchiveFormat)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArchiveFormat)
dataTypeOf :: ArchiveFormat -> DataType
$cdataTypeOf :: ArchiveFormat -> DataType
toConstr :: ArchiveFormat -> Constr
$ctoConstr :: ArchiveFormat -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArchiveFormat
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArchiveFormat
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArchiveFormat -> c ArchiveFormat
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArchiveFormat -> c 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
$cto :: forall x. Rep ArchiveFormat x -> ArchiveFormat
$cfrom :: forall x. ArchiveFormat -> Rep ArchiveFormat x
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 (f :: * -> *) a. Applicative f => a -> f a
pure CollaboratorPermission
CollaboratorPermissionAdmin
        Text
"write" -> CollaboratorPermission -> Parser CollaboratorPermission
forall (f :: * -> *) a. Applicative f => a -> f a
pure CollaboratorPermission
CollaboratorPermissionWrite
        Text
"read"  -> CollaboratorPermission -> Parser CollaboratorPermission
forall (f :: * -> *) a. Applicative f => a -> f a
pure CollaboratorPermission
CollaboratorPermissionRead
        Text
"none"  -> CollaboratorPermission -> Parser CollaboratorPermission
forall (f :: * -> *) a. Applicative f => a -> f a
pure CollaboratorPermission
CollaboratorPermissionNone
        Text
_       -> String -> Parser CollaboratorPermission
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 (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"