{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric      #-}
{-# LANGUAGE NoImplicitPrelude  #-}
{-# LANGUAGE OverloadedStrings  #-}
-----------------------------------------------------------------------------
-- |
-- License     :  BSD-3-Clause
-- Maintainer  :  Oleg Grenrus <oleg.grenrus@iki.fi>
--
module GitHub.Data.Teams where

import GitHub.Data.Definitions
import GitHub.Data.Id          (Id)
import GitHub.Data.Name        (Name)
import GitHub.Data.Repos       (Repo)
import GitHub.Data.URL         (URL)
import GitHub.Internal.Prelude
import Prelude ()

import qualified Data.Text as T

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

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

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

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

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

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

data SimpleTeam = SimpleTeam
    { SimpleTeam -> Id Team
simpleTeamId              :: !(Id Team)
    , SimpleTeam -> URL
simpleTeamUrl             :: !URL
    , SimpleTeam -> Text
simpleTeamName            :: !Text  -- TODO (0.15.0): unify this and 'simpleTeamSlug' as in 'Team'.
    , SimpleTeam -> Name Team
simpleTeamSlug            :: !(Name Team)
    , SimpleTeam -> Maybe Text
simpleTeamDescription     :: !(Maybe Text)
    , SimpleTeam -> Privacy
simpleTeamPrivacy         :: !Privacy
    , SimpleTeam -> Permission
simpleTeamPermission      :: !Permission
    , SimpleTeam -> URL
simpleTeamMembersUrl      :: !URL
    , SimpleTeam -> URL
simpleTeamRepositoriesUrl :: !URL
    }
    deriving (Int -> SimpleTeam -> ShowS
[SimpleTeam] -> ShowS
SimpleTeam -> String
(Int -> SimpleTeam -> ShowS)
-> (SimpleTeam -> String)
-> ([SimpleTeam] -> ShowS)
-> Show SimpleTeam
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SimpleTeam] -> ShowS
$cshowList :: [SimpleTeam] -> ShowS
show :: SimpleTeam -> String
$cshow :: SimpleTeam -> String
showsPrec :: Int -> SimpleTeam -> ShowS
$cshowsPrec :: Int -> SimpleTeam -> ShowS
Show, Typeable SimpleTeam
DataType
Constr
Typeable SimpleTeam
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SimpleTeam -> c SimpleTeam)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SimpleTeam)
-> (SimpleTeam -> Constr)
-> (SimpleTeam -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SimpleTeam))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SimpleTeam))
-> ((forall b. Data b => b -> b) -> SimpleTeam -> SimpleTeam)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SimpleTeam -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SimpleTeam -> r)
-> (forall u. (forall d. Data d => d -> u) -> SimpleTeam -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SimpleTeam -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SimpleTeam -> m SimpleTeam)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SimpleTeam -> m SimpleTeam)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SimpleTeam -> m SimpleTeam)
-> Data SimpleTeam
SimpleTeam -> DataType
SimpleTeam -> Constr
(forall b. Data b => b -> b) -> SimpleTeam -> SimpleTeam
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SimpleTeam -> c SimpleTeam
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SimpleTeam
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) -> SimpleTeam -> u
forall u. (forall d. Data d => d -> u) -> SimpleTeam -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SimpleTeam -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SimpleTeam -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SimpleTeam -> m SimpleTeam
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SimpleTeam -> m SimpleTeam
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SimpleTeam
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SimpleTeam -> c SimpleTeam
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SimpleTeam)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SimpleTeam)
$cSimpleTeam :: Constr
$tSimpleTeam :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SimpleTeam -> m SimpleTeam
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SimpleTeam -> m SimpleTeam
gmapMp :: (forall d. Data d => d -> m d) -> SimpleTeam -> m SimpleTeam
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SimpleTeam -> m SimpleTeam
gmapM :: (forall d. Data d => d -> m d) -> SimpleTeam -> m SimpleTeam
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SimpleTeam -> m SimpleTeam
gmapQi :: Int -> (forall d. Data d => d -> u) -> SimpleTeam -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SimpleTeam -> u
gmapQ :: (forall d. Data d => d -> u) -> SimpleTeam -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SimpleTeam -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SimpleTeam -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SimpleTeam -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SimpleTeam -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SimpleTeam -> r
gmapT :: (forall b. Data b => b -> b) -> SimpleTeam -> SimpleTeam
$cgmapT :: (forall b. Data b => b -> b) -> SimpleTeam -> SimpleTeam
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SimpleTeam)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SimpleTeam)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SimpleTeam)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SimpleTeam)
dataTypeOf :: SimpleTeam -> DataType
$cdataTypeOf :: SimpleTeam -> DataType
toConstr :: SimpleTeam -> Constr
$ctoConstr :: SimpleTeam -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SimpleTeam
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SimpleTeam
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SimpleTeam -> c SimpleTeam
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SimpleTeam -> c SimpleTeam
$cp1Data :: Typeable SimpleTeam
Data, Typeable, SimpleTeam -> SimpleTeam -> Bool
(SimpleTeam -> SimpleTeam -> Bool)
-> (SimpleTeam -> SimpleTeam -> Bool) -> Eq SimpleTeam
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SimpleTeam -> SimpleTeam -> Bool
$c/= :: SimpleTeam -> SimpleTeam -> Bool
== :: SimpleTeam -> SimpleTeam -> Bool
$c== :: SimpleTeam -> SimpleTeam -> Bool
Eq, Eq SimpleTeam
Eq SimpleTeam
-> (SimpleTeam -> SimpleTeam -> Ordering)
-> (SimpleTeam -> SimpleTeam -> Bool)
-> (SimpleTeam -> SimpleTeam -> Bool)
-> (SimpleTeam -> SimpleTeam -> Bool)
-> (SimpleTeam -> SimpleTeam -> Bool)
-> (SimpleTeam -> SimpleTeam -> SimpleTeam)
-> (SimpleTeam -> SimpleTeam -> SimpleTeam)
-> Ord SimpleTeam
SimpleTeam -> SimpleTeam -> Bool
SimpleTeam -> SimpleTeam -> Ordering
SimpleTeam -> SimpleTeam -> SimpleTeam
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 :: SimpleTeam -> SimpleTeam -> SimpleTeam
$cmin :: SimpleTeam -> SimpleTeam -> SimpleTeam
max :: SimpleTeam -> SimpleTeam -> SimpleTeam
$cmax :: SimpleTeam -> SimpleTeam -> SimpleTeam
>= :: SimpleTeam -> SimpleTeam -> Bool
$c>= :: SimpleTeam -> SimpleTeam -> Bool
> :: SimpleTeam -> SimpleTeam -> Bool
$c> :: SimpleTeam -> SimpleTeam -> Bool
<= :: SimpleTeam -> SimpleTeam -> Bool
$c<= :: SimpleTeam -> SimpleTeam -> Bool
< :: SimpleTeam -> SimpleTeam -> Bool
$c< :: SimpleTeam -> SimpleTeam -> Bool
compare :: SimpleTeam -> SimpleTeam -> Ordering
$ccompare :: SimpleTeam -> SimpleTeam -> Ordering
$cp1Ord :: Eq SimpleTeam
Ord, (forall x. SimpleTeam -> Rep SimpleTeam x)
-> (forall x. Rep SimpleTeam x -> SimpleTeam) -> Generic SimpleTeam
forall x. Rep SimpleTeam x -> SimpleTeam
forall x. SimpleTeam -> Rep SimpleTeam x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SimpleTeam x -> SimpleTeam
$cfrom :: forall x. SimpleTeam -> Rep SimpleTeam x
Generic)

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

