module GitHub.Data.Definitions where

import GitHub.Internal.Prelude
import Prelude ()

import Control.Monad       (mfilter)
import Data.Aeson.Types    (Parser)
import Network.HTTP.Client (HttpException)

import qualified Control.Exception as E
import qualified Data.ByteString   as BS
import qualified Data.Text         as T

import GitHub.Data.Id   (Id)
import GitHub.Data.Name (Name)
import GitHub.Data.URL  (URL (..))

-- | Errors have been tagged according to their source, so you can more easily
-- dispatch and handle them.
data Error
    = HTTPError !HttpException -- ^ A HTTP error occurred. The actual caught error is included.
    | ParseError !Text -- ^ An error in the parser itself.
    | JsonError !Text -- ^ The JSON is malformed or unexpected.
    | UserError !Text -- ^ Incorrect input.
    deriving (Int -> Error -> ShowS
[Error] -> ShowS
Error -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Error] -> ShowS
$cshowList :: [Error] -> ShowS
show :: Error -> String
$cshow :: Error -> String
showsPrec :: Int -> Error -> ShowS
$cshowsPrec :: Int -> Error -> ShowS
Show, Typeable)

instance E.Exception Error

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

instance NFData OwnerType
instance Binary OwnerType

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

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

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

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

-- | Sometimes we don't know the type of the owner, e.g. in 'Repo'
data SimpleOwner = SimpleOwner
    { SimpleOwner -> Id Owner
simpleOwnerId        :: !(Id Owner)
    , SimpleOwner -> Name Owner
simpleOwnerLogin     :: !(Name Owner)
    , SimpleOwner -> URL
simpleOwnerUrl       :: !URL
    , SimpleOwner -> URL
simpleOwnerAvatarUrl :: !URL
    , SimpleOwner -> OwnerType
simpleOwnerType      :: !OwnerType
    }
    deriving (Int -> SimpleOwner -> ShowS
[SimpleOwner] -> ShowS
SimpleOwner -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SimpleOwner] -> ShowS
$cshowList :: [SimpleOwner] -> ShowS
show :: SimpleOwner -> String
$cshow :: SimpleOwner -> String
showsPrec :: Int -> SimpleOwner -> ShowS
$cshowsPrec :: Int -> SimpleOwner -> ShowS
Show, Typeable SimpleOwner
SimpleOwner -> DataType
SimpleOwner -> Constr
(forall b. Data b => b -> b) -> SimpleOwner -> SimpleOwner
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) -> SimpleOwner -> u
forall u. (forall d. Data d => d -> u) -> SimpleOwner -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SimpleOwner -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SimpleOwner -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SimpleOwner -> m SimpleOwner
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SimpleOwner -> m SimpleOwner
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SimpleOwner
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SimpleOwner -> c SimpleOwner
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SimpleOwner)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SimpleOwner)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SimpleOwner -> m SimpleOwner
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SimpleOwner -> m SimpleOwner
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SimpleOwner -> m SimpleOwner
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SimpleOwner -> m SimpleOwner
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SimpleOwner -> m SimpleOwner
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SimpleOwner -> m SimpleOwner
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SimpleOwner -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SimpleOwner -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> SimpleOwner -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SimpleOwner -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SimpleOwner -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SimpleOwner -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SimpleOwner -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SimpleOwner -> r
gmapT :: (forall b. Data b => b -> b) -> SimpleOwner -> SimpleOwner
$cgmapT :: (forall b. Data b => b -> b) -> SimpleOwner -> SimpleOwner
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SimpleOwner)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SimpleOwner)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SimpleOwner)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SimpleOwner)
dataTypeOf :: SimpleOwner -> DataType
$cdataTypeOf :: SimpleOwner -> DataType
toConstr :: SimpleOwner -> Constr
$ctoConstr :: SimpleOwner -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SimpleOwner
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SimpleOwner
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SimpleOwner -> c SimpleOwner
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SimpleOwner -> c SimpleOwner
Data, Typeable, SimpleOwner -> SimpleOwner -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SimpleOwner -> SimpleOwner -> Bool
$c/= :: SimpleOwner -> SimpleOwner -> Bool
== :: SimpleOwner -> SimpleOwner -> Bool
$c== :: SimpleOwner -> SimpleOwner -> Bool
Eq, Eq SimpleOwner
SimpleOwner -> SimpleOwner -> Bool
SimpleOwner -> SimpleOwner -> Ordering
SimpleOwner -> SimpleOwner -> SimpleOwner
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 :: SimpleOwner -> SimpleOwner -> SimpleOwner
$cmin :: SimpleOwner -> SimpleOwner -> SimpleOwner
max :: SimpleOwner -> SimpleOwner -> SimpleOwner
$cmax :: SimpleOwner -> SimpleOwner -> SimpleOwner
>= :: SimpleOwner -> SimpleOwner -> Bool
$c>= :: SimpleOwner -> SimpleOwner -> Bool
> :: SimpleOwner -> SimpleOwner -> Bool
$c> :: SimpleOwner -> SimpleOwner -> Bool
<= :: SimpleOwner -> SimpleOwner -> Bool
$c<= :: SimpleOwner -> SimpleOwner -> Bool
< :: SimpleOwner -> SimpleOwner -> Bool
$c< :: SimpleOwner -> SimpleOwner -> Bool
compare :: SimpleOwner -> SimpleOwner -> Ordering
$ccompare :: SimpleOwner -> SimpleOwner -> Ordering
Ord, forall x. Rep SimpleOwner x -> SimpleOwner
forall x. SimpleOwner -> Rep SimpleOwner x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SimpleOwner x -> SimpleOwner
$cfrom :: forall x. SimpleOwner -> Rep SimpleOwner x
Generic)

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

