{-# LANGUAGE DataKinds         #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE KindSignatures    #-}
{-# LANGUAGE RecordWildCards   #-}

module GitHub.Data.Actions.Secrets (
    OrganizationSecret(..),
    PublicKey(..),
    SetSecret(..),
    SetRepoSecret(..),
    SelectedRepo(..),
    SetSelectedRepositories(..),
    RepoSecret(..),
    Environment(..),
    ) where

import GitHub.Data.Id          (Id)
import GitHub.Internal.Prelude
import Prelude ()

import Data.Maybe                 (maybeToList)
import GitHub.Data.Actions.Common (WithTotalCount (WithTotalCount))
import GitHub.Data.Name           (Name)
import GitHub.Data.Repos          (Repo)

-------------------------------------------------------------------------------
-- Secret
-------------------------------------------------------------------------------

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

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

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

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

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

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

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

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

-------------------------------------------------------------------------------
-- JSON instances
-------------------------------------------------------------------------------

instance FromJSON OrganizationSecret where
    parseJSON :: Value -> Parser OrganizationSecret
parseJSON = String
-> (Object -> Parser OrganizationSecret)
-> Value
-> Parser OrganizationSecret
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Secret" ((Object -> Parser OrganizationSecret)
 -> Value -> Parser OrganizationSecret)
-> (Object -> Parser OrganizationSecret)
-> Value
-> Parser OrganizationSecret
forall a b. (a -> b) -> a -> b
$ \Object
o -> Name OrganizationSecret
-> UTCTime -> UTCTime -> Text -> OrganizationSecret
OrganizationSecret
        (Name OrganizationSecret
 -> UTCTime -> UTCTime -> Text -> OrganizationSecret)
-> Parser (Name OrganizationSecret)
-> Parser (UTCTime -> UTCTime -> Text -> OrganizationSecret)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Name OrganizationSecret)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
        Parser (UTCTime -> UTCTime -> Text -> OrganizationSecret)
-> Parser UTCTime -> Parser (UTCTime -> Text -> OrganizationSecret)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser UTCTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
        Parser (UTCTime -> Text -> OrganizationSecret)
-> Parser UTCTime -> Parser (Text -> OrganizationSecret)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser UTCTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
        Parser (Text -> OrganizationSecret)
-> Parser Text -> Parser OrganizationSecret
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"visibility"

instance FromJSON (WithTotalCount OrganizationSecret) where
    parseJSON :: Value -> Parser (WithTotalCount OrganizationSecret)
parseJSON = String
-> (Object -> Parser (WithTotalCount OrganizationSecret))
-> Value
-> Parser (WithTotalCount OrganizationSecret)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"SecretList" ((Object -> Parser (WithTotalCount OrganizationSecret))
 -> Value -> Parser (WithTotalCount OrganizationSecret))
-> (Object -> Parser (WithTotalCount OrganizationSecret))
-> Value
-> Parser (WithTotalCount OrganizationSecret)
forall a b. (a -> b) -> a -> b
$ \Object
o -> Vector OrganizationSecret
-> Int -> WithTotalCount OrganizationSecret
forall a. Vector a -> Int -> WithTotalCount a
WithTotalCount
        (Vector OrganizationSecret
 -> Int -> WithTotalCount OrganizationSecret)
-> Parser (Vector OrganizationSecret)
-> Parser (Int -> WithTotalCount OrganizationSecret)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Vector OrganizationSecret)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"secrets"
        Parser (Int -> WithTotalCount OrganizationSecret)
-> Parser Int -> Parser (WithTotalCount OrganizationSecret)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"total_count"

instance FromJSON PublicKey where
    parseJSON :: Value -> Parser PublicKey
parseJSON = String -> (Object -> Parser PublicKey) -> Value -> Parser PublicKey
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"PublicKey" ((Object -> Parser PublicKey) -> Value -> Parser PublicKey)
-> (Object -> Parser PublicKey) -> Value -> Parser PublicKey
forall a b. (a -> b) -> a -> b
$ \Object
o -> Text -> Text -> PublicKey
PublicKey
        (Text -> Text -> PublicKey)
-> Parser Text -> Parser (Text -> PublicKey)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"key_id"
        Parser (Text -> PublicKey) -> Parser Text -> Parser PublicKey
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"key"

instance FromJSON SelectedRepo where
    parseJSON :: Value -> Parser SelectedRepo
parseJSON = String
-> (Object -> Parser SelectedRepo) -> Value -> Parser SelectedRepo
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"SelectedRepo" ((Object -> Parser SelectedRepo) -> Value -> Parser SelectedRepo)
-> (Object -> Parser SelectedRepo) -> Value -> Parser SelectedRepo
forall a b. (a -> b) -> a -> b
$ \Object
o -> Id Repo -> Name Repo -> SelectedRepo
SelectedRepo
        (Id Repo -> Name Repo -> SelectedRepo)
-> Parser (Id Repo) -> Parser (Name Repo -> SelectedRepo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Id Repo)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
        Parser (Name Repo -> SelectedRepo)
-> Parser (Name Repo) -> Parser SelectedRepo
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Name Repo)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"

instance ToJSON SetSelectedRepositories where
    toJSON :: SetSelectedRepositories -> Value
toJSON SetSelectedRepositories{[Id Repo]
setSelectedRepositoriesRepositoryIds :: SetSelectedRepositories -> [Id Repo]
setSelectedRepositoriesRepositoryIds :: [Id Repo]
..} =
        [Pair] -> Value