data Team = Team
    { Team -> Id Team
teamId              :: !(Id Team)
    , Team -> URL
teamUrl             :: !URL
    , Team -> Text
teamName            :: !Text
    , Team -> Name Team
teamSlug            :: !(Name Team)
    , Team -> Maybe Text
teamDescription     :: !(Maybe Text)
    , Team -> Privacy
teamPrivacy         :: !Privacy
    , Team -> Permission
teamPermission      :: !Permission
    , Team -> URL
teamMembersUrl      :: !URL
    , Team -> URL
teamRepositoriesUrl :: !URL
    , Team -> Int
teamMembersCount    :: !Int
    , Team -> Int
teamReposCount      :: !Int
    , Team -> SimpleOrganization
teamOrganization    :: !SimpleOrganization
    }
    deriving (Int -> Team -> ShowS
[Team] -> ShowS
Team -> String
(Int -> Team -> ShowS)
-> (Team -> String) -> ([Team] -> ShowS) -> Show Team
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Team] -> ShowS
$cshowList :: [Team] -> ShowS
show :: Team -> String
$cshow :: Team -> String
showsPrec :: Int -> Team -> ShowS
$cshowsPrec :: Int -> Team -> ShowS
Show, Typeable Team
DataType
Constr
Typeable Team
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Team -> c Team)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Team)
-> (Team -> Constr)
-> (Team -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Team))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Team))
-> ((forall b. Data b => b -> b) -> Team -> Team)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Team -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Team -> r)
-> (forall u. (forall d. Data d => d -> u) -> Team -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Team -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Team -> m Team)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Team -> m Team)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Team -> m Team)
-> Data Team
Team -> DataType
Team -> Constr
(forall b. Data b => b -> b) -> Team -> Team
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Team -> c Team
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Team
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) -> Team -> u
forall u. (forall d. Data d => d -> u) -> Team -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Team -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Team -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Team -> m Team
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Team -> m Team
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Team
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Team -> c Team
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Team)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Team)
$cTeam :: Constr
$tTeam :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Team -> m Team
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Team -> m Team
gmapMp :: (forall d. Data d => d -> m d) -> Team -> m Team
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Team -> m Team
gmapM :: (forall d. Data d => d -> m d) -> Team -> m Team
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Team -> m Team
gmapQi :: Int -> (forall d. Data d => d -> u) -> Team -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Team -> u
gmapQ :: (forall d. Data d => d -> u) -> Team -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Team -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Team -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Team -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Team -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Team -> r
gmapT :: (forall b. Data b => b -> b) -> Team -> Team
$cgmapT :: (forall b. Data b => b -> b) -> Team -> Team
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Team)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Team)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Team)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Team)
dataTypeOf :: Team -> DataType
$cdataTypeOf :: Team -> DataType
toConstr :: Team -> Constr
$ctoConstr :: Team -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Team
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Team
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Team -> c Team
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Team -> c Team
$cp1Data :: Typeable Team
Data, Typeable, Team -> Team -> Bool
(Team -> Team -> Bool) -> (Team -> Team -> Bool) -> Eq Team
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Team -> Team -> Bool
$c/= :: Team -> Team -> Bool
== :: Team -> Team -> Bool
$c== :: Team -> Team -> Bool
Eq, Eq Team
Eq Team
-> (Team -> Team -> Ordering)
-> (Team -> Team -> Bool)
-> (Team -> Team -> Bool)
-> (Team -> Team -> Bool)
-> (Team -> Team -> Bool)
-> (Team -> Team -> Team)
-> (Team -> Team -> Team)
-> Ord Team
Team -> Team -> Bool
Team -> Team -> Ordering
Team -> Team -> Team
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 :: Team -> Team -> Team
$cmin :: Team -> Team -> Team
max :: Team -> Team -> Team
$cmax :: Team -> Team -> Team
>= :: Team -> Team -> Bool
$c>= :: Team -> Team -> Bool
> :: Team -> Team -> Bool
$c> :: Team -> Team -> Bool
<= :: Team -> Team -> Bool
$c<= :: Team -> Team -> Bool
< :: Team -> Team -> Bool
$c< :: Team -> Team -> Bool
compare :: Team -> Team -> Ordering
$ccompare :: Team -> Team -> Ordering
$cp1Ord :: Eq Team
Ord, (forall x. Team -> Rep Team x)
-> (forall x. Rep Team x -> Team) -> Generic Team
forall x. Rep Team x -> Team
forall x. Team -> Rep Team x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Team x -> Team
$cfrom :: forall x. Team -> Rep Team x
Generic)

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

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

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

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

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

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