data User = User
    { User -> Id User
userId          :: !(Id User)
    , User -> Name User
userLogin       :: !(Name User)
    , User -> Maybe Text
userName        :: !(Maybe Text)
    , User -> OwnerType
userType        :: !OwnerType  -- ^ Should always be 'OwnerUser' or 'OwnerBot'
    , User -> UTCTime
userCreatedAt   :: !UTCTime
    , User -> Int
userPublicGists :: !Int
    , User -> URL
userAvatarUrl   :: !URL
    , User -> Int
userFollowers   :: !Int
    , User -> Int
userFollowing   :: !Int
    , User -> Maybe Bool
userHireable    :: !(Maybe Bool)
    , User -> Maybe Text
userBlog        :: !(Maybe Text)
    , User -> Maybe Text
userBio         :: !(Maybe Text)
    , User -> Int
userPublicRepos :: !Int
    , User -> Maybe Text
userLocation    :: !(Maybe Text)
    , User -> Maybe Text
userCompany     :: !(Maybe Text)
    , User -> Maybe Text
userEmail       :: !(Maybe Text)
    , User -> URL
userUrl         :: !URL
    , User -> URL
userHtmlUrl     :: !URL
    }
    deriving (Int -> User -> ShowS
[User] -> ShowS
User -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [User] -> ShowS
$cshowList :: [User] -> ShowS
show :: User -> String
$cshow :: User -> String
showsPrec :: Int -> User -> ShowS
$cshowsPrec :: Int -> User -> ShowS
Show, Typeable User
User -> DataType
User -> Constr
(forall b. Data b => b -> b) -> User -> User
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) -> User -> u
forall u. (forall d. Data d => d -> u) -> User -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> User -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> User -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> User -> m User
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> User -> m User
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c User
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> User -> c User
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c User)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c User)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> User -> m User
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> User -> m User
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> User -> m User
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> User -> m User
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> User -> m User
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> User -> m User
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> User -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> User -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> User -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> User -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> User -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> User -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> User -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> User -> r
gmapT :: (forall b. Data b => b -> b) -> User -> User
$cgmapT :: (forall b. Data b => b -> b) -> User -> User
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c User)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c User)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c User)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c User)
dataTypeOf :: User -> DataType
$cdataTypeOf :: User -> DataType
toConstr :: User -> Constr
$ctoConstr :: User -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c User
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c User
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> User -> c User
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> User -> c User
Data, Typeable, User -> User -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: User -> User -> Bool
$c/= :: User -> User -> Bool
== :: User -> User -> Bool
$c== :: User -> User -> Bool
Eq, Eq User
User -> User -> Bool
User -> User -> Ordering
User -> User -> User
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 :: User -> User -> User
$cmin :: User -> User -> User
max :: User -> User -> User
$cmax :: User -> User -> User
>= :: User -> User -> Bool
$c>= :: User -> User -> Bool
> :: User -> User -> Bool
$c> :: User -> User -> Bool
<= :: User -> User -> Bool
$c<= :: User -> User -> Bool
< :: User -> User -> Bool
$c< :: User -> User -> Bool
compare :: User -> User -> Ordering
$ccompare :: User -> User -> Ordering
Ord, forall x. Rep User x -> User
forall x. User -> Rep User x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep User x -> User
$cfrom :: forall x. User -> Rep User x
Generic)

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