object
            [ Key
"selected_repository_ids" Key -> [Id Repo] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.=  [Id Repo]
setSelectedRepositoriesRepositoryIds
            ]

instance ToJSON SetSecret where
    toJSON :: SetSecret -> Value
toJSON SetSecret{Maybe [Id Repo]
Text
setSecretPublicKeyId :: SetSecret -> Text
setSecretEncryptedValue :: SetSecret -> Text
setSecretVisibility :: SetSecret -> Text
setSecretSelectedRepositoryIds :: SetSecret -> Maybe [Id Repo]
setSecretPublicKeyId :: Text
setSecretEncryptedValue :: Text
setSecretVisibility :: Text
setSecretSelectedRepositoryIds :: Maybe [Id Repo]
..} =
        [Pair] -> Value
object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$
            [ Key
"encrypted_value" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
setSecretEncryptedValue
            ,  Key
"key_id" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
setSecretPublicKeyId
            ,  Key
"visibility" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
setSecretVisibility
            ] [Pair] -> [Pair] -> [Pair]
forall a. Semigroup a => a -> a -> a
<> Maybe Pair -> [Pair]
forall a. Maybe a -> [a]
maybeToList (([Id Repo] -> Pair) -> Maybe [Id Repo] -> Maybe Pair
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Key
"selected_repository_ids" Key -> [Id Repo] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.=) Maybe [Id Repo]
setSecretSelectedRepositoryIds)

instance ToJSON SetRepoSecret where
    toJSON :: SetRepoSecret -> Value
toJSON SetRepoSecret{Text
setRepoSecretPublicKeyId :: SetRepoSecret -> Text
setRepoSecretEncryptedValue :: SetRepoSecret -> Text
setRepoSecretPublicKeyId :: Text
setRepoSecretEncryptedValue :: Text
..} =
        [Pair] -> Value
object
            [ Key
"encrypted_value" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
setRepoSecretEncryptedValue
            ,  Key
"key_id" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
setRepoSecretPublicKeyId
            ]

instance FromJSON (WithTotalCount SelectedRepo) where
    parseJSON :: Value -> Parser (WithTotalCount SelectedRepo)
parseJSON = String
-> (Object -> Parser (WithTotalCount SelectedRepo))
-> Value
-> Parser (WithTotalCount SelectedRepo)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"SelectedRepoList" ((Object -> Parser (WithTotalCount SelectedRepo))
 -> Value -> Parser (WithTotalCount SelectedRepo))
-> (Object -> Parser (WithTotalCount SelectedRepo))
-> Value
-> Parser (WithTotalCount SelectedRepo)
forall a b. (a -> b) -> a -> b
$ \Object
o -> Vector SelectedRepo -> Int -> WithTotalCount SelectedRepo
forall a. Vector a -> Int -> WithTotalCount a
WithTotalCount
        (Vector SelectedRepo -> Int -> WithTotalCount SelectedRepo)
-> Parser (Vector SelectedRepo)
-> Parser (Int -> WithTotalCount SelectedRepo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Vector SelectedRepo)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"repositories"
        Parser (Int -> WithTotalCount SelectedRepo)
-> Parser Int -> Parser (WithTotalCount SelectedRepo)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"total_count"

instance FromJSON RepoSecret where
    parseJSON :: Value -> Parser RepoSecret
parseJSON = String
-> (Object -> Parser RepoSecret) -> Value -> Parser RepoSecret
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"RepoSecret" ((Object -> Parser RepoSecret) -> Value -> Parser RepoSecret)
-> (Object -> Parser RepoSecret) -> Value -> Parser RepoSecret
forall a b. (a -> b) -> a -> b
$ \Object
o -> Name RepoSecret -> UTCTime -> UTCTime -> RepoSecret
RepoSecret
        (Name RepoSecret -> UTCTime -> UTCTime -> RepoSecret)
-> Parser (Name RepoSecret)
-> Parser (UTCTime -> UTCTime -> RepoSecret)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Name RepoSecret)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
        Parser (UTCTime -> UTCTime -> RepoSecret)
-> Parser UTCTime -> Parser (UTCTime -> RepoSecret)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser UTCTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
        Parser (UTCTime -> RepoSecret)
-> Parser UTCTime -> Parser RepoSecret
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser UTCTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"

instance FromJSON (WithTotalCount RepoSecret) where
    parseJSON :: Value -> Parser (WithTotalCount RepoSecret)
parseJSON = String
-> (Object -> Parser (WithTotalCount RepoSecret))
-> Value
-> Parser (WithTotalCount RepoSecret)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"RepoSecretList" ((Object -> Parser (WithTotalCount RepoSecret))
 -> Value -> Parser (WithTotalCount RepoSecret))
-> (Object -> Parser (WithTotalCount RepoSecret))
-> Value
-> Parser (WithTotalCount RepoSecret)
forall a b. (a -> b) -> a -> b
$ \Object
o -> Vector RepoSecret -> Int -> WithTotalCount RepoSecret
forall a. Vector a -> Int -> WithTotalCount a
WithTotalCount
        (Vector RepoSecret -> Int -> WithTotalCount RepoSecret)
-> Parser (Vector RepoSecret)
-> Parser (Int -> WithTotalCount RepoSecret)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Vector RepoSecret)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"secrets"
        Parser (Int -> WithTotalCount RepoSecret)
-> Parser Int -> Parser (WithTotalCount RepoSecret)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"total_count"