instance NFData Role
instance Binary Role

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

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

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

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

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

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

-- JSON Instances

instance FromJSON SimpleTeam where
    parseJSON :: Value -> Parser SimpleTeam
parseJSON = String
-> (Object -> Parser SimpleTeam) -> Value -> Parser SimpleTeam
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"SimpleTeam" ((Object -> Parser SimpleTeam) -> Value -> Parser SimpleTeam)
-> (Object -> Parser SimpleTeam) -> Value -> Parser SimpleTeam
forall a b. (a -> b) -> a -> b
$ \Object
o -> Id Team
-> URL
-> Text
-> Name Team
-> Maybe Text
-> Privacy
-> Permission
-> URL
-> URL
-> SimpleTeam
SimpleTeam
        (Id Team
 -> URL
 -> Text
 -> Name Team
 -> Maybe Text
 -> Privacy
 -> Permission
 -> URL
 -> URL
 -> SimpleTeam)
-> Parser (Id Team)
-> Parser
     (URL
      -> Text
      -> Name Team
      -> Maybe Text
      -> Privacy
      -> Permission
      -> URL
      -> URL
      -> SimpleTeam)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Id Team)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
        Parser
  (URL
   -> Text
   -> Name Team
   -> Maybe Text
   -> Privacy
   -> Permission
   -> URL
   -> URL
   -> SimpleTeam)