data Organization = Organization
    { Organization -> Id Organization
organizationId          :: !(Id Organization)
    , Organization -> Name Organization
organizationLogin       :: !(Name Organization)
    , Organization -> Maybe Text
organizationName        :: !(Maybe Text)
    , Organization -> OwnerType
organizationType        :: !OwnerType  -- ^ Should always be 'OwnerOrganization'
    , Organization -> Maybe Text
organizationBlog        :: !(Maybe Text)
    , Organization -> Maybe Text
organizationLocation    :: !(Maybe Text)
    , Organization -> Int
organizationFollowers   :: !Int
    , Organization -> Maybe Text
organizationCompany     :: !(Maybe Text)
    , Organization -> URL
organizationAvatarUrl   :: !URL
    , Organization -> Int
organizationPublicGists :: !Int
    , Organization -> URL
organizationHtmlUrl     :: !URL
    , Organization -> Maybe Text
organizationEmail       :: !(Maybe Text)
    , Organization -> Int
organizationFollowing   :: !Int
    , Organization -> Int
organizationPublicRepos :: !Int
    , Organization -> URL
organizationUrl         :: !URL
    , Organization -> UTCTime
organizationCreatedAt   :: !UTCTime
    }
    deriving (Int -> Organization -> ShowS
[Organization] -> ShowS
Organization -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Organization] -> ShowS
$cshowList :: [Organization] -> ShowS
show :: Organization -> String
$cshow :: Organization -> String
showsPrec :: Int -> Organization -> ShowS
$cshowsPrec :: Int -> Organization -> ShowS
Show, Typeable Organization
Organization -> DataType
Organization -> Constr
(forall b. Data b => b -> b) -> Organization -> Organization
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) -> Organization -> u
forall u. (forall d. Data d => d -> u) -> Organization -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Organization -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Organization -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Organization -> m Organization
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Organization -> m Organization
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Organization
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Organization -> c Organization
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Organization)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Organization)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Organization -> m Organization
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Organization -> m Organization
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Organization -> m Organization
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Organization -> m Organization
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Organization -> m Organization
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Organization -> m Organization
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Organization -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Organization -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Organization -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Organization -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Organization -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Organization -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Organization -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Organization -> r
gmapT :: (forall b. Data b => b -> b) -> Organization -> Organization
$cgmapT :: (forall b. Data b => b -> b) -> Organization -> Organization
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Organization)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Organization)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Organization)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Organization)
dataTypeOf :: Organization -> DataType
$cdataTypeOf :: Organization -> DataType
toConstr :: Organization -> Constr
$ctoConstr :: Organization -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Organization
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Organization
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Organization -> c Organization
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Organization -> c Organization
Data, Typeable, Organization -> Organization -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Organization -> Organization -> Bool
$c/= :: Organization -> Organization -> Bool
== :: Organization -> Organization -> Bool
$c== :: Organization -> Organization -> Bool
Eq, Eq Organization
Organization -> Organization -> Bool
Organization -> Organization -> Ordering
Organization -> Organization -> Organization
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 :: Organization -> Organization -> Organization
$cmin :: Organization -> Organization -> Organization
max :: Organization -> Organization -> Organization
$cmax :: Organization -> Organization -> Organization
>= :: Organization -> Organization -> Bool
$c>= :: Organization -> Organization -> Bool
> :: Organization -> Organization -> Bool
$c> :: Organization -> Organization -> Bool
<= :: Organization -> Organization -> Bool
$c<= :: Organization -> Organization -> Bool
< :: Organization -> Organization -> Bool
$c< :: Organization -> Organization -> Bool
compare :: Organization -> Organization -> Ordering
$ccompare :: Organization -> Organization -> Ordering
Ord, forall x. Rep Organization x -> Organization
forall x. Organization -> Rep Organization x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Organization x -> Organization
$cfrom :: forall x. Organization -> Rep Organization x
Generic)

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

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

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

