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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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