-> Parser URL
-> Parser
     (Text
      -> Name Team
      -> Maybe Text
      -> Privacy
      -> Permission
      -> URL
      -> URL
      -> SimpleTeam)
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
  (Text
   -> Name Team
   -> Maybe Text
   -> Privacy
   -> Permission
   -> URL
   -> URL
   -> SimpleTeam)
-> Parser Text
-> Parser
     (Name Team
      -> Maybe Text -> Privacy -> Permission -> URL -> URL -> SimpleTeam)
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"
        Parser
  (Name Team
   -> Maybe Text -> Privacy -> Permission -> URL -> URL -> SimpleTeam)
-> Parser (Name Team)
-> Parser
     (Maybe Text -> Privacy -> Permission -> URL -> URL -> SimpleTeam)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Name Team)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"slug"
        Parser
  (Maybe Text -> Privacy -> Permission -> URL -> URL -> SimpleTeam)
-> Parser (Maybe Text)
-> Parser (Privacy -> Permission -> URL -> URL -> SimpleTeam)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe (Maybe Text))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:?Key
"description" Parser (Maybe (Maybe Text)) -> Maybe Text -> Parser (Maybe Text)
forall a. Parser (Maybe a) -> a -> Parser a
.!= Maybe Text
forall a. Maybe a
Nothing
        Parser (Privacy -> Permission -> URL -> URL -> SimpleTeam)
-> Parser Privacy
-> Parser (Permission -> URL -> URL -> SimpleTeam)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Privacy
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"privacy"
        Parser (Permission -> URL -> URL -> SimpleTeam)
-> Parser Permission -> Parser (URL -> URL -> SimpleTeam)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Permission
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"permission"
        Parser (URL -> URL -> SimpleTeam)
-> Parser URL -> Parser (URL -> SimpleTeam)
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
"members_url"
        Parser (URL -> SimpleTeam) -> Parser URL -> Parser SimpleTeam
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
"repositories_url"

instance FromJSON Team where
    parseJSON :: Value -> Parser Team
parseJSON = String -> (Object -> Parser Team) -> Value -> Parser Team
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Team" ((Object -> Parser Team) -> Value -> Parser Team)
-> (Object -> Parser Team) -> Value -> Parser Team
forall a b. (a -> b) -> a -> b
$ \Object
o -> Id Team
-> URL
-> Text
-> Name Team
-> Maybe Text
-> Privacy
-> Permission
-> URL
-> URL
-> Int
-> Int
-> SimpleOrganization
-> Team
Team
        (Id Team
 -> URL
 -> Text
 -> Name Team
 -> Maybe Text
 -> Privacy
 -> Permission
 -> URL
 -> URL
 -> Int
 -> Int
 -> SimpleOrganization
 -> Team)
-> Parser (Id Team)
-> Parser
     (URL
      -> Text
      -> Name Team
      -> Maybe Text
      -> Privacy
      -> Permission
      -> URL
      -> URL
      -> Int
      -> Int
      -> SimpleOrganization
      -> Team)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Id Team)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
        Parser
  (URL
   -> Text
   -> Name Team
   -> Maybe Text
   -> Privacy
   -> Permission
   -> URL
   -> URL
   -> Int
   -> Int
   -> SimpleOrganization
   -> Team)
-> Parser URL
-> Parser
     (Text
      -> Name Team
      -> Maybe Text
      -> Privacy
      -> Permission
      -> URL
      -> URL
      -> Int
      -> Int
      -> SimpleOrganization
      -> Team)
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
  (Text
   -> Name Team
   -> Maybe Text
   -> Privacy
   -> Permission
   -> URL
   -> URL
   -> Int
   -> Int
   -> SimpleOrganization
   -> Team)
-> Parser Text
-> Parser
     (Name Team
      -> Maybe Text
      -> Privacy
      -> Permission
      -> URL
      -> URL
      -> Int
      -> Int
      -> SimpleOrganization
      -> Team)
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"
        Parser
  (Name Team
   -> Maybe Text
   -> Privacy
   -> Permission
   -> URL
   -> URL
   -> Int
   -> Int
   -> SimpleOrganization
   -> Team)
-> Parser (Name Team)
-> Parser
     (Maybe Text
      -> Privacy
      -> Permission
      -> URL
      -> URL
      -> Int
      -> Int
      -> SimpleOrganization
      -> Team)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Name Team)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"slug"
        Parser
  (Maybe Text
   -> Privacy
   -> Permission
   -> URL
   -> URL
   -> Int
   -> Int
   -> SimpleOrganization
   -> Team)