fromOwner :: Owner -> Either User Organization
fromOwner :: Owner -> Either User Organization
fromOwner (Owner Either User Organization
owner) = Either User Organization
owner

-- JSON instances

instance FromJSON OwnerType where
    parseJSON :: Value -> Parser OwnerType
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"OwnerType" forall a b. (a -> b) -> a -> b
$ \Text
t -> case Text -> Text
T.toLower Text
t of
        Text
"user"         -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ OwnerType
OwnerUser
        Text
"organization" -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ OwnerType
OwnerOrganization
        Text
"bot"          -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ OwnerType
OwnerBot
        Text
_              -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"Unknown OwnerType: " forall a. Semigroup a => a -> a -> a
<> Text -> String
T.unpack Text
t

instance FromJSON SimpleUser where
    parseJSON :: Value -> Parser SimpleUser
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"SimpleUser" forall a b. (a -> b) -> a -> b
$ \Object
obj -> do
        Id User -> Name User -> URL -> URL -> SimpleUser
SimpleUser
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"login"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"avatar_url"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"

instance FromJSON SimpleOrganization where
    parseJSON :: Value -> Parser SimpleOrganization
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"SimpleOrganization" forall a b. (a -> b) -> a -> b
$ \Object
obj ->
        Id Organization
-> Name Organization -> URL -> URL -> SimpleOrganization
SimpleOrganization
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"login"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"avatar_url"

instance FromJSON SimpleOwner where
    parseJSON :: Value -> Parser SimpleOwner
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"SimpleOwner" forall a b. (a -> b) -> a -> b
$ \Object
obj -> do
        Id Owner -> Name Owner -> URL -> URL -> OwnerType -> SimpleOwner
SimpleOwner
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"login"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"avatar_url"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"

parseUser :: Object -> Parser User
parseUser :: Object -> Parser User
parseUser Object
obj = Id User
-> Name User
-> Maybe Text
-> OwnerType
-> UTCTime
-> Int
-> URL
-> Int
-> Int
-> Maybe Bool
-> Maybe Text
-> Maybe Text
-> Int
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> URL
-> URL
-> User
User
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"login"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"name"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"public_gists"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"avatar_url"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"followers"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"following"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"hireable"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"blog"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"bio"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"public_repos"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"location"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"company"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"email"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"html_url"