-> Parser (Maybe Text)
-> Parser
     (Privacy
      -> Permission
      -> URL
      -> URL
      -> Int
      -> Int
      -> SimpleOrganization
      -> Team)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe (Maybe Text))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:?Key
"description" Parser (Maybe (Maybe Text)) -> Maybe Text -> Parser (Maybe Text)
forall a. Parser (Maybe a) -> a -> Parser a
.!= Maybe Text
forall a. Maybe a
Nothing
        Parser
  (Privacy
   -> Permission
   -> URL
   -> URL
   -> Int
   -> Int
   -> SimpleOrganization
   -> Team)
-> Parser Privacy
-> Parser
     (Permission
      -> URL -> URL -> Int -> Int -> SimpleOrganization -> Team)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Privacy
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"privacy"
        Parser
  (Permission
   -> URL -> URL -> Int -> Int -> SimpleOrganization -> Team)
-> Parser Permission
-> Parser (URL -> URL -> Int -> Int -> SimpleOrganization -> Team)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Permission
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"permission"
        Parser (URL -> URL -> Int -> Int -> SimpleOrganization -> Team)
-> Parser URL
-> Parser (URL -> Int -> Int -> SimpleOrganization -> Team)
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
"members_url"
        Parser (URL -> Int -> Int -> SimpleOrganization -> Team)
-> Parser URL -> Parser (Int -> Int -> SimpleOrganization -> Team)
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
"repositories_url"
        Parser (Int -> Int -> SimpleOrganization -> Team)
-> Parser Int -> Parser (Int -> SimpleOrganization -> Team)
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
"members_count"
        Parser (Int -> SimpleOrganization -> Team)
-> Parser Int -> Parser (SimpleOrganization -> Team)
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
"repos_count"
        Parser (SimpleOrganization -> Team)
-> Parser SimpleOrganization -> Parser Team
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser SimpleOrganization
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"organization"

instance ToJSON CreateTeam where
    toJSON :: CreateTeam -> Value
toJSON (CreateTeam Name Team
name Maybe Text
desc Vector (Name Repo)
repo_names Privacy
privacy Permission
permission) =
        [Pair] -> Value
object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ (Pair -> Bool) -> [Pair] -> [Pair]
forall a. (a -> Bool) -> [a] -> [a]
filter Pair -> Bool
forall a. (a, Value) -> Bool
notNull
            [ Key
"name"        Key -> Name Team -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Name Team
name
            , Key
"description" Key -> Maybe Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
desc
            , Key
"repo_names"  Key -> Vector (Name Repo) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Vector (Name Repo)
repo_names
            , Key
"privacy"     Key -> Privacy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Privacy
privacy
            , Key
"permission"  Key -> Permission -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Permission
permission
            ]
      where
        notNull :: (a, Value) -> Bool
notNull (a
_, Value
Null) = Bool
False
        notNull (a
_, Value
_) = Bool
True

instance ToJSON EditTeam where
    toJSON :: EditTeam -> Value
toJSON (EditTeam Name Team
name Maybe Text
desc Maybe Privacy
privacy Maybe Permission
permission) =
        [Pair] -> Value
object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ (Pair -> Bool) -> [Pair] -> [Pair]
forall a. (a -> Bool) -> [a] -> [a]
filter Pair -> Bool
forall a. (a, Value) -> Bool
notNull
            [ Key
"name"        Key -> Name Team -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Name Team
name
            , Key
"description" Key -> Maybe Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
desc
            , Key
"privacy"     Key -> Maybe Privacy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Privacy
privacy
            , Key
"permission"  Key -> Maybe Permission -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Permission
permission
            ]
      where
        notNull :: (a, Value) -> Bool
notNull (a
_, Value
Null) = Bool
False
        notNull (a
_, Value
_) = Bool
True

instance FromJSON TeamMembership where
    parseJSON :: Value -> Parser TeamMembership
parseJSON = String
-> (Object -> Parser TeamMembership)
-> Value
-> Parser TeamMembership
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"TeamMembership" ((Object -> Parser TeamMembership)
 -> Value -> Parser TeamMembership)
-> (Object -> Parser TeamMembership)
-> Value
-> Parser TeamMembership
forall a b. (a -> b) -> a -> b
$ \Object
o -> URL -> Role -> ReqState -> TeamMembership
TeamMembership
        (URL -> Role -> ReqState -> TeamMembership)
-> Parser URL -> Parser (Role -> ReqState -> TeamMembership)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
        Parser (Role -> ReqState -> TeamMembership)
-> Parser Role -> Parser (ReqState -> TeamMembership)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Role
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"role"
        Parser (ReqState -> TeamMembership)
-> Parser ReqState -> Parser TeamMembership
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser ReqState
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"state"

instance FromJSON CreateTeamMembership where
    parseJSON :: Value -> Parser CreateTeamMembership
parseJSON = String
-> (Object -> Parser CreateTeamMembership)
-> Value
-> Parser CreateTeamMembership
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"CreateTeamMembership" ((Object -> Parser CreateTeamMembership)
 -> Value -> Parser CreateTeamMembership)
-> (Object -> Parser CreateTeamMembership)
-> Value
-> Parser CreateTeamMembership
forall a b. (a -> b) -> a -> b
$ \Object
o -> Role -> CreateTeamMembership
CreateTeamMembership
        (Role -> CreateTeamMembership)
-> Parser Role -> Parser CreateTeamMembership
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Role
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"role"

instance ToJSON CreateTeamMembership where
    toJSON :: CreateTeamMembership -> Value
toJSON (CreateTeamMembership { createTeamMembershipRole :: CreateTeamMembership -> Role
createTeamMembershipRole = Role
role }) =
        [Pair] -> Value
object [ Key
"role" Key -> Role -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Role
role ]

instance FromJSON AddTeamRepoPermission where
    parseJSON :: Value -> Parser AddTeamRepoPermission
parseJSON = String
-> (Object -> Parser AddTeamRepoPermission)
-> Value
-> Parser AddTeamRepoPermission
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"AddTeamRepoPermission" ((Object -> Parser AddTeamRepoPermission)
 -> Value -> Parser AddTeamRepoPermission)
-> (Object -> Parser AddTeamRepoPermission)
-> Value
-> Parser AddTeamRepoPermission
forall a b. (a -> b) -> a -> b
$ \Object
o -> Permission -> AddTeamRepoPermission
AddTeamRepoPermission
        (Permission -> AddTeamRepoPermission)
-> Parser Permission -> Parser AddTeamRepoPermission
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Permission
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"permission"

instance ToJSON AddTeamRepoPermission where
    toJSON :: AddTeamRepoPermission -> Value
toJSON (AddTeamRepoPermission { addTeamRepoPermission :: AddTeamRepoPermission -> Permission
addTeamRepoPermission = Permission
permission}) =
        [Pair] -> Value
object [ Key
"permission" Key -> Permission -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Permission
permission ]

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

instance ToJSON Role where
    toJSON :: Role -> Value
toJSON Role
RoleMaintainer = Text -> Value
String Text
"maintainer"
    toJSON Role
RoleMember     = Text -> Value
String Text
"member"

instance FromJSON Permission where
    parseJSON :: Value -> Parser Permission
parseJSON = String -> (Text -> Parser Permission) -> Value -> Parser Permission
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"Permission" ((Text -> Parser Permission) -> Value -> Parser Permission)
-> (Text -> Parser Permission) -> Value -> Parser Permission
forall a b. (a -> b) -> a -> b
$ \Text
t -> case Text -> Text
T.toLower Text
t of
        Text
"pull"  -> Permission -> Parser Permission
forall (f :: * -> *) a. Applicative f => a -> f a
pure Permission
PermissionPull
        Text
"push"  -> Permission -> Parser Permission
forall (f :: * -> *) a. Applicative f => a -> f a
pure Permission
PermissionPush
        Text
"admin" -> Permission -> Parser Permission
forall (f :: * -> *) a. Applicative f => a -> f a
pure Permission
PermissionAdmin
        Text
_       -> String -> Parser Permission
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser Permission) -> String -> Parser Permission
forall a b. (a -> b) -> a -> b
$ String
"Unknown Permission: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Text -> String
T.unpack Text
t

instance ToJSON Permission where
    toJSON :: Permission -> Value
toJSON Permission
PermissionPull  = Value
"pull"
    toJSON Permission
PermissionPush  = Value
"push"
    toJSON Permission
PermissionAdmin = Value
"admin"

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

instance ToJSON Privacy where
    toJSON :: Privacy -> Value
toJSON Privacy
PrivacySecret = Text -> Value
String Text
"secret"
    toJSON Privacy
PrivacyClosed = Text -> Value
String Text
"closed"

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

instance ToJSON ReqState where
    toJSON :: ReqState -> Value
toJSON ReqState
StateActive  = Text -> Value
String Text
"active"
    toJSON ReqState
StatePending = Text -> Value
String Text
"pending"