parseOrganization :: Object -> Parser Organization
parseOrganization :: Object -> Parser Organization
parseOrganization Object
obj = Id Organization
-> Name Organization
-> Maybe Text
-> OwnerType
-> Maybe Text
-> Maybe Text
-> Int
-> Maybe Text
-> URL
-> Int
-> URL
-> Maybe Text
-> Int
-> Int
-> URL
-> UTCTime
-> Organization
Organization
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"login"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"name"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"blog"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"location"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"followers"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"company"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"avatar_url"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"public_gists"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"html_url"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"email"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"following"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"public_repos"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"

instance FromJSON User where
    parseJSON :: Value -> Parser User
parseJSON = forall (m :: * -> *) a. MonadPlus m => (a -> Bool) -> m a -> m a
mfilter ((forall a. Eq a => a -> a -> Bool
/= OwnerType
OwnerOrganization) forall b c a. (b -> c) -> (a -> b) -> a -> c
. User -> OwnerType
userType) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"User" Object -> Parser User
parseUser

instance FromJSON Organization where
    parseJSON :: Value -> Parser Organization
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Organization" Object -> Parser Organization
parseOrganization

instance FromJSON Owner where
    parseJSON :: Value -> Parser Owner
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Owner" forall a b. (a -> b) -> a -> b
$ \Object
obj -> do
        OwnerType
t <- Object
obj forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
        case OwnerType
t of
            OwnerType
OwnerUser         -> Either User Organization -> Owner
Owner forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> Either a b
Left forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object -> Parser User
parseUser Object
obj
            OwnerType
OwnerBot          -> Either User Organization -> Owner
Owner forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> Either a b
Left forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object -> Parser User
parseUser Object
obj
            OwnerType
OwnerOrganization -> Either User Organization -> Owner
Owner forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. b -> Either a b
Right forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object -> Parser Organization
parseOrganization Object
obj

-- | Filter members returned in the list.
data OrgMemberFilter
    = OrgMemberFilter2faDisabled  -- ^ Members without two-factor authentication enabled. Available for organization owners.
    | OrgMemberFilterAll          -- ^ All members the authenticated user can see.
    deriving (Int -> OrgMemberFilter -> ShowS
[OrgMemberFilter] -> ShowS
OrgMemberFilter -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OrgMemberFilter] -> ShowS
$cshowList :: [OrgMemberFilter] -> ShowS
show :: OrgMemberFilter -> String
$cshow :: OrgMemberFilter -> String
showsPrec :: Int -> OrgMemberFilter -> ShowS
$cshowsPrec :: Int -> OrgMemberFilter -> ShowS
Show, OrgMemberFilter -> OrgMemberFilter -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OrgMemberFilter -> OrgMemberFilter -> Bool
$c/= :: OrgMemberFilter -> OrgMemberFilter -> Bool
== :: OrgMemberFilter -> OrgMemberFilter -> Bool
$c== :: OrgMemberFilter -> OrgMemberFilter -> Bool
Eq, Eq OrgMemberFilter
OrgMemberFilter -> OrgMemberFilter -> Bool
OrgMemberFilter -> OrgMemberFilter -> Ordering
OrgMemberFilter -> OrgMemberFilter -> OrgMemberFilter
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 :: OrgMemberFilter -> OrgMemberFilter -> OrgMemberFilter
$cmin :: OrgMemberFilter -> OrgMemberFilter -> OrgMemberFilter
max :: OrgMemberFilter -> OrgMemberFilter -> OrgMemberFilter
$cmax :: OrgMemberFilter -> OrgMemberFilter -> OrgMemberFilter
>= :: OrgMemberFilter -> OrgMemberFilter -> Bool
$c>= :: OrgMemberFilter -> OrgMemberFilter -> Bool
> :: OrgMemberFilter -> OrgMemberFilter -> Bool
$c> :: OrgMemberFilter -> OrgMemberFilter -> Bool
<= :: OrgMemberFilter -> OrgMemberFilter -> Bool
$c<= :: OrgMemberFilter -> OrgMemberFilter -> Bool
< :: OrgMemberFilter -> OrgMemberFilter -> Bool
$c< :: OrgMemberFilter -> OrgMemberFilter -> Bool
compare :: OrgMemberFilter -> OrgMemberFilter -> Ordering
$ccompare :: OrgMemberFilter -> OrgMemberFilter -> Ordering
Ord, Int -> OrgMemberFilter
OrgMemberFilter -> Int
OrgMemberFilter -> [OrgMemberFilter]
OrgMemberFilter -> OrgMemberFilter
OrgMemberFilter -> OrgMemberFilter -> [OrgMemberFilter]
OrgMemberFilter
-> OrgMemberFilter -> OrgMemberFilter -> [OrgMemberFilter]
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 :: OrgMemberFilter
-> OrgMemberFilter -> OrgMemberFilter -> [OrgMemberFilter]
$cenumFromThenTo :: OrgMemberFilter
-> OrgMemberFilter -> OrgMemberFilter -> [OrgMemberFilter]
enumFromTo :: OrgMemberFilter -> OrgMemberFilter -> [OrgMemberFilter]
$cenumFromTo :: OrgMemberFilter -> OrgMemberFilter -> [OrgMemberFilter]
enumFromThen :: OrgMemberFilter -> OrgMemberFilter -> [OrgMemberFilter]
$cenumFromThen :: OrgMemberFilter -> OrgMemberFilter -> [OrgMemberFilter]
enumFrom :: OrgMemberFilter -> [OrgMemberFilter]
$cenumFrom :: OrgMemberFilter -> [OrgMemberFilter]
fromEnum :: OrgMemberFilter -> Int
$cfromEnum :: OrgMemberFilter -> Int
toEnum :: Int -> OrgMemberFilter
$ctoEnum :: Int -> OrgMemberFilter
pred :: OrgMemberFilter -> OrgMemberFilter
$cpred :: OrgMemberFilter -> OrgMemberFilter
succ :: OrgMemberFilter -> OrgMemberFilter
$csucc :: OrgMemberFilter -> OrgMemberFilter
Enum, OrgMemberFilter
forall a. a -> a -> Bounded a
maxBound :: OrgMemberFilter
$cmaxBound :: OrgMemberFilter
minBound :: OrgMemberFilter
$cminBound :: OrgMemberFilter
Bounded, Typeable, Typeable OrgMemberFilter
OrgMemberFilter -> DataType
OrgMemberFilter -> Constr
(forall b. Data b => b -> b) -> OrgMemberFilter -> OrgMemberFilter
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) -> OrgMemberFilter -> u
forall u. (forall d. Data d => d -> u) -> OrgMemberFilter -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OrgMemberFilter -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OrgMemberFilter -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> OrgMemberFilter -> m OrgMemberFilter
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OrgMemberFilter -> m OrgMemberFilter
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OrgMemberFilter
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OrgMemberFilter -> c OrgMemberFilter
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OrgMemberFilter)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OrgMemberFilter)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OrgMemberFilter -> m OrgMemberFilter
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OrgMemberFilter -> m OrgMemberFilter
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OrgMemberFilter -> m OrgMemberFilter
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OrgMemberFilter -> m OrgMemberFilter
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> OrgMemberFilter -> m OrgMemberFilter
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> OrgMemberFilter -> m OrgMemberFilter
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> OrgMemberFilter -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> OrgMemberFilter -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> OrgMemberFilter -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OrgMemberFilter -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OrgMemberFilter -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OrgMemberFilter -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OrgMemberFilter -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OrgMemberFilter -> r
gmapT :: (forall b. Data b => b -> b) -> OrgMemberFilter -> OrgMemberFilter
$cgmapT :: (forall b. Data b => b -> b) -> OrgMemberFilter -> OrgMemberFilter
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OrgMemberFilter)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OrgMemberFilter)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OrgMemberFilter)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OrgMemberFilter)
dataTypeOf :: OrgMemberFilter -> DataType
$cdataTypeOf :: OrgMemberFilter -> DataType
toConstr :: OrgMemberFilter -> Constr
$ctoConstr :: OrgMemberFilter -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OrgMemberFilter
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OrgMemberFilter
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OrgMemberFilter -> c OrgMemberFilter
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OrgMemberFilter -> c OrgMemberFilter
Data, forall x. Rep OrgMemberFilter x -> OrgMemberFilter
forall x. OrgMemberFilter -> Rep OrgMemberFilter x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OrgMemberFilter x -> OrgMemberFilter
$cfrom :: forall x. OrgMemberFilter -> Rep OrgMemberFilter x
Generic)

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