-- | Filters members returned by their role in the team.
data TeamMemberRole
    = TeamMemberRoleAll         -- ^ all members of the team.
    | TeamMemberRoleMaintainer  -- ^ team maintainers
    | TeamMemberRoleMember      -- ^ normal members of the team.
    deriving (Int -> TeamMemberRole -> ShowS
[TeamMemberRole] -> ShowS
TeamMemberRole -> String
(Int -> TeamMemberRole -> ShowS)
-> (TeamMemberRole -> String)
-> ([TeamMemberRole] -> ShowS)
-> Show TeamMemberRole
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TeamMemberRole] -> ShowS
$cshowList :: [TeamMemberRole] -> ShowS
show :: TeamMemberRole -> String
$cshow :: TeamMemberRole -> String
showsPrec :: Int -> TeamMemberRole -> ShowS
$cshowsPrec :: Int -> TeamMemberRole -> ShowS
Show, TeamMemberRole -> TeamMemberRole -> Bool
(TeamMemberRole -> TeamMemberRole -> Bool)
-> (TeamMemberRole -> TeamMemberRole -> Bool) -> Eq TeamMemberRole
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TeamMemberRole -> TeamMemberRole -> Bool
$c/= :: TeamMemberRole -> TeamMemberRole -> Bool
== :: TeamMemberRole -> TeamMemberRole -> Bool
$c== :: TeamMemberRole -> TeamMemberRole -> Bool
Eq, Eq TeamMemberRole
Eq TeamMemberRole
-> (TeamMemberRole -> TeamMemberRole -> Ordering)
-> (TeamMemberRole -> TeamMemberRole -> Bool)
-> (TeamMemberRole -> TeamMemberRole -> Bool)
-> (TeamMemberRole -> TeamMemberRole -> Bool)
-> (TeamMemberRole -> TeamMemberRole -> Bool)
-> (TeamMemberRole -> TeamMemberRole -> TeamMemberRole)
-> (TeamMemberRole -> TeamMemberRole -> TeamMemberRole)
-> Ord TeamMemberRole
TeamMemberRole -> TeamMemberRole -> Bool
TeamMemberRole -> TeamMemberRole -> Ordering
TeamMemberRole -> TeamMemberRole -> TeamMemberRole
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 :: TeamMemberRole -> TeamMemberRole -> TeamMemberRole
$cmin :: TeamMemberRole -> TeamMemberRole -> TeamMemberRole
max :: TeamMemberRole -> TeamMemberRole -> TeamMemberRole
$cmax :: TeamMemberRole -> TeamMemberRole -> TeamMemberRole
>= :: TeamMemberRole -> TeamMemberRole -> Bool
$c>= :: TeamMemberRole -> TeamMemberRole -> Bool
> :: TeamMemberRole -> TeamMemberRole -> Bool
$c> :: TeamMemberRole -> TeamMemberRole -> Bool
<= :: TeamMemberRole -> TeamMemberRole -> Bool
$c<= :: TeamMemberRole -> TeamMemberRole -> Bool
< :: TeamMemberRole -> TeamMemberRole -> Bool
$c< :: TeamMemberRole -> TeamMemberRole -> Bool
compare :: TeamMemberRole -> TeamMemberRole -> Ordering
$ccompare :: TeamMemberRole -> TeamMemberRole -> Ordering
$cp1Ord :: Eq TeamMemberRole
Ord, Int -> TeamMemberRole
TeamMemberRole -> Int
TeamMemberRole -> [TeamMemberRole]
TeamMemberRole -> TeamMemberRole
TeamMemberRole -> TeamMemberRole -> [TeamMemberRole]
TeamMemberRole
-> TeamMemberRole -> TeamMemberRole -> [TeamMemberRole]
(TeamMemberRole -> TeamMemberRole)
-> (TeamMemberRole -> TeamMemberRole)
-> (Int -> TeamMemberRole)
-> (TeamMemberRole -> Int)
-> (TeamMemberRole -> [TeamMemberRole])
-> (TeamMemberRole -> TeamMemberRole -> [TeamMemberRole])
-> (TeamMemberRole -> TeamMemberRole -> [TeamMemberRole])
-> (TeamMemberRole
    -> TeamMemberRole -> TeamMemberRole -> [TeamMemberRole])