-- | Request query string
type QueryString = [(BS.ByteString, Maybe BS.ByteString)]

-- | Count of elements
type Count = Int

-------------------------------------------------------------------------------
-- IssueNumber
-------------------------------------------------------------------------------

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

unIssueNumber :: IssueNumber -> Int
unIssueNumber :: IssueNumber -> Int
unIssueNumber (IssueNumber Int
i) = Int
i

instance Hashable IssueNumber
instance Binary IssueNumber

instance NFData IssueNumber where
    rnf :: IssueNumber -> ()
rnf (IssueNumber Int
s) = forall a. NFData a => a -> ()
rnf Int
s

instance FromJSON IssueNumber where
    parseJSON :: Value -> Parser IssueNumber
parseJSON = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> IssueNumber
IssueNumber forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. FromJSON a => Value -> Parser a
parseJSON

instance ToJSON IssueNumber where
    toJSON :: IssueNumber -> Value
toJSON = forall a. ToJSON a => a -> Value
toJSON forall b c a. (b -> c) -> (a -> b) -> a -> c
. IssueNumber -> Int
unIssueNumber

-------------------------------------------------------------------------------
-- IssueLabel
-------------------------------------------------------------------------------

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

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

instance FromJSON IssueLabel where
    parseJSON :: Value -> Parser IssueLabel
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"IssueLabel" forall a b. (a -> b) -> a -> b
$ \Object
o -> Text -> URL -> Name IssueLabel -> Maybe Text -> IssueLabel
IssueLabel
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"color"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"url" forall a. Parser (Maybe a) -> a -> Parser a
.!= Text -> URL
URL Text
"" -- in events there aren't URL
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"description"


-------------------------------------------------------------------------------
-- NewIssueLabel
-------------------------------------------------------------------------------

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

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


instance ToJSON NewIssueLabel where
    toJSON :: NewIssueLabel -> Value
toJSON (NewIssueLabel Text
color Name NewIssueLabel
lblName Maybe Text
lblDesc) = [Pair] -> Value
object forall a b. (a -> b) -> a -> b
$ forall a. (a -> Bool) -> [a] -> [a]
filter forall {a}. (a, Value) -> Bool
notNull
        [ Key
"name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Name NewIssueLabel
lblName
        , Key
"color" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
color
        , Key
"description" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
lblDesc
        ]
        where
            notNull :: (a, Value) -> Bool
notNull (a
_, Value
Null) = Bool
False
            notNull (a
_, Value
_)    = Bool
True



-------------------------------------------------------------------------------
-- UpdateIssueLabel
-------------------------------------------------------------------------------

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

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


instance ToJSON UpdateIssueLabel where
    toJSON :: UpdateIssueLabel -> Value
toJSON (UpdateIssueLabel Text
color Name UpdateIssueLabel
lblName Maybe Text
lblDesc) = [Pair] -> Value
object forall a b. (a -> b) -> a -> b
$ forall a. (a -> Bool) -> [a] -> [a]
filter forall {a}. (a, Value) -> Bool
notNull
        [ Key
"new_name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Name UpdateIssueLabel
lblName
        , Key
"color" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
color
        , Key
"description" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
lblDesc
        ]
        where
            notNull :: (a, Value) -> Bool
notNull (a
_, Value
Null) = Bool
False
            notNull (a
_, Value
_)    = Bool
True