-> Enum TeamMemberRole
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 :: TeamMemberRole
-> TeamMemberRole -> TeamMemberRole -> [TeamMemberRole]
$cenumFromThenTo :: TeamMemberRole
-> TeamMemberRole -> TeamMemberRole -> [TeamMemberRole]
enumFromTo :: TeamMemberRole -> TeamMemberRole -> [TeamMemberRole]
$cenumFromTo :: TeamMemberRole -> TeamMemberRole -> [TeamMemberRole]
enumFromThen :: TeamMemberRole -> TeamMemberRole -> [TeamMemberRole]
$cenumFromThen :: TeamMemberRole -> TeamMemberRole -> [TeamMemberRole]
enumFrom :: TeamMemberRole -> [TeamMemberRole]
$cenumFrom :: TeamMemberRole -> [TeamMemberRole]
fromEnum :: TeamMemberRole -> Int
$cfromEnum :: TeamMemberRole -> Int
toEnum :: Int -> TeamMemberRole
$ctoEnum :: Int -> TeamMemberRole
pred :: TeamMemberRole -> TeamMemberRole
$cpred :: TeamMemberRole -> TeamMemberRole
succ :: TeamMemberRole -> TeamMemberRole
$csucc :: TeamMemberRole -> TeamMemberRole
Enum, TeamMemberRole
TeamMemberRole -> TeamMemberRole -> Bounded TeamMemberRole
forall a. a -> a -> Bounded a
maxBound :: TeamMemberRole
$cmaxBound :: TeamMemberRole
minBound :: TeamMemberRole
$cminBound :: TeamMemberRole
Bounded, Typeable, Typeable TeamMemberRole
DataType
Constr
Typeable TeamMemberRole
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TeamMemberRole -> c TeamMemberRole)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TeamMemberRole)
-> (TeamMemberRole -> Constr)
-> (TeamMemberRole -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TeamMemberRole))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TeamMemberRole))
-> ((forall b. Data b => b -> b)
    -> TeamMemberRole -> TeamMemberRole)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TeamMemberRole -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TeamMemberRole -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TeamMemberRole -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TeamMemberRole -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TeamMemberRole -> m TeamMemberRole)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TeamMemberRole -> m TeamMemberRole)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TeamMemberRole -> m TeamMemberRole)
-> Data TeamMemberRole
TeamMemberRole -> DataType
TeamMemberRole -> Constr
(forall b. Data b => b -> b) -> TeamMemberRole -> TeamMemberRole
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TeamMemberRole -> c TeamMemberRole
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TeamMemberRole
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) -> TeamMemberRole -> u
forall u. (forall d. Data d => d -> u) -> TeamMemberRole -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TeamMemberRole -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TeamMemberRole -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TeamMemberRole -> m TeamMemberRole
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TeamMemberRole -> m TeamMemberRole
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TeamMemberRole
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TeamMemberRole -> c TeamMemberRole
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TeamMemberRole)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TeamMemberRole)
$cTeamMemberRoleMember :: Constr
$cTeamMemberRoleMaintainer :: Constr
$cTeamMemberRoleAll :: Constr
$tTeamMemberRole :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> TeamMemberRole -> m TeamMemberRole
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TeamMemberRole -> m TeamMemberRole
gmapMp :: (forall d. Data d => d -> m d)
-> TeamMemberRole -> m TeamMemberRole
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TeamMemberRole -> m TeamMemberRole
gmapM :: (forall d. Data d => d -> m d)
-> TeamMemberRole -> m TeamMemberRole
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TeamMemberRole -> m TeamMemberRole
gmapQi :: Int -> (forall d. Data d => d -> u) -> TeamMemberRole -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TeamMemberRole -> u
gmapQ :: (forall d. Data d => d -> u) -> TeamMemberRole -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TeamMemberRole -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TeamMemberRole -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TeamMemberRole -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TeamMemberRole -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TeamMemberRole -> r
gmapT :: (forall b. Data b => b -> b) -> TeamMemberRole -> TeamMemberRole
$cgmapT :: (forall b. Data b => b -> b) -> TeamMemberRole -> TeamMemberRole
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TeamMemberRole)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TeamMemberRole)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TeamMemberRole)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TeamMemberRole)
dataTypeOf :: TeamMemberRole -> DataType
$cdataTypeOf :: TeamMemberRole -> DataType
toConstr :: TeamMemberRole -> Constr
$ctoConstr :: TeamMemberRole -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TeamMemberRole
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TeamMemberRole
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TeamMemberRole -> c TeamMemberRole
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TeamMemberRole -> c TeamMemberRole
$cp1Data :: Typeable TeamMemberRole
Data, (forall x. TeamMemberRole -> Rep TeamMemberRole x)
-> (forall x. Rep TeamMemberRole x -> TeamMemberRole)
-> Generic TeamMemberRole
forall x. Rep TeamMemberRole x -> TeamMemberRole
forall x. TeamMemberRole -> Rep TeamMemberRole x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TeamMemberRole x -> TeamMemberRole
$cfrom :: forall x. TeamMemberRole -> Rep TeamMemberRole x
Generic)