-- |
-- Module      : Zuul.Config
-- Description : Configuration data types
-- Copyright   : (c) Red Hat, 2022
-- License     : Apache-2.0
--
-- Maintainer  : tdecacqu@redhat.com, fboucher@redhat.com
-- Stability   : provisional
-- Portability : portable
--
-- The Zuul Configuration data types.
--
-- See: https://zuul-ci.org/docs/zuul/latest/project-config.html#configuration-items
module Zuul.Config
  ( -- * Newtype wrappers
    TenantName (..),
    JobName (..),
    ProjectName (..),
    ProjectRegex (..),
    PipelineName (..),
    NodesetName (..),
    NodeLabelName (..),
    ProjectTemplateName (..),
    SecretName (..),
    QueueName (..),
    SemaphoreName (..),

    -- * Project identifiers
    BranchName (..),
    ProviderName (..),
    ConnectionName (..),
    ConnectionUrl (..),
    CanonicalProjectName (..),

    -- * Configuration data types
    Job (..),
    JobNodeset (..),
    Project (..),
    ProjectPipeline (..),
    PipelineJob (..),
    PipelineTrigger (..),
    PipelineReporter (..),
    Pipeline (..),
    Nodeset (..),
    ProjectTemplate (..),

    -- * Configuration identifiers
    ConfigLoc (..),
    ZuulConfigElement (..),
    ZuulConfigType (..),
  )
where

import ZuulWeeder.Prelude

newtype BranchName = BranchName Text
  deriving (BranchName -> BranchName -> Bool
(BranchName -> BranchName -> Bool)
-> (BranchName -> BranchName -> Bool) -> Eq BranchName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BranchName -> BranchName -> Bool
$c/= :: BranchName -> BranchName -> Bool
== :: BranchName -> BranchName -> Bool
$c== :: BranchName -> BranchName -> Bool
Eq, Eq BranchName
Eq BranchName
-> (BranchName -> BranchName -> Ordering)
-> (BranchName -> BranchName -> Bool)
-> (BranchName -> BranchName -> Bool)
-> (BranchName -> BranchName -> Bool)
-> (BranchName -> BranchName -> Bool)
-> (BranchName -> BranchName -> BranchName)
-> (BranchName -> BranchName -> BranchName)
-> Ord BranchName
BranchName -> BranchName -> Bool
BranchName -> BranchName -> Ordering
BranchName -> BranchName -> BranchName
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 :: BranchName -> BranchName -> BranchName
$cmin :: BranchName -> BranchName -> BranchName
max :: BranchName -> BranchName -> BranchName
$cmax :: BranchName -> BranchName -> BranchName
>= :: BranchName -> BranchName -> Bool
$c>= :: BranchName -> BranchName -> Bool
> :: BranchName -> BranchName -> Bool
$c> :: BranchName -> BranchName -> Bool
<= :: BranchName -> BranchName -> Bool
$c<= :: BranchName -> BranchName -> Bool
< :: BranchName -> BranchName -> Bool
$c< :: BranchName -> BranchName -> Bool
compare :: BranchName -> BranchName -> Ordering
$ccompare :: BranchName -> BranchName -> Ordering
Ord, Int -> BranchName -> ShowS
[BranchName] -> ShowS
BranchName -> String
(Int -> BranchName -> ShowS)
-> (BranchName -> String)
-> ([BranchName] -> ShowS)
-> Show BranchName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BranchName] -> ShowS
$cshowList :: [BranchName] -> ShowS
show :: BranchName -> String
$cshow :: BranchName -> String
showsPrec :: Int -> BranchName -> ShowS
$cshowsPrec :: Int -> BranchName -> ShowS
Show, (forall x. BranchName -> Rep BranchName x)
-> (forall x. Rep BranchName x -> BranchName) -> Generic BranchName
forall x. Rep BranchName x -> BranchName
forall x. BranchName -> Rep BranchName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BranchName x -> BranchName
$cfrom :: forall x. BranchName -> Rep BranchName x
Generic)
  deriving newtype (Eq BranchName
Eq BranchName
-> (Int -> BranchName -> Int)
-> (BranchName -> Int)
-> Hashable BranchName
Int -> BranchName -> Int
BranchName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: BranchName -> Int
$chash :: BranchName -> Int
hashWithSalt :: Int -> BranchName -> Int
$chashWithSalt :: Int -> BranchName -> Int
Hashable, Value -> Parser [BranchName]
Value -> Parser BranchName
(Value -> Parser BranchName)
-> (Value -> Parser [BranchName]) -> FromJSON BranchName
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [BranchName]
$cparseJSONList :: Value -> Parser [BranchName]
parseJSON :: Value -> Parser BranchName
$cparseJSON :: Value -> Parser BranchName
FromJSON, [BranchName] -> Encoding
[BranchName] -> Value
BranchName -> Encoding
BranchName -> Value
(BranchName -> Value)
-> (BranchName -> Encoding)
-> ([BranchName] -> Value)
-> ([BranchName] -> Encoding)
-> ToJSON BranchName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [BranchName] -> Encoding
$ctoEncodingList :: [BranchName] -> Encoding
toJSONList :: [BranchName] -> Value
$ctoJSONList :: [BranchName] -> Value
toEncoding :: BranchName -> Encoding
$ctoEncoding :: BranchName -> Encoding
toJSON :: BranchName -> Value
$ctoJSON :: BranchName -> Value
ToJSON)

newtype JobName = JobName Text
  deriving (JobName -> JobName -> Bool
(JobName -> JobName -> Bool)
-> (JobName -> JobName -> Bool) -> Eq JobName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JobName -> JobName -> Bool
$c/= :: JobName -> JobName -> Bool
== :: JobName -> JobName -> Bool
$c== :: JobName -> JobName -> Bool
Eq, Eq JobName
Eq JobName
-> (JobName -> JobName -> Ordering)
-> (JobName -> JobName -> Bool)
-> (JobName -> JobName -> Bool)
-> (JobName -> JobName -> Bool)
-> (JobName -> JobName -> Bool)
-> (JobName -> JobName -> JobName)
-> (JobName -> JobName -> JobName)
-> Ord JobName
JobName -> JobName -> Bool
JobName -> JobName -> Ordering
JobName -> JobName -> JobName
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 :: JobName -> JobName -> JobName
$cmin :: JobName -> JobName -> JobName
max :: JobName -> JobName -> JobName
$cmax :: JobName -> JobName -> JobName
>= :: JobName -> JobName -> Bool
$c>= :: JobName -> JobName -> Bool
> :: JobName -> JobName -> Bool
$c> :: JobName -> JobName -> Bool
<= :: JobName -> JobName -> Bool
$c<= :: JobName -> JobName -> Bool
< :: JobName -> JobName -> Bool
$c< :: JobName -> JobName -> Bool
compare :: JobName -> JobName -> Ordering
$ccompare :: JobName -> JobName -> Ordering
Ord, Int -> JobName -> ShowS
[JobName] -> ShowS
JobName -> String
(Int -> JobName -> ShowS)
-> (JobName -> String) -> ([JobName] -> ShowS) -> Show JobName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JobName] -> ShowS
$cshowList :: [JobName] -> ShowS
show :: JobName -> String
$cshow :: JobName -> String
showsPrec :: Int -> JobName -> ShowS
$cshowsPrec :: Int -> JobName -> ShowS
Show, (forall x. JobName -> Rep JobName x)
-> (forall x. Rep JobName x -> JobName) -> Generic JobName
forall x. Rep JobName x -> JobName
forall x. JobName -> Rep JobName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep JobName x -> JobName
$cfrom :: forall x. JobName -> Rep JobName x
Generic)
  deriving newtype (Eq JobName
Eq JobName
-> (Int -> JobName -> Int) -> (JobName -> Int) -> Hashable JobName
Int -> JobName -> Int
JobName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: JobName -> Int
$chash :: JobName -> Int
hashWithSalt :: Int -> JobName -> Int
$chashWithSalt :: Int -> JobName -> Int
Hashable, Value -> Parser [JobName]
Value -> Parser JobName
(Value -> Parser JobName)
-> (Value -> Parser [JobName]) -> FromJSON JobName
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [JobName]
$cparseJSONList :: Value -> Parser [JobName]
parseJSON :: Value -> Parser JobName
$cparseJSON :: Value -> Parser JobName
FromJSON, FromJSONKeyFunction [JobName]
FromJSONKeyFunction JobName
FromJSONKeyFunction JobName
-> FromJSONKeyFunction [JobName] -> FromJSONKey JobName
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [JobName]
$cfromJSONKeyList :: FromJSONKeyFunction [JobName]
fromJSONKey :: FromJSONKeyFunction JobName
$cfromJSONKey :: FromJSONKeyFunction JobName
FromJSONKey, [JobName] -> Encoding
[JobName] -> Value
JobName -> Encoding
JobName -> Value
(JobName -> Value)
-> (JobName -> Encoding)
-> ([JobName] -> Value)
-> ([JobName] -> Encoding)
-> ToJSON JobName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [JobName] -> Encoding
$ctoEncodingList :: [JobName] -> Encoding
toJSONList :: [JobName] -> Value
$ctoJSONList :: [JobName] -> Value
toEncoding :: JobName -> Encoding
$ctoEncoding :: JobName -> Encoding
toJSON :: JobName -> Value
$ctoJSON :: JobName -> Value
ToJSON, ToJSONKeyFunction [JobName]
ToJSONKeyFunction JobName
ToJSONKeyFunction JobName
-> ToJSONKeyFunction [JobName] -> ToJSONKey JobName
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [JobName]
$ctoJSONKeyList :: ToJSONKeyFunction [JobName]
toJSONKey :: ToJSONKeyFunction JobName
$ctoJSONKey :: ToJSONKeyFunction JobName
ToJSONKey)

newtype PipelineName = PipelineName Text
  deriving (PipelineName -> PipelineName -> Bool
(PipelineName -> PipelineName -> Bool)
-> (PipelineName -> PipelineName -> Bool) -> Eq PipelineName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PipelineName -> PipelineName -> Bool
$c/= :: PipelineName -> PipelineName -> Bool
== :: PipelineName -> PipelineName -> Bool
$c== :: PipelineName -> PipelineName -> Bool
Eq, Eq PipelineName
Eq PipelineName
-> (PipelineName -> PipelineName -> Ordering)
-> (PipelineName -> PipelineName -> Bool)
-> (PipelineName -> PipelineName -> Bool)
-> (PipelineName -> PipelineName -> Bool)
-> (PipelineName -> PipelineName -> Bool)
-> (PipelineName -> PipelineName -> PipelineName)
-> (PipelineName -> PipelineName -> PipelineName)
-> Ord PipelineName
PipelineName -> PipelineName -> Bool
PipelineName -> PipelineName -> Ordering
PipelineName -> PipelineName -> PipelineName
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 :: PipelineName -> PipelineName -> PipelineName
$cmin :: PipelineName -> PipelineName -> PipelineName
max :: PipelineName -> PipelineName -> PipelineName
$cmax :: PipelineName -> PipelineName -> PipelineName
>= :: PipelineName -> PipelineName -> Bool
$c>= :: PipelineName -> PipelineName -> Bool
> :: PipelineName -> PipelineName -> Bool
$c> :: PipelineName -> PipelineName -> Bool
<= :: PipelineName -> PipelineName -> Bool
$c<= :: PipelineName -> PipelineName -> Bool
< :: PipelineName -> PipelineName -> Bool
$c< :: PipelineName -> PipelineName -> Bool
compare :: PipelineName -> PipelineName -> Ordering
$ccompare :: PipelineName -> PipelineName -> Ordering
Ord, Int -> PipelineName -> ShowS
[PipelineName] -> ShowS
PipelineName -> String
(Int -> PipelineName -> ShowS)
-> (PipelineName -> String)
-> ([PipelineName] -> ShowS)
-> Show PipelineName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PipelineName] -> ShowS
$cshowList :: [PipelineName] -> ShowS
show :: PipelineName -> String
$cshow :: PipelineName -> String
showsPrec :: Int -> PipelineName -> ShowS
$cshowsPrec :: Int -> PipelineName -> ShowS
Show, (forall x. PipelineName -> Rep PipelineName x)
-> (forall x. Rep PipelineName x -> PipelineName)
-> Generic PipelineName
forall x. Rep PipelineName x -> PipelineName
forall x. PipelineName -> Rep PipelineName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PipelineName x -> PipelineName
$cfrom :: forall x. PipelineName -> Rep PipelineName x
Generic)
  deriving newtype (Eq PipelineName
Eq PipelineName
-> (Int -> PipelineName -> Int)
-> (PipelineName -> Int)
-> Hashable PipelineName
Int -> PipelineName -> Int
PipelineName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: PipelineName -> Int
$chash :: PipelineName -> Int
hashWithSalt :: Int -> PipelineName -> Int
$chashWithSalt :: Int -> PipelineName -> Int
Hashable, Value -> Parser [PipelineName]
Value -> Parser PipelineName
(Value -> Parser PipelineName)
-> (Value -> Parser [PipelineName]) -> FromJSON PipelineName
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [PipelineName]
$cparseJSONList :: Value -> Parser [PipelineName]
parseJSON :: Value -> Parser PipelineName
$cparseJSON :: Value -> Parser PipelineName
FromJSON, FromJSONKeyFunction [PipelineName]
FromJSONKeyFunction PipelineName
FromJSONKeyFunction PipelineName
-> FromJSONKeyFunction [PipelineName] -> FromJSONKey PipelineName
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [PipelineName]
$cfromJSONKeyList :: FromJSONKeyFunction [PipelineName]
fromJSONKey :: FromJSONKeyFunction PipelineName
$cfromJSONKey :: FromJSONKeyFunction PipelineName
FromJSONKey, [PipelineName] -> Encoding
[PipelineName] -> Value
PipelineName -> Encoding
PipelineName -> Value
(PipelineName -> Value)
-> (PipelineName -> Encoding)
-> ([PipelineName] -> Value)
-> ([PipelineName] -> Encoding)
-> ToJSON PipelineName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [PipelineName] -> Encoding
$ctoEncodingList :: [PipelineName] -> Encoding
toJSONList :: [PipelineName] -> Value
$ctoJSONList :: [PipelineName] -> Value
toEncoding :: PipelineName -> Encoding
$ctoEncoding :: PipelineName -> Encoding
toJSON :: PipelineName -> Value
$ctoJSON :: PipelineName -> Value
ToJSON, ToJSONKeyFunction [PipelineName]
ToJSONKeyFunction PipelineName
ToJSONKeyFunction PipelineName
-> ToJSONKeyFunction [PipelineName] -> ToJSONKey PipelineName
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [PipelineName]
$ctoJSONKeyList :: ToJSONKeyFunction [PipelineName]
toJSONKey :: ToJSONKeyFunction PipelineName
$ctoJSONKey :: ToJSONKeyFunction PipelineName
ToJSONKey)

newtype ProjectName = ProjectName Text
  deriving (ProjectName -> ProjectName -> Bool
(ProjectName -> ProjectName -> Bool)
-> (ProjectName -> ProjectName -> Bool) -> Eq ProjectName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProjectName -> ProjectName -> Bool
$c/= :: ProjectName -> ProjectName -> Bool
== :: ProjectName -> ProjectName -> Bool
$c== :: ProjectName -> ProjectName -> Bool
Eq, Eq ProjectName
Eq ProjectName
-> (ProjectName -> ProjectName -> Ordering)
-> (ProjectName -> ProjectName -> Bool)
-> (ProjectName -> ProjectName -> Bool)
-> (ProjectName -> ProjectName -> Bool)
-> (ProjectName -> ProjectName -> Bool)
-> (ProjectName -> ProjectName -> ProjectName)
-> (ProjectName -> ProjectName -> ProjectName)
-> Ord ProjectName
ProjectName -> ProjectName -> Bool
ProjectName -> ProjectName -> Ordering
ProjectName -> ProjectName -> ProjectName
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 :: ProjectName -> ProjectName -> ProjectName
$cmin :: ProjectName -> ProjectName -> ProjectName
max :: ProjectName -> ProjectName -> ProjectName
$cmax :: ProjectName -> ProjectName -> ProjectName
>= :: ProjectName -> ProjectName -> Bool
$c>= :: ProjectName -> ProjectName -> Bool
> :: ProjectName -> ProjectName -> Bool
$c> :: ProjectName -> ProjectName -> Bool
<= :: ProjectName -> ProjectName -> Bool
$c<= :: ProjectName -> ProjectName -> Bool
< :: ProjectName -> ProjectName -> Bool
$c< :: ProjectName -> ProjectName -> Bool
compare :: ProjectName -> ProjectName -> Ordering
$ccompare :: ProjectName -> ProjectName -> Ordering
Ord, Int -> ProjectName -> ShowS
[ProjectName] -> ShowS
ProjectName -> String
(Int -> ProjectName -> ShowS)
-> (ProjectName -> String)
-> ([ProjectName] -> ShowS)
-> Show ProjectName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProjectName] -> ShowS
$cshowList :: [ProjectName] -> ShowS
show :: ProjectName -> String
$cshow :: ProjectName -> String
showsPrec :: Int -> ProjectName -> ShowS
$cshowsPrec :: Int -> ProjectName -> ShowS
Show, (forall x. ProjectName -> Rep ProjectName x)
-> (forall x. Rep ProjectName x -> ProjectName)
-> Generic ProjectName
forall x. Rep ProjectName x -> ProjectName
forall x. ProjectName -> Rep ProjectName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProjectName x -> ProjectName
$cfrom :: forall x. ProjectName -> Rep ProjectName x
Generic)
  deriving newtype (Eq ProjectName
Eq ProjectName
-> (Int -> ProjectName -> Int)
-> (ProjectName -> Int)
-> Hashable ProjectName
Int -> ProjectName -> Int
ProjectName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: ProjectName -> Int
$chash :: ProjectName -> Int
hashWithSalt :: Int -> ProjectName -> Int
$chashWithSalt :: Int -> ProjectName -> Int
Hashable, Value -> Parser [ProjectName]
Value -> Parser ProjectName
(Value -> Parser ProjectName)
-> (Value -> Parser [ProjectName]) -> FromJSON ProjectName
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [ProjectName]
$cparseJSONList :: Value -> Parser [ProjectName]
parseJSON :: Value -> Parser ProjectName
$cparseJSON :: Value -> Parser ProjectName
FromJSON, FromJSONKeyFunction [ProjectName]
FromJSONKeyFunction ProjectName
FromJSONKeyFunction ProjectName
-> FromJSONKeyFunction [ProjectName] -> FromJSONKey ProjectName
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [ProjectName]
$cfromJSONKeyList :: FromJSONKeyFunction [ProjectName]
fromJSONKey :: FromJSONKeyFunction ProjectName
$cfromJSONKey :: FromJSONKeyFunction ProjectName
FromJSONKey, [ProjectName] -> Encoding
[ProjectName] -> Value
ProjectName -> Encoding
ProjectName -> Value
(ProjectName -> Value)
-> (ProjectName -> Encoding)
-> ([ProjectName] -> Value)
-> ([ProjectName] -> Encoding)
-> ToJSON ProjectName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [ProjectName] -> Encoding
$ctoEncodingList :: [ProjectName] -> Encoding
toJSONList :: [ProjectName] -> Value
$ctoJSONList :: [ProjectName] -> Value
toEncoding :: ProjectName -> Encoding
$ctoEncoding :: ProjectName -> Encoding
toJSON :: ProjectName -> Value
$ctoJSON :: ProjectName -> Value
ToJSON, ToJSONKeyFunction [ProjectName]
ToJSONKeyFunction ProjectName
ToJSONKeyFunction ProjectName
-> ToJSONKeyFunction [ProjectName] -> ToJSONKey ProjectName
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [ProjectName]
$ctoJSONKeyList :: ToJSONKeyFunction [ProjectName]
toJSONKey :: ToJSONKeyFunction ProjectName
$ctoJSONKey :: ToJSONKeyFunction ProjectName
ToJSONKey)

instance From ProjectName Text where
  from :: ProjectName -> Text
from (ProjectName Text
n) = Text
n

newtype ProjectRegex = ProjectRegex Text
  deriving (ProjectRegex -> ProjectRegex -> Bool
(ProjectRegex -> ProjectRegex -> Bool)
-> (ProjectRegex -> ProjectRegex -> Bool) -> Eq ProjectRegex
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProjectRegex -> ProjectRegex -> Bool
$c/= :: ProjectRegex -> ProjectRegex -> Bool
== :: ProjectRegex -> ProjectRegex -> Bool
$c== :: ProjectRegex -> ProjectRegex -> Bool
Eq, Eq ProjectRegex
Eq ProjectRegex
-> (ProjectRegex -> ProjectRegex -> Ordering)
-> (ProjectRegex -> ProjectRegex -> Bool)
-> (ProjectRegex -> ProjectRegex -> Bool)
-> (ProjectRegex -> ProjectRegex -> Bool)
-> (ProjectRegex -> ProjectRegex -> Bool)
-> (ProjectRegex -> ProjectRegex -> ProjectRegex)
-> (ProjectRegex -> ProjectRegex -> ProjectRegex)
-> Ord ProjectRegex
ProjectRegex -> ProjectRegex -> Bool
ProjectRegex -> ProjectRegex -> Ordering
ProjectRegex -> ProjectRegex -> ProjectRegex
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 :: ProjectRegex -> ProjectRegex -> ProjectRegex
$cmin :: ProjectRegex -> ProjectRegex -> ProjectRegex
max :: ProjectRegex -> ProjectRegex -> ProjectRegex
$cmax :: ProjectRegex -> ProjectRegex -> ProjectRegex
>= :: ProjectRegex -> ProjectRegex -> Bool
$c>= :: ProjectRegex -> ProjectRegex -> Bool
> :: ProjectRegex -> ProjectRegex -> Bool
$c> :: ProjectRegex -> ProjectRegex -> Bool
<= :: ProjectRegex -> ProjectRegex -> Bool
$c<= :: ProjectRegex -> ProjectRegex -> Bool
< :: ProjectRegex -> ProjectRegex -> Bool
$c< :: ProjectRegex -> ProjectRegex -> Bool
compare :: ProjectRegex -> ProjectRegex -> Ordering
$ccompare :: ProjectRegex -> ProjectRegex -> Ordering
Ord, Int -> ProjectRegex -> ShowS
[ProjectRegex] -> ShowS
ProjectRegex -> String
(Int -> ProjectRegex -> ShowS)
-> (ProjectRegex -> String)
-> ([ProjectRegex] -> ShowS)
-> Show ProjectRegex
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProjectRegex] -> ShowS
$cshowList :: [ProjectRegex] -> ShowS
show :: ProjectRegex -> String
$cshow :: ProjectRegex -> String
showsPrec :: Int -> ProjectRegex -> ShowS
$cshowsPrec :: Int -> ProjectRegex -> ShowS
Show, (forall x. ProjectRegex -> Rep ProjectRegex x)
-> (forall x. Rep ProjectRegex x -> ProjectRegex)
-> Generic ProjectRegex
forall x. Rep ProjectRegex x -> ProjectRegex
forall x. ProjectRegex -> Rep ProjectRegex x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProjectRegex x -> ProjectRegex
$cfrom :: forall x. ProjectRegex -> Rep ProjectRegex x
Generic)
  deriving newtype (Eq ProjectRegex
Eq ProjectRegex
-> (Int -> ProjectRegex -> Int)
-> (ProjectRegex -> Int)
-> Hashable ProjectRegex
Int -> ProjectRegex -> Int
ProjectRegex -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: ProjectRegex -> Int
$chash :: ProjectRegex -> Int
hashWithSalt :: Int -> ProjectRegex -> Int
$chashWithSalt :: Int -> ProjectRegex -> Int
Hashable, Value -> Parser [ProjectRegex]
Value -> Parser ProjectRegex
(Value -> Parser ProjectRegex)
-> (Value -> Parser [ProjectRegex]) -> FromJSON ProjectRegex
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [ProjectRegex]
$cparseJSONList :: Value -> Parser [ProjectRegex]
parseJSON :: Value -> Parser ProjectRegex
$cparseJSON :: Value -> Parser ProjectRegex
FromJSON, FromJSONKeyFunction [ProjectRegex]
FromJSONKeyFunction ProjectRegex
FromJSONKeyFunction ProjectRegex
-> FromJSONKeyFunction [ProjectRegex] -> FromJSONKey ProjectRegex
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [ProjectRegex]
$cfromJSONKeyList :: FromJSONKeyFunction [ProjectRegex]
fromJSONKey :: FromJSONKeyFunction ProjectRegex
$cfromJSONKey :: FromJSONKeyFunction ProjectRegex
FromJSONKey, [ProjectRegex] -> Encoding
[ProjectRegex] -> Value
ProjectRegex -> Encoding
ProjectRegex -> Value
(ProjectRegex -> Value)
-> (ProjectRegex -> Encoding)
-> ([ProjectRegex] -> Value)
-> ([ProjectRegex] -> Encoding)
-> ToJSON ProjectRegex
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [ProjectRegex] -> Encoding
$ctoEncodingList :: [ProjectRegex] -> Encoding
toJSONList :: [ProjectRegex] -> Value
$ctoJSONList :: [ProjectRegex] -> Value
toEncoding :: ProjectRegex -> Encoding
$ctoEncoding :: ProjectRegex -> Encoding
toJSON :: ProjectRegex -> Value
$ctoJSON :: ProjectRegex -> Value
ToJSON, ToJSONKeyFunction [ProjectRegex]
ToJSONKeyFunction ProjectRegex
ToJSONKeyFunction ProjectRegex
-> ToJSONKeyFunction [ProjectRegex] -> ToJSONKey ProjectRegex
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [ProjectRegex]
$ctoJSONKeyList :: ToJSONKeyFunction [ProjectRegex]
toJSONKey :: ToJSONKeyFunction ProjectRegex
$ctoJSONKey :: ToJSONKeyFunction ProjectRegex
ToJSONKey)

instance From ProjectName ProjectRegex where
  from :: ProjectName -> ProjectRegex
from (ProjectName Text
n) = Text -> ProjectRegex
ProjectRegex Text
n

newtype NodesetName = NodesetName Text
  deriving (NodesetName -> NodesetName -> Bool
(NodesetName -> NodesetName -> Bool)
-> (NodesetName -> NodesetName -> Bool) -> Eq NodesetName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NodesetName -> NodesetName -> Bool
$c/= :: NodesetName -> NodesetName -> Bool
== :: NodesetName -> NodesetName -> Bool
$c== :: NodesetName -> NodesetName -> Bool
Eq, Eq NodesetName
Eq NodesetName
-> (NodesetName -> NodesetName -> Ordering)
-> (NodesetName -> NodesetName -> Bool)
-> (NodesetName -> NodesetName -> Bool)
-> (NodesetName -> NodesetName -> Bool)
-> (NodesetName -> NodesetName -> Bool)
-> (NodesetName -> NodesetName -> NodesetName)
-> (NodesetName -> NodesetName -> NodesetName)
-> Ord NodesetName
NodesetName -> NodesetName -> Bool
NodesetName -> NodesetName -> Ordering
NodesetName -> NodesetName -> NodesetName
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 :: NodesetName -> NodesetName -> NodesetName
$cmin :: NodesetName -> NodesetName -> NodesetName
max :: NodesetName -> NodesetName -> NodesetName
$cmax :: NodesetName -> NodesetName -> NodesetName
>= :: NodesetName -> NodesetName -> Bool
$c>= :: NodesetName -> NodesetName -> Bool
> :: NodesetName -> NodesetName -> Bool
$c> :: NodesetName -> NodesetName -> Bool
<= :: NodesetName -> NodesetName -> Bool
$c<= :: NodesetName -> NodesetName -> Bool
< :: NodesetName -> NodesetName -> Bool
$c< :: NodesetName -> NodesetName -> Bool
compare :: NodesetName -> NodesetName -> Ordering
$ccompare :: NodesetName -> NodesetName -> Ordering
Ord, Int -> NodesetName -> ShowS
[NodesetName] -> ShowS
NodesetName -> String
(Int -> NodesetName -> ShowS)
-> (NodesetName -> String)
-> ([NodesetName] -> ShowS)
-> Show NodesetName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NodesetName] -> ShowS
$cshowList :: [NodesetName] -> ShowS
show :: NodesetName -> String
$cshow :: NodesetName -> String
showsPrec :: Int -> NodesetName -> ShowS
$cshowsPrec :: Int -> NodesetName -> ShowS
Show, (forall x. NodesetName -> Rep NodesetName x)
-> (forall x. Rep NodesetName x -> NodesetName)
-> Generic NodesetName
forall x. Rep NodesetName x -> NodesetName
forall x. NodesetName -> Rep NodesetName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NodesetName x -> NodesetName
$cfrom :: forall x. NodesetName -> Rep NodesetName x
Generic)
  deriving newtype (Eq NodesetName
Eq NodesetName
-> (Int -> NodesetName -> Int)
-> (NodesetName -> Int)
-> Hashable NodesetName
Int -> NodesetName -> Int
NodesetName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: NodesetName -> Int
$chash :: NodesetName -> Int
hashWithSalt :: Int -> NodesetName -> Int
$chashWithSalt :: Int -> NodesetName -> Int
Hashable, Value -> Parser [NodesetName]
Value -> Parser NodesetName
(Value -> Parser NodesetName)
-> (Value -> Parser [NodesetName]) -> FromJSON NodesetName
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [NodesetName]
$cparseJSONList :: Value -> Parser [NodesetName]
parseJSON :: Value -> Parser NodesetName
$cparseJSON :: Value -> Parser NodesetName
FromJSON, FromJSONKeyFunction [NodesetName]
FromJSONKeyFunction NodesetName
FromJSONKeyFunction NodesetName
-> FromJSONKeyFunction [NodesetName] -> FromJSONKey NodesetName
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [NodesetName]
$cfromJSONKeyList :: FromJSONKeyFunction [NodesetName]
fromJSONKey :: FromJSONKeyFunction NodesetName
$cfromJSONKey :: FromJSONKeyFunction NodesetName
FromJSONKey, [NodesetName] -> Encoding
[NodesetName] -> Value
NodesetName -> Encoding
NodesetName -> Value
(NodesetName -> Value)
-> (NodesetName -> Encoding)
-> ([NodesetName] -> Value)
-> ([NodesetName] -> Encoding)
-> ToJSON NodesetName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [NodesetName] -> Encoding
$ctoEncodingList :: [NodesetName] -> Encoding
toJSONList :: [NodesetName] -> Value
$ctoJSONList :: [NodesetName] -> Value
toEncoding :: NodesetName -> Encoding
$ctoEncoding :: NodesetName -> Encoding
toJSON :: NodesetName -> Value
$ctoJSON :: NodesetName -> Value
ToJSON, ToJSONKeyFunction [NodesetName]
ToJSONKeyFunction NodesetName
ToJSONKeyFunction NodesetName
-> ToJSONKeyFunction [NodesetName] -> ToJSONKey NodesetName
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [NodesetName]
$ctoJSONKeyList :: ToJSONKeyFunction [NodesetName]
toJSONKey :: ToJSONKeyFunction NodesetName
$ctoJSONKey :: ToJSONKeyFunction NodesetName
ToJSONKey)

newtype NodeLabelName = NodeLabelName Text
  deriving (NodeLabelName -> NodeLabelName -> Bool
(NodeLabelName -> NodeLabelName -> Bool)
-> (NodeLabelName -> NodeLabelName -> Bool) -> Eq NodeLabelName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NodeLabelName -> NodeLabelName -> Bool
$c/= :: NodeLabelName -> NodeLabelName -> Bool
== :: NodeLabelName -> NodeLabelName -> Bool
$c== :: NodeLabelName -> NodeLabelName -> Bool
Eq, Eq NodeLabelName
Eq NodeLabelName
-> (NodeLabelName -> NodeLabelName -> Ordering)
-> (NodeLabelName -> NodeLabelName -> Bool)
-> (NodeLabelName -> NodeLabelName -> Bool)
-> (NodeLabelName -> NodeLabelName -> Bool)
-> (NodeLabelName -> NodeLabelName -> Bool)
-> (NodeLabelName -> NodeLabelName -> NodeLabelName)
-> (NodeLabelName -> NodeLabelName -> NodeLabelName)
-> Ord NodeLabelName
NodeLabelName -> NodeLabelName -> Bool
NodeLabelName -> NodeLabelName -> Ordering
NodeLabelName -> NodeLabelName -> NodeLabelName
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 :: NodeLabelName -> NodeLabelName -> NodeLabelName
$cmin :: NodeLabelName -> NodeLabelName -> NodeLabelName
max :: NodeLabelName -> NodeLabelName -> NodeLabelName
$cmax :: NodeLabelName -> NodeLabelName -> NodeLabelName
>= :: NodeLabelName -> NodeLabelName -> Bool
$c>= :: NodeLabelName -> NodeLabelName -> Bool
> :: NodeLabelName -> NodeLabelName -> Bool
$c> :: NodeLabelName -> NodeLabelName -> Bool
<= :: NodeLabelName -> NodeLabelName -> Bool
$c<= :: NodeLabelName -> NodeLabelName -> Bool
< :: NodeLabelName -> NodeLabelName -> Bool
$c< :: NodeLabelName -> NodeLabelName -> Bool
compare :: NodeLabelName -> NodeLabelName -> Ordering
$ccompare :: NodeLabelName -> NodeLabelName -> Ordering
Ord, Int -> NodeLabelName -> ShowS
[NodeLabelName] -> ShowS
NodeLabelName -> String
(Int -> NodeLabelName -> ShowS)
-> (NodeLabelName -> String)
-> ([NodeLabelName] -> ShowS)
-> Show NodeLabelName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NodeLabelName] -> ShowS
$cshowList :: [NodeLabelName] -> ShowS
show :: NodeLabelName -> String
$cshow :: NodeLabelName -> String
showsPrec :: Int -> NodeLabelName -> ShowS
$cshowsPrec :: Int -> NodeLabelName -> ShowS
Show, (forall x. NodeLabelName -> Rep NodeLabelName x)
-> (forall x. Rep NodeLabelName x -> NodeLabelName)
-> Generic NodeLabelName
forall x. Rep NodeLabelName x -> NodeLabelName
forall x. NodeLabelName -> Rep NodeLabelName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NodeLabelName x -> NodeLabelName
$cfrom :: forall x. NodeLabelName -> Rep NodeLabelName x
Generic)
  deriving newtype (Eq NodeLabelName
Eq NodeLabelName
-> (Int -> NodeLabelName -> Int)
-> (NodeLabelName -> Int)
-> Hashable NodeLabelName
Int -> NodeLabelName -> Int
NodeLabelName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: NodeLabelName -> Int
$chash :: NodeLabelName -> Int
hashWithSalt :: Int -> NodeLabelName -> Int
$chashWithSalt :: Int -> NodeLabelName -> Int
Hashable, Value -> Parser [NodeLabelName]
Value -> Parser NodeLabelName
(Value -> Parser NodeLabelName)
-> (Value -> Parser [NodeLabelName]) -> FromJSON NodeLabelName
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [NodeLabelName]
$cparseJSONList :: Value -> Parser [NodeLabelName]
parseJSON :: Value -> Parser NodeLabelName
$cparseJSON :: Value -> Parser NodeLabelName
FromJSON, FromJSONKeyFunction [NodeLabelName]
FromJSONKeyFunction NodeLabelName
FromJSONKeyFunction NodeLabelName
-> FromJSONKeyFunction [NodeLabelName] -> FromJSONKey NodeLabelName
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [NodeLabelName]
$cfromJSONKeyList :: FromJSONKeyFunction [NodeLabelName]
fromJSONKey :: FromJSONKeyFunction NodeLabelName
$cfromJSONKey :: FromJSONKeyFunction NodeLabelName
FromJSONKey, [NodeLabelName] -> Encoding
[NodeLabelName] -> Value
NodeLabelName -> Encoding
NodeLabelName -> Value
(NodeLabelName -> Value)
-> (NodeLabelName -> Encoding)
-> ([NodeLabelName] -> Value)
-> ([NodeLabelName] -> Encoding)
-> ToJSON NodeLabelName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [NodeLabelName] -> Encoding
$ctoEncodingList :: [NodeLabelName] -> Encoding
toJSONList :: [NodeLabelName] -> Value
$ctoJSONList :: [NodeLabelName] -> Value
toEncoding :: NodeLabelName -> Encoding
$ctoEncoding :: NodeLabelName -> Encoding
toJSON :: NodeLabelName -> Value
$ctoJSON :: NodeLabelName -> Value
ToJSON, ToJSONKeyFunction [NodeLabelName]
ToJSONKeyFunction NodeLabelName
ToJSONKeyFunction NodeLabelName
-> ToJSONKeyFunction [NodeLabelName] -> ToJSONKey NodeLabelName
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [NodeLabelName]
$ctoJSONKeyList :: ToJSONKeyFunction [NodeLabelName]
toJSONKey :: ToJSONKeyFunction NodeLabelName
$ctoJSONKey :: ToJSONKeyFunction NodeLabelName
ToJSONKey)

newtype ProviderName = ProviderName Text
  deriving (ProviderName -> ProviderName -> Bool
(ProviderName -> ProviderName -> Bool)
-> (ProviderName -> ProviderName -> Bool) -> Eq ProviderName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProviderName -> ProviderName -> Bool
$c/= :: ProviderName -> ProviderName -> Bool
== :: ProviderName -> ProviderName -> Bool
$c== :: ProviderName -> ProviderName -> Bool
Eq, Eq ProviderName
Eq ProviderName
-> (ProviderName -> ProviderName -> Ordering)
-> (ProviderName -> ProviderName -> Bool)
-> (ProviderName -> ProviderName -> Bool)
-> (ProviderName -> ProviderName -> Bool)
-> (ProviderName -> ProviderName -> Bool)
-> (ProviderName -> ProviderName -> ProviderName)
-> (ProviderName -> ProviderName -> ProviderName)
-> Ord ProviderName
ProviderName -> ProviderName -> Bool
ProviderName -> ProviderName -> Ordering
ProviderName -> ProviderName -> ProviderName
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 :: ProviderName -> ProviderName -> ProviderName
$cmin :: ProviderName -> ProviderName -> ProviderName
max :: ProviderName -> ProviderName -> ProviderName
$cmax :: ProviderName -> ProviderName -> ProviderName
>= :: ProviderName -> ProviderName -> Bool
$c>= :: ProviderName -> ProviderName -> Bool
> :: ProviderName -> ProviderName -> Bool
$c> :: ProviderName -> ProviderName -> Bool
<= :: ProviderName -> ProviderName -> Bool
$c<= :: ProviderName -> ProviderName -> Bool
< :: ProviderName -> ProviderName -> Bool
$c< :: ProviderName -> ProviderName -> Bool
compare :: ProviderName -> ProviderName -> Ordering
$ccompare :: ProviderName -> ProviderName -> Ordering
Ord, Int -> ProviderName -> ShowS
[ProviderName] -> ShowS
ProviderName -> String
(Int -> ProviderName -> ShowS)
-> (ProviderName -> String)
-> ([ProviderName] -> ShowS)
-> Show ProviderName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProviderName] -> ShowS
$cshowList :: [ProviderName] -> ShowS
show :: ProviderName -> String
$cshow :: ProviderName -> String
showsPrec :: Int -> ProviderName -> ShowS
$cshowsPrec :: Int -> ProviderName -> ShowS
Show, (forall x. ProviderName -> Rep ProviderName x)
-> (forall x. Rep ProviderName x -> ProviderName)
-> Generic ProviderName
forall x. Rep ProviderName x -> ProviderName
forall x. ProviderName -> Rep ProviderName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProviderName x -> ProviderName
$cfrom :: forall x. ProviderName -> Rep ProviderName x
Generic)
  deriving newtype (Eq ProviderName
Eq ProviderName
-> (Int -> ProviderName -> Int)
-> (ProviderName -> Int)
-> Hashable ProviderName
Int -> ProviderName -> Int
ProviderName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: ProviderName -> Int
$chash :: ProviderName -> Int
hashWithSalt :: Int -> ProviderName -> Int
$chashWithSalt :: Int -> ProviderName -> Int
Hashable, Value -> Parser [ProviderName]
Value -> Parser ProviderName
(Value -> Parser ProviderName)
-> (Value -> Parser [ProviderName]) -> FromJSON ProviderName
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [ProviderName]
$cparseJSONList :: Value -> Parser [ProviderName]
parseJSON :: Value -> Parser ProviderName
$cparseJSON :: Value -> Parser ProviderName
FromJSON, FromJSONKeyFunction [ProviderName]
FromJSONKeyFunction ProviderName
FromJSONKeyFunction ProviderName
-> FromJSONKeyFunction [ProviderName] -> FromJSONKey ProviderName
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [ProviderName]
$cfromJSONKeyList :: FromJSONKeyFunction [ProviderName]
fromJSONKey :: FromJSONKeyFunction ProviderName
$cfromJSONKey :: FromJSONKeyFunction ProviderName
FromJSONKey, [ProviderName] -> Encoding
[ProviderName] -> Value
ProviderName -> Encoding
ProviderName -> Value
(ProviderName -> Value)
-> (ProviderName -> Encoding)
-> ([ProviderName] -> Value)
-> ([ProviderName] -> Encoding)
-> ToJSON ProviderName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [ProviderName] -> Encoding
$ctoEncodingList :: [ProviderName] -> Encoding
toJSONList :: [ProviderName] -> Value
$ctoJSONList :: [ProviderName] -> Value
toEncoding :: ProviderName -> Encoding
$ctoEncoding :: ProviderName -> Encoding
toJSON :: ProviderName -> Value
$ctoJSON :: ProviderName -> Value
ToJSON, ToJSONKeyFunction [ProviderName]
ToJSONKeyFunction ProviderName
ToJSONKeyFunction ProviderName
-> ToJSONKeyFunction [ProviderName] -> ToJSONKey ProviderName
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [ProviderName]
$ctoJSONKeyList :: ToJSONKeyFunction [ProviderName]
toJSONKey :: ToJSONKeyFunction ProviderName
$ctoJSONKey :: ToJSONKeyFunction ProviderName
ToJSONKey)

newtype ProjectTemplateName = ProjectTemplateName Text
  deriving (ProjectTemplateName -> ProjectTemplateName -> Bool
(ProjectTemplateName -> ProjectTemplateName -> Bool)
-> (ProjectTemplateName -> ProjectTemplateName -> Bool)
-> Eq ProjectTemplateName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProjectTemplateName -> ProjectTemplateName -> Bool
$c/= :: ProjectTemplateName -> ProjectTemplateName -> Bool
== :: ProjectTemplateName -> ProjectTemplateName -> Bool
$c== :: ProjectTemplateName -> ProjectTemplateName -> Bool
Eq, Eq ProjectTemplateName
Eq ProjectTemplateName
-> (ProjectTemplateName -> ProjectTemplateName -> Ordering)
-> (ProjectTemplateName -> ProjectTemplateName -> Bool)
-> (ProjectTemplateName -> ProjectTemplateName -> Bool)
-> (ProjectTemplateName -> ProjectTemplateName -> Bool)
-> (ProjectTemplateName -> ProjectTemplateName -> Bool)
-> (ProjectTemplateName
    -> ProjectTemplateName -> ProjectTemplateName)
-> (ProjectTemplateName
    -> ProjectTemplateName -> ProjectTemplateName)
-> Ord ProjectTemplateName
ProjectTemplateName -> ProjectTemplateName -> Bool
ProjectTemplateName -> ProjectTemplateName -> Ordering
ProjectTemplateName -> ProjectTemplateName -> ProjectTemplateName
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 :: ProjectTemplateName -> ProjectTemplateName -> ProjectTemplateName
$cmin :: ProjectTemplateName -> ProjectTemplateName -> ProjectTemplateName
max :: ProjectTemplateName -> ProjectTemplateName -> ProjectTemplateName
$cmax :: ProjectTemplateName -> ProjectTemplateName -> ProjectTemplateName
>= :: ProjectTemplateName -> ProjectTemplateName -> Bool
$c>= :: ProjectTemplateName -> ProjectTemplateName -> Bool
> :: ProjectTemplateName -> ProjectTemplateName -> Bool
$c> :: ProjectTemplateName -> ProjectTemplateName -> Bool
<= :: ProjectTemplateName -> ProjectTemplateName -> Bool
$c<= :: ProjectTemplateName -> ProjectTemplateName -> Bool
< :: ProjectTemplateName -> ProjectTemplateName -> Bool
$c< :: ProjectTemplateName -> ProjectTemplateName -> Bool
compare :: ProjectTemplateName -> ProjectTemplateName -> Ordering
$ccompare :: ProjectTemplateName -> ProjectTemplateName -> Ordering
Ord, Int -> ProjectTemplateName -> ShowS
[ProjectTemplateName] -> ShowS
ProjectTemplateName -> String
(Int -> ProjectTemplateName -> ShowS)
-> (ProjectTemplateName -> String)
-> ([ProjectTemplateName] -> ShowS)
-> Show ProjectTemplateName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProjectTemplateName] -> ShowS
$cshowList :: [ProjectTemplateName] -> ShowS
show :: ProjectTemplateName -> String
$cshow :: ProjectTemplateName -> String
showsPrec :: Int -> ProjectTemplateName -> ShowS
$cshowsPrec :: Int -> ProjectTemplateName -> ShowS
Show, (forall x. ProjectTemplateName -> Rep ProjectTemplateName x)
-> (forall x. Rep ProjectTemplateName x -> ProjectTemplateName)
-> Generic ProjectTemplateName
forall x. Rep ProjectTemplateName x -> ProjectTemplateName
forall x. ProjectTemplateName -> Rep ProjectTemplateName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProjectTemplateName x -> ProjectTemplateName
$cfrom :: forall x. ProjectTemplateName -> Rep ProjectTemplateName x
Generic)
  deriving newtype (Eq ProjectTemplateName
Eq ProjectTemplateName
-> (Int -> ProjectTemplateName -> Int)
-> (ProjectTemplateName -> Int)
-> Hashable ProjectTemplateName
Int -> ProjectTemplateName -> Int
ProjectTemplateName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: ProjectTemplateName -> Int
$chash :: ProjectTemplateName -> Int
hashWithSalt :: Int -> ProjectTemplateName -> Int
$chashWithSalt :: Int -> ProjectTemplateName -> Int
Hashable, Value -> Parser [ProjectTemplateName]
Value -> Parser ProjectTemplateName
(Value -> Parser ProjectTemplateName)
-> (Value -> Parser [ProjectTemplateName])
-> FromJSON ProjectTemplateName
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [ProjectTemplateName]
$cparseJSONList :: Value -> Parser [ProjectTemplateName]
parseJSON :: Value -> Parser ProjectTemplateName
$cparseJSON :: Value -> Parser ProjectTemplateName
FromJSON, FromJSONKeyFunction [ProjectTemplateName]
FromJSONKeyFunction ProjectTemplateName
FromJSONKeyFunction ProjectTemplateName
-> FromJSONKeyFunction [ProjectTemplateName]
-> FromJSONKey ProjectTemplateName
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [ProjectTemplateName]
$cfromJSONKeyList :: FromJSONKeyFunction [ProjectTemplateName]
fromJSONKey :: FromJSONKeyFunction ProjectTemplateName
$cfromJSONKey :: FromJSONKeyFunction ProjectTemplateName
FromJSONKey, [ProjectTemplateName] -> Encoding
[ProjectTemplateName] -> Value
ProjectTemplateName -> Encoding
ProjectTemplateName -> Value
(ProjectTemplateName -> Value)
-> (ProjectTemplateName -> Encoding)
-> ([ProjectTemplateName] -> Value)
-> ([ProjectTemplateName] -> Encoding)
-> ToJSON ProjectTemplateName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [ProjectTemplateName] -> Encoding
$ctoEncodingList :: [ProjectTemplateName] -> Encoding
toJSONList :: [ProjectTemplateName] -> Value
$ctoJSONList :: [ProjectTemplateName] -> Value
toEncoding :: ProjectTemplateName -> Encoding
$ctoEncoding :: ProjectTemplateName -> Encoding
toJSON :: ProjectTemplateName -> Value
$ctoJSON :: ProjectTemplateName -> Value
ToJSON, ToJSONKeyFunction [ProjectTemplateName]
ToJSONKeyFunction ProjectTemplateName
ToJSONKeyFunction ProjectTemplateName
-> ToJSONKeyFunction [ProjectTemplateName]
-> ToJSONKey ProjectTemplateName
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [ProjectTemplateName]
$ctoJSONKeyList :: ToJSONKeyFunction [ProjectTemplateName]
toJSONKey :: ToJSONKeyFunction ProjectTemplateName
$ctoJSONKey :: ToJSONKeyFunction ProjectTemplateName
ToJSONKey)

newtype SecretName = SecretName Text
  deriving (SecretName -> SecretName -> Bool
(SecretName -> SecretName -> Bool)
-> (SecretName -> SecretName -> Bool) -> Eq SecretName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SecretName -> SecretName -> Bool
$c/= :: SecretName -> SecretName -> Bool
== :: SecretName -> SecretName -> Bool
$c== :: SecretName -> SecretName -> Bool
Eq, Eq SecretName
Eq SecretName
-> (SecretName -> SecretName -> Ordering)
-> (SecretName -> SecretName -> Bool)
-> (SecretName -> SecretName -> Bool)
-> (SecretName -> SecretName -> Bool)
-> (SecretName -> SecretName -> Bool)
-> (SecretName -> SecretName -> SecretName)
-> (SecretName -> SecretName -> SecretName)
-> Ord SecretName
SecretName -> SecretName -> Bool
SecretName -> SecretName -> Ordering
SecretName -> SecretName -> SecretName
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 :: SecretName -> SecretName -> SecretName
$cmin :: SecretName -> SecretName -> SecretName
max :: SecretName -> SecretName -> SecretName
$cmax :: SecretName -> SecretName -> SecretName
>= :: SecretName -> SecretName -> Bool
$c>= :: SecretName -> SecretName -> Bool
> :: SecretName -> SecretName -> Bool
$c> :: SecretName -> SecretName -> Bool
<= :: SecretName -> SecretName -> Bool
$c<= :: SecretName -> SecretName -> Bool
< :: SecretName -> SecretName -> Bool
$c< :: SecretName -> SecretName -> Bool
compare :: SecretName -> SecretName -> Ordering
$ccompare :: SecretName -> SecretName -> Ordering
Ord, Int -> SecretName -> ShowS
[SecretName] -> ShowS
SecretName -> String
(Int -> SecretName -> ShowS)
-> (SecretName -> String)
-> ([SecretName] -> ShowS)
-> Show SecretName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SecretName] -> ShowS
$cshowList :: [SecretName] -> ShowS
show :: SecretName -> String
$cshow :: SecretName -> String
showsPrec :: Int -> SecretName -> ShowS
$cshowsPrec :: Int -> SecretName -> ShowS
Show, (forall x. SecretName -> Rep SecretName x)
-> (forall x. Rep SecretName x -> SecretName) -> Generic SecretName
forall x. Rep SecretName x -> SecretName
forall x. SecretName -> Rep SecretName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SecretName x -> SecretName
$cfrom :: forall x. SecretName -> Rep SecretName x
Generic)
  deriving newtype (Eq SecretName
Eq SecretName
-> (Int -> SecretName -> Int)
-> (SecretName -> Int)
-> Hashable SecretName
Int -> SecretName -> Int
SecretName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: SecretName -> Int
$chash :: SecretName -> Int
hashWithSalt :: Int -> SecretName -> Int
$chashWithSalt :: Int -> SecretName -> Int
Hashable, Value -> Parser [SecretName]
Value -> Parser SecretName
(Value -> Parser SecretName)
-> (Value -> Parser [SecretName]) -> FromJSON SecretName
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [SecretName]
$cparseJSONList :: Value -> Parser [SecretName]
parseJSON :: Value -> Parser SecretName
$cparseJSON :: Value -> Parser SecretName
FromJSON, FromJSONKeyFunction [SecretName]
FromJSONKeyFunction SecretName
FromJSONKeyFunction SecretName
-> FromJSONKeyFunction [SecretName] -> FromJSONKey SecretName
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [SecretName]
$cfromJSONKeyList :: FromJSONKeyFunction [SecretName]
fromJSONKey :: FromJSONKeyFunction SecretName
$cfromJSONKey :: FromJSONKeyFunction SecretName
FromJSONKey, [SecretName] -> Encoding
[SecretName] -> Value
SecretName -> Encoding
SecretName -> Value
(SecretName -> Value)
-> (SecretName -> Encoding)
-> ([SecretName] -> Value)
-> ([SecretName] -> Encoding)
-> ToJSON SecretName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [SecretName] -> Encoding
$ctoEncodingList :: [SecretName] -> Encoding
toJSONList :: [SecretName] -> Value
$ctoJSONList :: [SecretName] -> Value
toEncoding :: SecretName -> Encoding
$ctoEncoding :: SecretName -> Encoding
toJSON :: SecretName -> Value
$ctoJSON :: SecretName -> Value
ToJSON, ToJSONKeyFunction [SecretName]
ToJSONKeyFunction SecretName
ToJSONKeyFunction SecretName
-> ToJSONKeyFunction [SecretName] -> ToJSONKey SecretName
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [SecretName]
$ctoJSONKeyList :: ToJSONKeyFunction [SecretName]
toJSONKey :: ToJSONKeyFunction SecretName
$ctoJSONKey :: ToJSONKeyFunction SecretName
ToJSONKey)

newtype QueueName = QueueName Text
  deriving (QueueName -> QueueName -> Bool
(QueueName -> QueueName -> Bool)
-> (QueueName -> QueueName -> Bool) -> Eq QueueName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: QueueName -> QueueName -> Bool
$c/= :: QueueName -> QueueName -> Bool
== :: QueueName -> QueueName -> Bool
$c== :: QueueName -> QueueName -> Bool
Eq, Eq QueueName
Eq QueueName
-> (QueueName -> QueueName -> Ordering)
-> (QueueName -> QueueName -> Bool)
-> (QueueName -> QueueName -> Bool)
-> (QueueName -> QueueName -> Bool)
-> (QueueName -> QueueName -> Bool)
-> (QueueName -> QueueName -> QueueName)
-> (QueueName -> QueueName -> QueueName)
-> Ord QueueName
QueueName -> QueueName -> Bool
QueueName -> QueueName -> Ordering
QueueName -> QueueName -> QueueName
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 :: QueueName -> QueueName -> QueueName
$cmin :: QueueName -> QueueName -> QueueName
max :: QueueName -> QueueName -> QueueName
$cmax :: QueueName -> QueueName -> QueueName
>= :: QueueName -> QueueName -> Bool
$c>= :: QueueName -> QueueName -> Bool
> :: QueueName -> QueueName -> Bool
$c> :: QueueName -> QueueName -> Bool
<= :: QueueName -> QueueName -> Bool
$c<= :: QueueName -> QueueName -> Bool
< :: QueueName -> QueueName -> Bool
$c< :: QueueName -> QueueName -> Bool
compare :: QueueName -> QueueName -> Ordering
$ccompare :: QueueName -> QueueName -> Ordering
Ord, Int -> QueueName -> ShowS
[QueueName] -> ShowS
QueueName -> String
(Int -> QueueName -> ShowS)
-> (QueueName -> String)
-> ([QueueName] -> ShowS)
-> Show QueueName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [QueueName] -> ShowS
$cshowList :: [QueueName] -> ShowS
show :: QueueName -> String
$cshow :: QueueName -> String
showsPrec :: Int -> QueueName -> ShowS
$cshowsPrec :: Int -> QueueName -> ShowS
Show, (forall x. QueueName -> Rep QueueName x)
-> (forall x. Rep QueueName x -> QueueName) -> Generic QueueName
forall x. Rep QueueName x -> QueueName
forall x. QueueName -> Rep QueueName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep QueueName x -> QueueName
$cfrom :: forall x. QueueName -> Rep QueueName x
Generic)
  deriving newtype (Eq QueueName
Eq QueueName
-> (Int -> QueueName -> Int)
-> (QueueName -> Int)
-> Hashable QueueName
Int -> QueueName -> Int
QueueName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: QueueName -> Int
$chash :: QueueName -> Int
hashWithSalt :: Int -> QueueName -> Int
$chashWithSalt :: Int -> QueueName -> Int
Hashable, Value -> Parser [QueueName]
Value -> Parser QueueName
(Value -> Parser QueueName)
-> (Value -> Parser [QueueName]) -> FromJSON QueueName
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [QueueName]
$cparseJSONList :: Value -> Parser [QueueName]
parseJSON :: Value -> Parser QueueName
$cparseJSON :: Value -> Parser QueueName
FromJSON, FromJSONKeyFunction [QueueName]
FromJSONKeyFunction QueueName
FromJSONKeyFunction QueueName
-> FromJSONKeyFunction [QueueName] -> FromJSONKey QueueName
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [QueueName]
$cfromJSONKeyList :: FromJSONKeyFunction [QueueName]
fromJSONKey :: FromJSONKeyFunction QueueName
$cfromJSONKey :: FromJSONKeyFunction QueueName
FromJSONKey, [QueueName] -> Encoding
[QueueName] -> Value
QueueName -> Encoding
QueueName -> Value
(QueueName -> Value)
-> (QueueName -> Encoding)
-> ([QueueName] -> Value)
-> ([QueueName] -> Encoding)
-> ToJSON QueueName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [QueueName] -> Encoding
$ctoEncodingList :: [QueueName] -> Encoding
toJSONList :: [QueueName] -> Value
$ctoJSONList :: [QueueName] -> Value
toEncoding :: QueueName -> Encoding
$ctoEncoding :: QueueName -> Encoding
toJSON :: QueueName -> Value
$ctoJSON :: QueueName -> Value
ToJSON, ToJSONKeyFunction [QueueName]
ToJSONKeyFunction QueueName
ToJSONKeyFunction QueueName
-> ToJSONKeyFunction [QueueName] -> ToJSONKey QueueName
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [QueueName]
$ctoJSONKeyList :: ToJSONKeyFunction [QueueName]
toJSONKey :: ToJSONKeyFunction QueueName
$ctoJSONKey :: ToJSONKeyFunction QueueName
ToJSONKey)

newtype SemaphoreName = SemaphoreName Text
  deriving (SemaphoreName -> SemaphoreName -> Bool
(SemaphoreName -> SemaphoreName -> Bool)
-> (SemaphoreName -> SemaphoreName -> Bool) -> Eq SemaphoreName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SemaphoreName -> SemaphoreName -> Bool
$c/= :: SemaphoreName -> SemaphoreName -> Bool
== :: SemaphoreName -> SemaphoreName -> Bool
$c== :: SemaphoreName -> SemaphoreName -> Bool
Eq, Eq SemaphoreName
Eq SemaphoreName
-> (SemaphoreName -> SemaphoreName -> Ordering)
-> (SemaphoreName -> SemaphoreName -> Bool)
-> (SemaphoreName -> SemaphoreName -> Bool)
-> (SemaphoreName -> SemaphoreName -> Bool)
-> (SemaphoreName -> SemaphoreName -> Bool)
-> (SemaphoreName -> SemaphoreName -> SemaphoreName)
-> (SemaphoreName -> SemaphoreName -> SemaphoreName)
-> Ord SemaphoreName
SemaphoreName -> SemaphoreName -> Bool
SemaphoreName -> SemaphoreName -> Ordering
SemaphoreName -> SemaphoreName -> SemaphoreName
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 :: SemaphoreName -> SemaphoreName -> SemaphoreName
$cmin :: SemaphoreName -> SemaphoreName -> SemaphoreName
max :: SemaphoreName -> SemaphoreName -> SemaphoreName
$cmax :: SemaphoreName -> SemaphoreName -> SemaphoreName
>= :: SemaphoreName -> SemaphoreName -> Bool
$c>= :: SemaphoreName -> SemaphoreName -> Bool
> :: SemaphoreName -> SemaphoreName -> Bool
$c> :: SemaphoreName -> SemaphoreName -> Bool
<= :: SemaphoreName -> SemaphoreName -> Bool
$c<= :: SemaphoreName -> SemaphoreName -> Bool
< :: SemaphoreName -> SemaphoreName -> Bool
$c< :: SemaphoreName -> SemaphoreName -> Bool
compare :: SemaphoreName -> SemaphoreName -> Ordering
$ccompare :: SemaphoreName -> SemaphoreName -> Ordering
Ord, Int -> SemaphoreName -> ShowS
[SemaphoreName] -> ShowS
SemaphoreName -> String
(Int -> SemaphoreName -> ShowS)
-> (SemaphoreName -> String)
-> ([SemaphoreName] -> ShowS)
-> Show SemaphoreName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SemaphoreName] -> ShowS
$cshowList :: [SemaphoreName] -> ShowS
show :: SemaphoreName -> String
$cshow :: SemaphoreName -> String
showsPrec :: Int -> SemaphoreName -> ShowS
$cshowsPrec :: Int -> SemaphoreName -> ShowS
Show, (forall x. SemaphoreName -> Rep SemaphoreName x)
-> (forall x. Rep SemaphoreName x -> SemaphoreName)
-> Generic SemaphoreName
forall x. Rep SemaphoreName x -> SemaphoreName
forall x. SemaphoreName -> Rep SemaphoreName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SemaphoreName x -> SemaphoreName
$cfrom :: forall x. SemaphoreName -> Rep SemaphoreName x
Generic)
  deriving newtype (Eq SemaphoreName
Eq SemaphoreName
-> (Int -> SemaphoreName -> Int)
-> (SemaphoreName -> Int)
-> Hashable SemaphoreName
Int -> SemaphoreName -> Int
SemaphoreName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: SemaphoreName -> Int
$chash :: SemaphoreName -> Int
hashWithSalt :: Int -> SemaphoreName -> Int
$chashWithSalt :: Int -> SemaphoreName -> Int
Hashable, Value -> Parser [SemaphoreName]
Value -> Parser SemaphoreName
(Value -> Parser SemaphoreName)
-> (Value -> Parser [SemaphoreName]) -> FromJSON SemaphoreName
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [SemaphoreName]
$cparseJSONList :: Value -> Parser [SemaphoreName]
parseJSON :: Value -> Parser SemaphoreName
$cparseJSON :: Value -> Parser SemaphoreName
FromJSON, FromJSONKeyFunction [SemaphoreName]
FromJSONKeyFunction SemaphoreName
FromJSONKeyFunction SemaphoreName
-> FromJSONKeyFunction [SemaphoreName] -> FromJSONKey SemaphoreName
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [SemaphoreName]
$cfromJSONKeyList :: FromJSONKeyFunction [SemaphoreName]
fromJSONKey :: FromJSONKeyFunction SemaphoreName
$cfromJSONKey :: FromJSONKeyFunction SemaphoreName
FromJSONKey, [SemaphoreName] -> Encoding
[SemaphoreName] -> Value
SemaphoreName -> Encoding
SemaphoreName -> Value
(SemaphoreName -> Value)
-> (SemaphoreName -> Encoding)
-> ([SemaphoreName] -> Value)
-> ([SemaphoreName] -> Encoding)
-> ToJSON SemaphoreName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [SemaphoreName] -> Encoding
$ctoEncodingList :: [SemaphoreName] -> Encoding
toJSONList :: [SemaphoreName] -> Value
$ctoJSONList :: [SemaphoreName] -> Value
toEncoding :: SemaphoreName -> Encoding
$ctoEncoding :: SemaphoreName -> Encoding
toJSON :: SemaphoreName -> Value
$ctoJSON :: SemaphoreName -> Value
ToJSON, ToJSONKeyFunction [SemaphoreName]
ToJSONKeyFunction SemaphoreName
ToJSONKeyFunction SemaphoreName
-> ToJSONKeyFunction [SemaphoreName] -> ToJSONKey SemaphoreName
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [SemaphoreName]
$ctoJSONKeyList :: ToJSONKeyFunction [SemaphoreName]
toJSONKey :: ToJSONKeyFunction SemaphoreName
$ctoJSONKey :: ToJSONKeyFunction SemaphoreName
ToJSONKey)

data CanonicalProjectName = CanonicalProjectName
  { CanonicalProjectName -> ProviderName
provider :: ProviderName,
    CanonicalProjectName -> ProjectName
project :: ProjectName
  }
  deriving (CanonicalProjectName -> CanonicalProjectName -> Bool
(CanonicalProjectName -> CanonicalProjectName -> Bool)
-> (CanonicalProjectName -> CanonicalProjectName -> Bool)
-> Eq CanonicalProjectName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CanonicalProjectName -> CanonicalProjectName -> Bool
$c/= :: CanonicalProjectName -> CanonicalProjectName -> Bool
== :: CanonicalProjectName -> CanonicalProjectName -> Bool
$c== :: CanonicalProjectName -> CanonicalProjectName -> Bool
Eq, Eq CanonicalProjectName
Eq CanonicalProjectName
-> (CanonicalProjectName -> CanonicalProjectName -> Ordering)
-> (CanonicalProjectName -> CanonicalProjectName -> Bool)
-> (CanonicalProjectName -> CanonicalProjectName -> Bool)
-> (CanonicalProjectName -> CanonicalProjectName -> Bool)
-> (CanonicalProjectName -> CanonicalProjectName -> Bool)
-> (CanonicalProjectName
    -> CanonicalProjectName -> CanonicalProjectName)
-> (CanonicalProjectName
    -> CanonicalProjectName -> CanonicalProjectName)
-> Ord CanonicalProjectName
CanonicalProjectName -> CanonicalProjectName -> Bool
CanonicalProjectName -> CanonicalProjectName -> Ordering
CanonicalProjectName
-> CanonicalProjectName -> CanonicalProjectName
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 :: CanonicalProjectName
-> CanonicalProjectName -> CanonicalProjectName
$cmin :: CanonicalProjectName
-> CanonicalProjectName -> CanonicalProjectName
max :: CanonicalProjectName
-> CanonicalProjectName -> CanonicalProjectName
$cmax :: CanonicalProjectName
-> CanonicalProjectName -> CanonicalProjectName
>= :: CanonicalProjectName -> CanonicalProjectName -> Bool
$c>= :: CanonicalProjectName -> CanonicalProjectName -> Bool
> :: CanonicalProjectName -> CanonicalProjectName -> Bool
$c> :: CanonicalProjectName -> CanonicalProjectName -> Bool
<= :: CanonicalProjectName -> CanonicalProjectName -> Bool
$c<= :: CanonicalProjectName -> CanonicalProjectName -> Bool
< :: CanonicalProjectName -> CanonicalProjectName -> Bool
$c< :: CanonicalProjectName -> CanonicalProjectName -> Bool
compare :: CanonicalProjectName -> CanonicalProjectName -> Ordering
$ccompare :: CanonicalProjectName -> CanonicalProjectName -> Ordering
Ord, Int -> CanonicalProjectName -> ShowS
[CanonicalProjectName] -> ShowS
CanonicalProjectName -> String
(Int -> CanonicalProjectName -> ShowS)
-> (CanonicalProjectName -> String)
-> ([CanonicalProjectName] -> ShowS)
-> Show CanonicalProjectName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CanonicalProjectName] -> ShowS
$cshowList :: [CanonicalProjectName] -> ShowS
show :: CanonicalProjectName -> String
$cshow :: CanonicalProjectName -> String
showsPrec :: Int -> CanonicalProjectName -> ShowS
$cshowsPrec :: Int -> CanonicalProjectName -> ShowS
Show, (forall x. CanonicalProjectName -> Rep CanonicalProjectName x)
-> (forall x. Rep CanonicalProjectName x -> CanonicalProjectName)
-> Generic CanonicalProjectName
forall x. Rep CanonicalProjectName x -> CanonicalProjectName
forall x. CanonicalProjectName -> Rep CanonicalProjectName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CanonicalProjectName x -> CanonicalProjectName
$cfrom :: forall x. CanonicalProjectName -> Rep CanonicalProjectName x
Generic, Eq CanonicalProjectName
Eq CanonicalProjectName
-> (Int -> CanonicalProjectName -> Int)
-> (CanonicalProjectName -> Int)
-> Hashable CanonicalProjectName
Int -> CanonicalProjectName -> Int
CanonicalProjectName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: CanonicalProjectName -> Int
$chash :: CanonicalProjectName -> Int
hashWithSalt :: Int -> CanonicalProjectName -> Int
$chashWithSalt :: Int -> CanonicalProjectName -> Int
Hashable, Value -> Parser [CanonicalProjectName]
Value -> Parser CanonicalProjectName
(Value -> Parser CanonicalProjectName)
-> (Value -> Parser [CanonicalProjectName])
-> FromJSON CanonicalProjectName
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [CanonicalProjectName]
$cparseJSONList :: Value -> Parser [CanonicalProjectName]
parseJSON :: Value -> Parser CanonicalProjectName
$cparseJSON :: Value -> Parser CanonicalProjectName
FromJSON, FromJSONKeyFunction [CanonicalProjectName]
FromJSONKeyFunction CanonicalProjectName
FromJSONKeyFunction CanonicalProjectName
-> FromJSONKeyFunction [CanonicalProjectName]
-> FromJSONKey CanonicalProjectName
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [CanonicalProjectName]
$cfromJSONKeyList :: FromJSONKeyFunction [CanonicalProjectName]
fromJSONKey :: FromJSONKeyFunction CanonicalProjectName
$cfromJSONKey :: FromJSONKeyFunction CanonicalProjectName
FromJSONKey, [CanonicalProjectName] -> Encoding
[CanonicalProjectName] -> Value
CanonicalProjectName -> Encoding
CanonicalProjectName -> Value
(CanonicalProjectName -> Value)
-> (CanonicalProjectName -> Encoding)
-> ([CanonicalProjectName] -> Value)
-> ([CanonicalProjectName] -> Encoding)
-> ToJSON CanonicalProjectName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [CanonicalProjectName] -> Encoding
$ctoEncodingList :: [CanonicalProjectName] -> Encoding
toJSONList :: [CanonicalProjectName] -> Value
$ctoJSONList :: [CanonicalProjectName] -> Value
toEncoding :: CanonicalProjectName -> Encoding
$ctoEncoding :: CanonicalProjectName -> Encoding
toJSON :: CanonicalProjectName -> Value
$ctoJSON :: CanonicalProjectName -> Value
ToJSON, ToJSONKeyFunction [CanonicalProjectName]
ToJSONKeyFunction CanonicalProjectName
ToJSONKeyFunction CanonicalProjectName
-> ToJSONKeyFunction [CanonicalProjectName]
-> ToJSONKey CanonicalProjectName
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [CanonicalProjectName]
$ctoJSONKeyList :: ToJSONKeyFunction [CanonicalProjectName]
toJSONKey :: ToJSONKeyFunction CanonicalProjectName
$ctoJSONKey :: ToJSONKeyFunction CanonicalProjectName
ToJSONKey)

instance From CanonicalProjectName Text where
  from :: CanonicalProjectName -> Text
from (CanonicalProjectName (ProviderName Text
p) (ProjectName Text
n)) = Text
p Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
n

newtype ConnectionName = ConnectionName Text
  deriving (ConnectionName -> ConnectionName -> Bool
(ConnectionName -> ConnectionName -> Bool)
-> (ConnectionName -> ConnectionName -> Bool) -> Eq ConnectionName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConnectionName -> ConnectionName -> Bool
$c/= :: ConnectionName -> ConnectionName -> Bool
== :: ConnectionName -> ConnectionName -> Bool
$c== :: ConnectionName -> ConnectionName -> Bool
Eq, Eq ConnectionName
Eq ConnectionName
-> (ConnectionName -> ConnectionName -> Ordering)
-> (ConnectionName -> ConnectionName -> Bool)
-> (ConnectionName -> ConnectionName -> Bool)
-> (ConnectionName -> ConnectionName -> Bool)
-> (ConnectionName -> ConnectionName -> Bool)
-> (ConnectionName -> ConnectionName -> ConnectionName)
-> (ConnectionName -> ConnectionName -> ConnectionName)
-> Ord ConnectionName
ConnectionName -> ConnectionName -> Bool
ConnectionName -> ConnectionName -> Ordering
ConnectionName -> ConnectionName -> ConnectionName
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 :: ConnectionName -> ConnectionName -> ConnectionName
$cmin :: ConnectionName -> ConnectionName -> ConnectionName
max :: ConnectionName -> ConnectionName -> ConnectionName
$cmax :: ConnectionName -> ConnectionName -> ConnectionName
>= :: ConnectionName -> ConnectionName -> Bool
$c>= :: ConnectionName -> ConnectionName -> Bool
> :: ConnectionName -> ConnectionName -> Bool
$c> :: ConnectionName -> ConnectionName -> Bool
<= :: ConnectionName -> ConnectionName -> Bool
$c<= :: ConnectionName -> ConnectionName -> Bool
< :: ConnectionName -> ConnectionName -> Bool
$c< :: ConnectionName -> ConnectionName -> Bool
compare :: ConnectionName -> ConnectionName -> Ordering
$ccompare :: ConnectionName -> ConnectionName -> Ordering
Ord, Int -> ConnectionName -> ShowS
[ConnectionName] -> ShowS
ConnectionName -> String
(Int -> ConnectionName -> ShowS)
-> (ConnectionName -> String)
-> ([ConnectionName] -> ShowS)
-> Show ConnectionName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConnectionName] -> ShowS
$cshowList :: [ConnectionName] -> ShowS
show :: ConnectionName -> String
$cshow :: ConnectionName -> String
showsPrec :: Int -> ConnectionName -> ShowS
$cshowsPrec :: Int -> ConnectionName -> ShowS
Show, (forall x. ConnectionName -> Rep ConnectionName x)
-> (forall x. Rep ConnectionName x -> ConnectionName)
-> Generic ConnectionName
forall x. Rep ConnectionName x -> ConnectionName
forall x. ConnectionName -> Rep ConnectionName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ConnectionName x -> ConnectionName
$cfrom :: forall x. ConnectionName -> Rep ConnectionName x
Generic)
  deriving newtype (Eq ConnectionName
Eq ConnectionName
-> (Int -> ConnectionName -> Int)
-> (ConnectionName -> Int)
-> Hashable ConnectionName
Int -> ConnectionName -> Int
ConnectionName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: ConnectionName -> Int
$chash :: ConnectionName -> Int
hashWithSalt :: Int -> ConnectionName -> Int
$chashWithSalt :: Int -> ConnectionName -> Int
Hashable, Value -> Parser [ConnectionName]
Value -> Parser ConnectionName
(Value -> Parser ConnectionName)
-> (Value -> Parser [ConnectionName]) -> FromJSON ConnectionName
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [ConnectionName]
$cparseJSONList :: Value -> Parser [ConnectionName]
parseJSON :: Value -> Parser ConnectionName
$cparseJSON :: Value -> Parser ConnectionName
FromJSON, FromJSONKeyFunction [ConnectionName]
FromJSONKeyFunction ConnectionName
FromJSONKeyFunction ConnectionName
-> FromJSONKeyFunction [ConnectionName]
-> FromJSONKey ConnectionName
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [ConnectionName]
$cfromJSONKeyList :: FromJSONKeyFunction [ConnectionName]
fromJSONKey :: FromJSONKeyFunction ConnectionName
$cfromJSONKey :: FromJSONKeyFunction ConnectionName
FromJSONKey, [ConnectionName] -> Encoding
[ConnectionName] -> Value
ConnectionName -> Encoding
ConnectionName -> Value
(ConnectionName -> Value)
-> (ConnectionName -> Encoding)
-> ([ConnectionName] -> Value)
-> ([ConnectionName] -> Encoding)
-> ToJSON ConnectionName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [ConnectionName] -> Encoding
$ctoEncodingList :: [ConnectionName] -> Encoding
toJSONList :: [ConnectionName] -> Value
$ctoJSONList :: [ConnectionName] -> Value
toEncoding :: ConnectionName -> Encoding
$ctoEncoding :: ConnectionName -> Encoding
toJSON :: ConnectionName -> Value
$ctoJSON :: ConnectionName -> Value
ToJSON, ToJSONKeyFunction [ConnectionName]
ToJSONKeyFunction ConnectionName
ToJSONKeyFunction ConnectionName
-> ToJSONKeyFunction [ConnectionName] -> ToJSONKey ConnectionName
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [ConnectionName]
$ctoJSONKeyList :: ToJSONKeyFunction [ConnectionName]
toJSONKey :: ToJSONKeyFunction ConnectionName
$ctoJSONKey :: ToJSONKeyFunction ConnectionName
ToJSONKey)

-- TODO: use Network.URI.URI instead of Text

-- | The sum of all the possible connection urls
data ConnectionUrl
  = GerritUrl Text
  | GitlabUrl Text
  | GithubUrl Text
  | PagureUrl Text
  | GitUrl Text
  deriving (ConnectionUrl -> ConnectionUrl -> Bool
(ConnectionUrl -> ConnectionUrl -> Bool)
-> (ConnectionUrl -> ConnectionUrl -> Bool) -> Eq ConnectionUrl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConnectionUrl -> ConnectionUrl -> Bool
$c/= :: ConnectionUrl -> ConnectionUrl -> Bool
== :: ConnectionUrl -> ConnectionUrl -> Bool
$c== :: ConnectionUrl -> ConnectionUrl -> Bool
Eq, Eq ConnectionUrl
Eq ConnectionUrl
-> (ConnectionUrl -> ConnectionUrl -> Ordering)
-> (ConnectionUrl -> ConnectionUrl -> Bool)
-> (ConnectionUrl -> ConnectionUrl -> Bool)
-> (ConnectionUrl -> ConnectionUrl -> Bool)
-> (ConnectionUrl -> ConnectionUrl -> Bool)
-> (ConnectionUrl -> ConnectionUrl -> ConnectionUrl)
-> (ConnectionUrl -> ConnectionUrl -> ConnectionUrl)
-> Ord ConnectionUrl
ConnectionUrl -> ConnectionUrl -> Bool
ConnectionUrl -> ConnectionUrl -> Ordering
ConnectionUrl -> ConnectionUrl -> ConnectionUrl
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 :: ConnectionUrl -> ConnectionUrl -> ConnectionUrl
$cmin :: ConnectionUrl -> ConnectionUrl -> ConnectionUrl
max :: ConnectionUrl -> ConnectionUrl -> ConnectionUrl
$cmax :: ConnectionUrl -> ConnectionUrl -> ConnectionUrl
>= :: ConnectionUrl -> ConnectionUrl -> Bool
$c>= :: ConnectionUrl -> ConnectionUrl -> Bool
> :: ConnectionUrl -> ConnectionUrl -> Bool
$c> :: ConnectionUrl -> ConnectionUrl -> Bool
<= :: ConnectionUrl -> ConnectionUrl -> Bool
$c<= :: ConnectionUrl -> ConnectionUrl -> Bool
< :: ConnectionUrl -> ConnectionUrl -> Bool
$c< :: ConnectionUrl -> ConnectionUrl -> Bool
compare :: ConnectionUrl -> ConnectionUrl -> Ordering
$ccompare :: ConnectionUrl -> ConnectionUrl -> Ordering
Ord, Int -> ConnectionUrl -> ShowS
[ConnectionUrl] -> ShowS
ConnectionUrl -> String
(Int -> ConnectionUrl -> ShowS)
-> (ConnectionUrl -> String)
-> ([ConnectionUrl] -> ShowS)
-> Show ConnectionUrl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConnectionUrl] -> ShowS
$cshowList :: [ConnectionUrl] -> ShowS
show :: ConnectionUrl -> String
$cshow :: ConnectionUrl -> String
showsPrec :: Int -> ConnectionUrl -> ShowS
$cshowsPrec :: Int -> ConnectionUrl -> ShowS
Show, (forall x. ConnectionUrl -> Rep ConnectionUrl x)
-> (forall x. Rep ConnectionUrl x -> ConnectionUrl)
-> Generic ConnectionUrl
forall x. Rep ConnectionUrl x -> ConnectionUrl
forall x. ConnectionUrl -> Rep ConnectionUrl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ConnectionUrl x -> ConnectionUrl
$cfrom :: forall x. ConnectionUrl -> Rep ConnectionUrl x
Generic, Value -> Parser [ConnectionUrl]
Value -> Parser ConnectionUrl
(Value -> Parser ConnectionUrl)
-> (Value -> Parser [ConnectionUrl]) -> FromJSON ConnectionUrl
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [ConnectionUrl]
$cparseJSONList :: Value -> Parser [ConnectionUrl]
parseJSON :: Value -> Parser ConnectionUrl
$cparseJSON :: Value -> Parser ConnectionUrl
FromJSON, [ConnectionUrl] -> Encoding
[ConnectionUrl] -> Value
ConnectionUrl -> Encoding
ConnectionUrl -> Value
(ConnectionUrl -> Value)
-> (ConnectionUrl -> Encoding)
-> ([ConnectionUrl] -> Value)
-> ([ConnectionUrl] -> Encoding)
-> ToJSON ConnectionUrl
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [ConnectionUrl] -> Encoding
$ctoEncodingList :: [ConnectionUrl] -> Encoding
toJSONList :: [ConnectionUrl] -> Value
$ctoJSONList :: [ConnectionUrl] -> Value
toEncoding :: ConnectionUrl -> Encoding
$ctoEncoding :: ConnectionUrl -> Encoding
toJSON :: ConnectionUrl -> Value
$ctoJSON :: ConnectionUrl -> Value
ToJSON)

newtype TenantName = TenantName Text
  deriving (Int -> TenantName -> ShowS
[TenantName] -> ShowS
TenantName -> String
(Int -> TenantName -> ShowS)
-> (TenantName -> String)
-> ([TenantName] -> ShowS)
-> Show TenantName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TenantName] -> ShowS
$cshowList :: [TenantName] -> ShowS
show :: TenantName -> String
$cshow :: TenantName -> String
showsPrec :: Int -> TenantName -> ShowS
$cshowsPrec :: Int -> TenantName -> ShowS
Show, TenantName -> TenantName -> Bool
(TenantName -> TenantName -> Bool)
-> (TenantName -> TenantName -> Bool) -> Eq TenantName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TenantName -> TenantName -> Bool
$c/= :: TenantName -> TenantName -> Bool
== :: TenantName -> TenantName -> Bool
$c== :: TenantName -> TenantName -> Bool
Eq, Eq TenantName
Eq TenantName
-> (TenantName -> TenantName -> Ordering)
-> (TenantName -> TenantName -> Bool)
-> (TenantName -> TenantName -> Bool)
-> (TenantName -> TenantName -> Bool)
-> (TenantName -> TenantName -> Bool)
-> (TenantName -> TenantName -> TenantName)
-> (TenantName -> TenantName -> TenantName)
-> Ord TenantName
TenantName -> TenantName -> Bool
TenantName -> TenantName -> Ordering
TenantName -> TenantName -> TenantName
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 :: TenantName -> TenantName -> TenantName
$cmin :: TenantName -> TenantName -> TenantName
max :: TenantName -> TenantName -> TenantName
$cmax :: TenantName -> TenantName -> TenantName
>= :: TenantName -> TenantName -> Bool
$c>= :: TenantName -> TenantName -> Bool
> :: TenantName -> TenantName -> Bool
$c> :: TenantName -> TenantName -> Bool
<= :: TenantName -> TenantName -> Bool
$c<= :: TenantName -> TenantName -> Bool
< :: TenantName -> TenantName -> Bool
$c< :: TenantName -> TenantName -> Bool
compare :: TenantName -> TenantName -> Ordering
$ccompare :: TenantName -> TenantName -> Ordering
Ord, (forall x. TenantName -> Rep TenantName x)
-> (forall x. Rep TenantName x -> TenantName) -> Generic TenantName
forall x. Rep TenantName x -> TenantName
forall x. TenantName -> Rep TenantName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TenantName x -> TenantName
$cfrom :: forall x. TenantName -> Rep TenantName x
Generic)
  deriving newtype (Eq TenantName
Eq TenantName
-> (Int -> TenantName -> Int)
-> (TenantName -> Int)
-> Hashable TenantName
Int -> TenantName -> Int
TenantName -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: TenantName -> Int
$chash :: TenantName -> Int
hashWithSalt :: Int -> TenantName -> Int
$chashWithSalt :: Int -> TenantName -> Int
Hashable, Value -> Parser [TenantName]
Value -> Parser TenantName
(Value -> Parser TenantName)
-> (Value -> Parser [TenantName]) -> FromJSON TenantName
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [TenantName]
$cparseJSONList :: Value -> Parser [TenantName]
parseJSON :: Value -> Parser TenantName
$cparseJSON :: Value -> Parser TenantName
FromJSON, [TenantName] -> Encoding
[TenantName] -> Value
TenantName -> Encoding
TenantName -> Value
(TenantName -> Value)
-> (TenantName -> Encoding)
-> ([TenantName] -> Value)
-> ([TenantName] -> Encoding)
-> ToJSON TenantName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [TenantName] -> Encoding
$ctoEncodingList :: [TenantName] -> Encoding
toJSONList :: [TenantName] -> Value
$ctoJSONList :: [TenantName] -> Value
toEncoding :: TenantName -> Encoding
$ctoEncoding :: TenantName -> Encoding
toJSON :: TenantName -> Value
$ctoJSON :: TenantName -> Value
ToJSON)

instance From TenantName Text where
  from :: TenantName -> Text
from (TenantName Text
name) = Text
name

data JobNodeset
  = JobNodeset NodesetName
  | JobAnonymousNodeset [NodeLabelName]
  deriving (JobNodeset -> JobNodeset -> Bool
(JobNodeset -> JobNodeset -> Bool)
-> (JobNodeset -> JobNodeset -> Bool) -> Eq JobNodeset
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JobNodeset -> JobNodeset -> Bool
$c/= :: JobNodeset -> JobNodeset -> Bool
== :: JobNodeset -> JobNodeset -> Bool
$c== :: JobNodeset -> JobNodeset -> Bool
Eq, Eq JobNodeset
Eq JobNodeset
-> (JobNodeset -> JobNodeset -> Ordering)
-> (JobNodeset -> JobNodeset -> Bool)
-> (JobNodeset -> JobNodeset -> Bool)
-> (JobNodeset -> JobNodeset -> Bool)
-> (JobNodeset -> JobNodeset -> Bool)
-> (JobNodeset -> JobNodeset -> JobNodeset)
-> (JobNodeset -> JobNodeset -> JobNodeset)
-> Ord JobNodeset
JobNodeset -> JobNodeset -> Bool
JobNodeset -> JobNodeset -> Ordering
JobNodeset -> JobNodeset -> JobNodeset
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 :: JobNodeset -> JobNodeset -> JobNodeset
$cmin :: JobNodeset -> JobNodeset -> JobNodeset
max :: JobNodeset -> JobNodeset -> JobNodeset
$cmax :: JobNodeset -> JobNodeset -> JobNodeset
>= :: JobNodeset -> JobNodeset -> Bool
$c>= :: JobNodeset -> JobNodeset -> Bool
> :: JobNodeset -> JobNodeset -> Bool
$c> :: JobNodeset -> JobNodeset -> Bool
<= :: JobNodeset -> JobNodeset -> Bool
$c<= :: JobNodeset -> JobNodeset -> Bool
< :: JobNodeset -> JobNodeset -> Bool
$c< :: JobNodeset -> JobNodeset -> Bool
compare :: JobNodeset -> JobNodeset -> Ordering
$ccompare :: JobNodeset -> JobNodeset -> Ordering
Ord, Int -> JobNodeset -> ShowS
[JobNodeset] -> ShowS
JobNodeset -> String
(Int -> JobNodeset -> ShowS)
-> (JobNodeset -> String)
-> ([JobNodeset] -> ShowS)
-> Show JobNodeset
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JobNodeset] -> ShowS
$cshowList :: [JobNodeset] -> ShowS
show :: JobNodeset -> String
$cshow :: JobNodeset -> String
showsPrec :: Int -> JobNodeset -> ShowS
$cshowsPrec :: Int -> JobNodeset -> ShowS
Show, (forall x. JobNodeset -> Rep JobNodeset x)
-> (forall x. Rep JobNodeset x -> JobNodeset) -> Generic JobNodeset
forall x. Rep JobNodeset x -> JobNodeset
forall x. JobNodeset -> Rep JobNodeset x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep JobNodeset x -> JobNodeset
$cfrom :: forall x. JobNodeset -> Rep JobNodeset x
Generic, Eq JobNodeset
Eq JobNodeset
-> (Int -> JobNodeset -> Int)
-> (JobNodeset -> Int)
-> Hashable JobNodeset
Int -> JobNodeset -> Int
JobNodeset -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: JobNodeset -> Int
$chash :: JobNodeset -> Int
hashWithSalt :: Int -> JobNodeset -> Int
$chashWithSalt :: Int -> JobNodeset -> Int
Hashable, Value -> Parser [JobNodeset]
Value -> Parser JobNodeset
(Value -> Parser JobNodeset)
-> (Value -> Parser [JobNodeset]) -> FromJSON JobNodeset
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [JobNodeset]
$cparseJSONList :: Value -> Parser [JobNodeset]
parseJSON :: Value -> Parser JobNodeset
$cparseJSON :: Value -> Parser JobNodeset
FromJSON, [JobNodeset] -> Encoding
[JobNodeset] -> Value
JobNodeset -> Encoding
JobNodeset -> Value
(JobNodeset -> Value)
-> (JobNodeset -> Encoding)
-> ([JobNodeset] -> Value)
-> ([JobNodeset] -> Encoding)
-> ToJSON JobNodeset
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [JobNodeset] -> Encoding
$ctoEncodingList :: [JobNodeset] -> Encoding
toJSONList :: [JobNodeset] -> Value
$ctoJSONList :: [JobNodeset] -> Value
toEncoding :: JobNodeset -> Encoding
$ctoEncoding :: JobNodeset -> Encoding
toJSON :: JobNodeset -> Value
$ctoJSON :: JobNodeset -> Value
ToJSON)

data Nodeset = Nodeset
  { Nodeset -> NodesetName
name :: NodesetName,
    Nodeset -> [NodeLabelName]
labels :: [NodeLabelName]
  }
  deriving (Int -> Nodeset -> ShowS
[Nodeset] -> ShowS
Nodeset -> String
(Int -> Nodeset -> ShowS)
-> (Nodeset -> String) -> ([Nodeset] -> ShowS) -> Show Nodeset
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Nodeset] -> ShowS
$cshowList :: [Nodeset] -> ShowS
show :: Nodeset -> String
$cshow :: Nodeset -> String
showsPrec :: Int -> Nodeset -> ShowS
$cshowsPrec :: Int -> Nodeset -> ShowS
Show, Nodeset -> Nodeset -> Bool
(Nodeset -> Nodeset -> Bool)
-> (Nodeset -> Nodeset -> Bool) -> Eq Nodeset
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Nodeset -> Nodeset -> Bool
$c/= :: Nodeset -> Nodeset -> Bool
== :: Nodeset -> Nodeset -> Bool
$c== :: Nodeset -> Nodeset -> Bool
Eq, Eq Nodeset
Eq Nodeset
-> (Nodeset -> Nodeset -> Ordering)
-> (Nodeset -> Nodeset -> Bool)
-> (Nodeset -> Nodeset -> Bool)
-> (Nodeset -> Nodeset -> Bool)
-> (Nodeset -> Nodeset -> Bool)
-> (Nodeset -> Nodeset -> Nodeset)
-> (Nodeset -> Nodeset -> Nodeset)
-> Ord Nodeset
Nodeset -> Nodeset -> Bool
Nodeset -> Nodeset -> Ordering
Nodeset -> Nodeset -> Nodeset
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 :: Nodeset -> Nodeset -> Nodeset
$cmin :: Nodeset -> Nodeset -> Nodeset
max :: Nodeset -> Nodeset -> Nodeset
$cmax :: Nodeset -> Nodeset -> Nodeset
>= :: Nodeset -> Nodeset -> Bool
$c>= :: Nodeset -> Nodeset -> Bool
> :: Nodeset -> Nodeset -> Bool
$c> :: Nodeset -> Nodeset -> Bool
<= :: Nodeset -> Nodeset -> Bool
$c<= :: Nodeset -> Nodeset -> Bool
< :: Nodeset -> Nodeset -> Bool
$c< :: Nodeset -> Nodeset -> Bool
compare :: Nodeset -> Nodeset -> Ordering
$ccompare :: Nodeset -> Nodeset -> Ordering
Ord, (forall x. Nodeset -> Rep Nodeset x)
-> (forall x. Rep Nodeset x -> Nodeset) -> Generic Nodeset
forall x. Rep Nodeset x -> Nodeset
forall x. Nodeset -> Rep Nodeset x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Nodeset x -> Nodeset
$cfrom :: forall x. Nodeset -> Rep Nodeset x
Generic, Eq Nodeset
Eq Nodeset
-> (Int -> Nodeset -> Int) -> (Nodeset -> Int) -> Hashable Nodeset
Int -> Nodeset -> Int
Nodeset -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Nodeset -> Int
$chash :: Nodeset -> Int
hashWithSalt :: Int -> Nodeset -> Int
$chashWithSalt :: Int -> Nodeset -> Int
Hashable, Value -> Parser [Nodeset]
Value -> Parser Nodeset
(Value -> Parser Nodeset)
-> (Value -> Parser [Nodeset]) -> FromJSON Nodeset
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [Nodeset]
$cparseJSONList :: Value -> Parser [Nodeset]
parseJSON :: Value -> Parser Nodeset
$cparseJSON :: Value -> Parser Nodeset
FromJSON, [Nodeset] -> Encoding
[Nodeset] -> Value
Nodeset -> Encoding
Nodeset -> Value
(Nodeset -> Value)
-> (Nodeset -> Encoding)
-> ([Nodeset] -> Value)
-> ([Nodeset] -> Encoding)
-> ToJSON Nodeset
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [Nodeset] -> Encoding
$ctoEncodingList :: [Nodeset] -> Encoding
toJSONList :: [Nodeset] -> Value
$ctoJSONList :: [Nodeset] -> Value
toEncoding :: Nodeset -> Encoding
$ctoEncoding :: Nodeset -> Encoding
toJSON :: Nodeset -> Value
$ctoJSON :: Nodeset -> Value
ToJSON)

data Job = Job
  { Job -> JobName
name :: JobName,
    Job -> Maybe Bool
abstract :: Maybe Bool,
    Job -> Maybe JobName
parent :: Maybe JobName,
    Job -> Maybe JobNodeset
nodeset :: Maybe JobNodeset,
    Job -> Maybe [BranchName]
branches :: Maybe [BranchName],
    Job -> Maybe [JobName]
dependencies :: Maybe [JobName],
    Job -> Maybe [SemaphoreName]
semaphores :: Maybe [SemaphoreName],
    Job -> Maybe [SecretName]
secrets :: Maybe [SecretName]
  }
  deriving (Int -> Job -> ShowS
[Job] -> ShowS
Job -> String
(Int -> Job -> ShowS)
-> (Job -> String) -> ([Job] -> ShowS) -> Show Job
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Job] -> ShowS
$cshowList :: [Job] -> ShowS
show :: Job -> String
$cshow :: Job -> String
showsPrec :: Int -> Job -> ShowS
$cshowsPrec :: Int -> Job -> ShowS
Show, Job -> Job -> Bool
(Job -> Job -> Bool) -> (Job -> Job -> Bool) -> Eq Job
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Job -> Job -> Bool
$c/= :: Job -> Job -> Bool
== :: Job -> Job -> Bool
$c== :: Job -> Job -> Bool
Eq, Eq Job
Eq Job
-> (Job -> Job -> Ordering)
-> (Job -> Job -> Bool)
-> (Job -> Job -> Bool)
-> (Job -> Job -> Bool)
-> (Job -> Job -> Bool)
-> (Job -> Job -> Job)
-> (Job -> Job -> Job)
-> Ord Job
Job -> Job -> Bool
Job -> Job -> Ordering
Job -> Job -> Job
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 :: Job -> Job -> Job
$cmin :: Job -> Job -> Job
max :: Job -> Job -> Job
$cmax :: Job -> Job -> Job
>= :: Job -> Job -> Bool
$c>= :: Job -> Job -> Bool
> :: Job -> Job -> Bool
$c> :: Job -> Job -> Bool
<= :: Job -> Job -> Bool
$c<= :: Job -> Job -> Bool
< :: Job -> Job -> Bool
$c< :: Job -> Job -> Bool
compare :: Job -> Job -> Ordering
$ccompare :: Job -> Job -> Ordering
Ord, (forall x. Job -> Rep Job x)
-> (forall x. Rep Job x -> Job) -> Generic Job
forall x. Rep Job x -> Job
forall x. Job -> Rep Job x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Job x -> Job
$cfrom :: forall x. Job -> Rep Job x
Generic, Eq Job
Eq Job -> (Int -> Job -> Int) -> (Job -> Int) -> Hashable Job
Int -> Job -> Int
Job -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Job -> Int
$chash :: Job -> Int
hashWithSalt :: Int -> Job -> Int
$chashWithSalt :: Int -> Job -> Int
Hashable)

instance FromJSON Job where
  parseJSON :: Value -> Parser Job
parseJSON = Options -> Value -> Parser Job
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON Options
defaultOptions {omitNothingFields :: Bool
omitNothingFields = Bool
True}

instance ToJSON Job where
  toJSON :: Job -> Value
toJSON = Options -> Job -> Value
forall a.
(Generic a, GToJSON' Value Zero (Rep a)) =>
Options -> a -> Value
genericToJSON Options
defaultOptions {omitNothingFields :: Bool
omitNothingFields = Bool
True}

data PipelineJob
  = PJName JobName
  | PJJob Job
  deriving (Int -> PipelineJob -> ShowS
[PipelineJob] -> ShowS
PipelineJob -> String
(Int -> PipelineJob -> ShowS)
-> (PipelineJob -> String)
-> ([PipelineJob] -> ShowS)
-> Show PipelineJob
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PipelineJob] -> ShowS
$cshowList :: [PipelineJob] -> ShowS
show :: PipelineJob -> String
$cshow :: PipelineJob -> String
showsPrec :: Int -> PipelineJob -> ShowS
$cshowsPrec :: Int -> PipelineJob -> ShowS
Show, PipelineJob -> PipelineJob -> Bool
(PipelineJob -> PipelineJob -> Bool)
-> (PipelineJob -> PipelineJob -> Bool) -> Eq PipelineJob
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PipelineJob -> PipelineJob -> Bool
$c/= :: PipelineJob -> PipelineJob -> Bool
== :: PipelineJob -> PipelineJob -> Bool
$c== :: PipelineJob -> PipelineJob -> Bool
Eq, Eq PipelineJob
Eq PipelineJob
-> (PipelineJob -> PipelineJob -> Ordering)
-> (PipelineJob -> PipelineJob -> Bool)
-> (PipelineJob -> PipelineJob -> Bool)
-> (PipelineJob -> PipelineJob -> Bool)
-> (PipelineJob -> PipelineJob -> Bool)
-> (PipelineJob -> PipelineJob -> PipelineJob)
-> (PipelineJob -> PipelineJob -> PipelineJob)
-> Ord PipelineJob
PipelineJob -> PipelineJob -> Bool
PipelineJob -> PipelineJob -> Ordering
PipelineJob -> PipelineJob -> PipelineJob
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 :: PipelineJob -> PipelineJob -> PipelineJob
$cmin :: PipelineJob -> PipelineJob -> PipelineJob
max :: PipelineJob -> PipelineJob -> PipelineJob
$cmax :: PipelineJob -> PipelineJob -> PipelineJob
>= :: PipelineJob -> PipelineJob -> Bool
$c>= :: PipelineJob -> PipelineJob -> Bool
> :: PipelineJob -> PipelineJob -> Bool
$c> :: PipelineJob -> PipelineJob -> Bool
<= :: PipelineJob -> PipelineJob -> Bool
$c<= :: PipelineJob -> PipelineJob -> Bool
< :: PipelineJob -> PipelineJob -> Bool
$c< :: PipelineJob -> PipelineJob -> Bool
compare :: PipelineJob -> PipelineJob -> Ordering
$ccompare :: PipelineJob -> PipelineJob -> Ordering
Ord, (forall x. PipelineJob -> Rep PipelineJob x)
-> (forall x. Rep PipelineJob x -> PipelineJob)
-> Generic PipelineJob
forall x. Rep PipelineJob x -> PipelineJob
forall x. PipelineJob -> Rep PipelineJob x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PipelineJob x -> PipelineJob
$cfrom :: forall x. PipelineJob -> Rep PipelineJob x
Generic, Eq PipelineJob
Eq PipelineJob
-> (Int -> PipelineJob -> Int)
-> (PipelineJob -> Int)
-> Hashable PipelineJob
Int -> PipelineJob -> Int
PipelineJob -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: PipelineJob -> Int
$chash :: PipelineJob -> Int
hashWithSalt :: Int -> PipelineJob -> Int
$chashWithSalt :: Int -> PipelineJob -> Int
Hashable, Value -> Parser [PipelineJob]
Value -> Parser PipelineJob
(Value -> Parser PipelineJob)
-> (Value -> Parser [PipelineJob]) -> FromJSON PipelineJob
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [PipelineJob]
$cparseJSONList :: Value -> Parser [PipelineJob]
parseJSON :: Value -> Parser PipelineJob
$cparseJSON :: Value -> Parser PipelineJob
FromJSON, [PipelineJob] -> Encoding
[PipelineJob] -> Value
PipelineJob -> Encoding
PipelineJob -> Value
(PipelineJob -> Value)
-> (PipelineJob -> Encoding)
-> ([PipelineJob] -> Value)
-> ([PipelineJob] -> Encoding)
-> ToJSON PipelineJob
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [PipelineJob] -> Encoding
$ctoEncodingList :: [PipelineJob] -> Encoding
toJSONList :: [PipelineJob] -> Value
$ctoJSONList :: [PipelineJob] -> Value
toEncoding :: PipelineJob -> Encoding
$ctoEncoding :: PipelineJob -> Encoding
toJSON :: PipelineJob -> Value
$ctoJSON :: PipelineJob -> Value
ToJSON)

instance From PipelineJob JobName where
  from :: PipelineJob -> JobName
from = \case
    PJName JobName
name -> JobName
name
    PJJob Job
job -> Job
job.name

data ProjectPipeline = ProjectPipeline
  { ProjectPipeline -> PipelineName
name :: PipelineName,
    ProjectPipeline -> [PipelineJob]
jobs :: [PipelineJob]
  }
  deriving (Int -> ProjectPipeline -> ShowS
[ProjectPipeline] -> ShowS
ProjectPipeline -> String
(Int -> ProjectPipeline -> ShowS)
-> (ProjectPipeline -> String)
-> ([ProjectPipeline] -> ShowS)
-> Show ProjectPipeline
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProjectPipeline] -> ShowS
$cshowList :: [ProjectPipeline] -> ShowS
show :: ProjectPipeline -> String
$cshow :: ProjectPipeline -> String
showsPrec :: Int -> ProjectPipeline -> ShowS
$cshowsPrec :: Int -> ProjectPipeline -> ShowS
Show, ProjectPipeline -> ProjectPipeline -> Bool
(ProjectPipeline -> ProjectPipeline -> Bool)
-> (ProjectPipeline -> ProjectPipeline -> Bool)
-> Eq ProjectPipeline
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProjectPipeline -> ProjectPipeline -> Bool
$c/= :: ProjectPipeline -> ProjectPipeline -> Bool
== :: ProjectPipeline -> ProjectPipeline -> Bool
$c== :: ProjectPipeline -> ProjectPipeline -> Bool
Eq, Eq ProjectPipeline
Eq ProjectPipeline
-> (ProjectPipeline -> ProjectPipeline -> Ordering)
-> (ProjectPipeline -> ProjectPipeline -> Bool)
-> (ProjectPipeline -> ProjectPipeline -> Bool)
-> (ProjectPipeline -> ProjectPipeline -> Bool)
-> (ProjectPipeline -> ProjectPipeline -> Bool)
-> (ProjectPipeline -> ProjectPipeline -> ProjectPipeline)
-> (ProjectPipeline -> ProjectPipeline -> ProjectPipeline)
-> Ord ProjectPipeline
ProjectPipeline -> ProjectPipeline -> Bool
ProjectPipeline -> ProjectPipeline -> Ordering
ProjectPipeline -> ProjectPipeline -> ProjectPipeline
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 :: ProjectPipeline -> ProjectPipeline -> ProjectPipeline
$cmin :: ProjectPipeline -> ProjectPipeline -> ProjectPipeline
max :: ProjectPipeline -> ProjectPipeline -> ProjectPipeline
$cmax :: ProjectPipeline -> ProjectPipeline -> ProjectPipeline
>= :: ProjectPipeline -> ProjectPipeline -> Bool
$c>= :: ProjectPipeline -> ProjectPipeline -> Bool
> :: ProjectPipeline -> ProjectPipeline -> Bool
$c> :: ProjectPipeline -> ProjectPipeline -> Bool
<= :: ProjectPipeline -> ProjectPipeline -> Bool
$c<= :: ProjectPipeline -> ProjectPipeline -> Bool
< :: ProjectPipeline -> ProjectPipeline -> Bool
$c< :: ProjectPipeline -> ProjectPipeline -> Bool
compare :: ProjectPipeline -> ProjectPipeline -> Ordering
$ccompare :: ProjectPipeline -> ProjectPipeline -> Ordering
Ord, (forall x. ProjectPipeline -> Rep ProjectPipeline x)
-> (forall x. Rep ProjectPipeline x -> ProjectPipeline)
-> Generic ProjectPipeline
forall x. Rep ProjectPipeline x -> ProjectPipeline
forall x. ProjectPipeline -> Rep ProjectPipeline x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProjectPipeline x -> ProjectPipeline
$cfrom :: forall x. ProjectPipeline -> Rep ProjectPipeline x
Generic, Eq ProjectPipeline
Eq ProjectPipeline
-> (Int -> ProjectPipeline -> Int)
-> (ProjectPipeline -> Int)
-> Hashable ProjectPipeline
Int -> ProjectPipeline -> Int
ProjectPipeline -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: ProjectPipeline -> Int
$chash :: ProjectPipeline -> Int
hashWithSalt :: Int -> ProjectPipeline -> Int
$chashWithSalt :: Int -> ProjectPipeline -> Int
Hashable, Value -> Parser [ProjectPipeline]
Value -> Parser ProjectPipeline
(Value -> Parser ProjectPipeline)
-> (Value -> Parser [ProjectPipeline]) -> FromJSON ProjectPipeline
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [ProjectPipeline]
$cparseJSONList :: Value -> Parser [ProjectPipeline]
parseJSON :: Value -> Parser ProjectPipeline
$cparseJSON :: Value -> Parser ProjectPipeline
FromJSON, [ProjectPipeline] -> Encoding
[ProjectPipeline] -> Value
ProjectPipeline -> Encoding
ProjectPipeline -> Value
(ProjectPipeline -> Value)
-> (ProjectPipeline -> Encoding)
-> ([ProjectPipeline] -> Value)
-> ([ProjectPipeline] -> Encoding)
-> ToJSON ProjectPipeline
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [ProjectPipeline] -> Encoding
$ctoEncodingList :: [ProjectPipeline] -> Encoding
toJSONList :: [ProjectPipeline] -> Value
$ctoJSONList :: [ProjectPipeline] -> Value
toEncoding :: ProjectPipeline -> Encoding
$ctoEncoding :: ProjectPipeline -> Encoding
toJSON :: ProjectPipeline -> Value
$ctoJSON :: ProjectPipeline -> Value
ToJSON)

data Project = Project
  { Project -> ProjectName
name :: ProjectName,
    Project -> [ProjectTemplateName]
templates :: [ProjectTemplateName],
    Project -> Maybe QueueName
queue :: Maybe QueueName,
    Project -> Set ProjectPipeline
pipelines :: Set ProjectPipeline
  }
  deriving (Int -> Project -> ShowS
[Project] -> ShowS
Project -> String
(Int -> Project -> ShowS)
-> (Project -> String) -> ([Project] -> ShowS) -> Show Project
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Project] -> ShowS
$cshowList :: [Project] -> ShowS
show :: Project -> String
$cshow :: Project -> String
showsPrec :: Int -> Project -> ShowS
$cshowsPrec :: Int -> Project -> ShowS
Show, Project -> Project -> Bool
(Project -> Project -> Bool)
-> (Project -> Project -> Bool) -> Eq Project
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Project -> Project -> Bool
$c/= :: Project -> Project -> Bool
== :: Project -> Project -> Bool
$c== :: Project -> Project -> Bool
Eq, Eq Project
Eq Project
-> (Project -> Project -> Ordering)
-> (Project -> Project -> Bool)
-> (Project -> Project -> Bool)
-> (Project -> Project -> Bool)
-> (Project -> Project -> Bool)
-> (Project -> Project -> Project)
-> (Project -> Project -> Project)
-> Ord Project
Project -> Project -> Bool
Project -> Project -> Ordering
Project -> Project -> Project
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 :: Project -> Project -> Project
$cmin :: Project -> Project -> Project
max :: Project -> Project -> Project
$cmax :: Project -> Project -> Project
>= :: Project -> Project -> Bool
$c>= :: Project -> Project -> Bool
> :: Project -> Project -> Bool
$c> :: Project -> Project -> Bool
<= :: Project -> Project -> Bool
$c<= :: Project -> Project -> Bool
< :: Project -> Project -> Bool
$c< :: Project -> Project -> Bool
compare :: Project -> Project -> Ordering
$ccompare :: Project -> Project -> Ordering
Ord, (forall x. Project -> Rep Project x)
-> (forall x. Rep Project x -> Project) -> Generic Project
forall x. Rep Project x -> Project
forall x. Project -> Rep Project x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Project x -> Project
$cfrom :: forall x. Project -> Rep Project x
Generic, Eq Project
Eq Project
-> (Int -> Project -> Int) -> (Project -> Int) -> Hashable Project
Int -> Project -> Int
Project -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Project -> Int
$chash :: Project -> Int
hashWithSalt :: Int -> Project -> Int
$chashWithSalt :: Int -> Project -> Int
Hashable, Value -> Parser [Project]
Value -> Parser Project
(Value -> Parser Project)
-> (Value -> Parser [Project]) -> FromJSON Project
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [Project]
$cparseJSONList :: Value -> Parser [Project]
parseJSON :: Value -> Parser Project
$cparseJSON :: Value -> Parser Project
FromJSON, [Project] -> Encoding
[Project] -> Value
Project -> Encoding
Project -> Value
(Project -> Value)
-> (Project -> Encoding)
-> ([Project] -> Value)
-> ([Project] -> Encoding)
-> ToJSON Project
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [Project] -> Encoding
$ctoEncodingList :: [Project] -> Encoding
toJSONList :: [Project] -> Value
$ctoJSONList :: [Project] -> Value
toEncoding :: Project -> Encoding
$ctoEncoding :: Project -> Encoding
toJSON :: Project -> Value
$ctoJSON :: Project -> Value
ToJSON)

data ProjectTemplate = ProjectTemplate
  { ProjectTemplate -> ProjectTemplateName
name :: ProjectTemplateName,
    ProjectTemplate -> Maybe QueueName
queue :: Maybe QueueName,
    ProjectTemplate -> Set ProjectPipeline
pipelines :: Set ProjectPipeline
  }
  deriving (Int -> ProjectTemplate -> ShowS
[ProjectTemplate] -> ShowS
ProjectTemplate -> String
(Int -> ProjectTemplate -> ShowS)
-> (ProjectTemplate -> String)
-> ([ProjectTemplate] -> ShowS)
-> Show ProjectTemplate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProjectTemplate] -> ShowS
$cshowList :: [ProjectTemplate] -> ShowS
show :: ProjectTemplate -> String
$cshow :: ProjectTemplate -> String
showsPrec :: Int -> ProjectTemplate -> ShowS
$cshowsPrec :: Int -> ProjectTemplate -> ShowS
Show, ProjectTemplate -> ProjectTemplate -> Bool
(ProjectTemplate -> ProjectTemplate -> Bool)
-> (ProjectTemplate -> ProjectTemplate -> Bool)
-> Eq ProjectTemplate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProjectTemplate -> ProjectTemplate -> Bool
$c/= :: ProjectTemplate -> ProjectTemplate -> Bool
== :: ProjectTemplate -> ProjectTemplate -> Bool
$c== :: ProjectTemplate -> ProjectTemplate -> Bool
Eq, Eq ProjectTemplate
Eq ProjectTemplate
-> (ProjectTemplate -> ProjectTemplate -> Ordering)
-> (ProjectTemplate -> ProjectTemplate -> Bool)
-> (ProjectTemplate -> ProjectTemplate -> Bool)
-> (ProjectTemplate -> ProjectTemplate -> Bool)
-> (ProjectTemplate -> ProjectTemplate -> Bool)
-> (ProjectTemplate -> ProjectTemplate -> ProjectTemplate)
-> (ProjectTemplate -> ProjectTemplate -> ProjectTemplate)
-> Ord ProjectTemplate
ProjectTemplate -> ProjectTemplate -> Bool
ProjectTemplate -> ProjectTemplate -> Ordering
ProjectTemplate -> ProjectTemplate -> ProjectTemplate
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 :: ProjectTemplate -> ProjectTemplate -> ProjectTemplate
$cmin :: ProjectTemplate -> ProjectTemplate -> ProjectTemplate
max :: ProjectTemplate -> ProjectTemplate -> ProjectTemplate
$cmax :: ProjectTemplate -> ProjectTemplate -> ProjectTemplate
>= :: ProjectTemplate -> ProjectTemplate -> Bool
$c>= :: ProjectTemplate -> ProjectTemplate -> Bool
> :: ProjectTemplate -> ProjectTemplate -> Bool
$c> :: ProjectTemplate -> ProjectTemplate -> Bool
<= :: ProjectTemplate -> ProjectTemplate -> Bool
$c<= :: ProjectTemplate -> ProjectTemplate -> Bool
< :: ProjectTemplate -> ProjectTemplate -> Bool
$c< :: ProjectTemplate -> ProjectTemplate -> Bool
compare :: ProjectTemplate -> ProjectTemplate -> Ordering
$ccompare :: ProjectTemplate -> ProjectTemplate -> Ordering
Ord, (forall x. ProjectTemplate -> Rep ProjectTemplate x)
-> (forall x. Rep ProjectTemplate x -> ProjectTemplate)
-> Generic ProjectTemplate
forall x. Rep ProjectTemplate x -> ProjectTemplate
forall x. ProjectTemplate -> Rep ProjectTemplate x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProjectTemplate x -> ProjectTemplate
$cfrom :: forall x. ProjectTemplate -> Rep ProjectTemplate x
Generic, Eq ProjectTemplate
Eq ProjectTemplate
-> (Int -> ProjectTemplate -> Int)
-> (ProjectTemplate -> Int)
-> Hashable ProjectTemplate
Int -> ProjectTemplate -> Int
ProjectTemplate -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: ProjectTemplate -> Int
$chash :: ProjectTemplate -> Int
hashWithSalt :: Int -> ProjectTemplate -> Int
$chashWithSalt :: Int -> ProjectTemplate -> Int
Hashable, Value -> Parser [ProjectTemplate]
Value -> Parser ProjectTemplate
(Value -> Parser ProjectTemplate)
-> (Value -> Parser [ProjectTemplate]) -> FromJSON ProjectTemplate
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [ProjectTemplate]
$cparseJSONList :: Value -> Parser [ProjectTemplate]
parseJSON :: Value -> Parser ProjectTemplate
$cparseJSON :: Value -> Parser ProjectTemplate
FromJSON, [ProjectTemplate] -> Encoding
[ProjectTemplate] -> Value
ProjectTemplate -> Encoding
ProjectTemplate -> Value
(ProjectTemplate -> Value)
-> (ProjectTemplate -> Encoding)
-> ([ProjectTemplate] -> Value)
-> ([ProjectTemplate] -> Encoding)
-> ToJSON ProjectTemplate
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [ProjectTemplate] -> Encoding
$ctoEncodingList :: [ProjectTemplate] -> Encoding
toJSONList :: [ProjectTemplate] -> Value
$ctoJSONList :: [ProjectTemplate] -> Value
toEncoding :: ProjectTemplate -> Encoding
$ctoEncoding :: ProjectTemplate -> Encoding
toJSON :: ProjectTemplate -> Value
$ctoJSON :: ProjectTemplate -> Value
ToJSON)

newtype PipelineTrigger = PipelineTrigger {PipelineTrigger -> ConnectionName
connectionName :: ConnectionName}
  deriving (Int -> PipelineTrigger -> ShowS
[PipelineTrigger] -> ShowS
PipelineTrigger -> String
(Int -> PipelineTrigger -> ShowS)
-> (PipelineTrigger -> String)
-> ([PipelineTrigger] -> ShowS)
-> Show PipelineTrigger
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PipelineTrigger] -> ShowS
$cshowList :: [PipelineTrigger] -> ShowS
show :: PipelineTrigger -> String
$cshow :: PipelineTrigger -> String
showsPrec :: Int -> PipelineTrigger -> ShowS
$cshowsPrec :: Int -> PipelineTrigger -> ShowS
Show, Eq PipelineTrigger
Eq PipelineTrigger
-> (PipelineTrigger -> PipelineTrigger -> Ordering)
-> (PipelineTrigger -> PipelineTrigger -> Bool)
-> (PipelineTrigger -> PipelineTrigger -> Bool)
-> (PipelineTrigger -> PipelineTrigger -> Bool)
-> (PipelineTrigger -> PipelineTrigger -> Bool)
-> (PipelineTrigger -> PipelineTrigger -> PipelineTrigger)
-> (PipelineTrigger -> PipelineTrigger -> PipelineTrigger)
-> Ord PipelineTrigger
PipelineTrigger -> PipelineTrigger -> Bool
PipelineTrigger -> PipelineTrigger -> Ordering
PipelineTrigger -> PipelineTrigger -> PipelineTrigger
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 :: PipelineTrigger -> PipelineTrigger -> PipelineTrigger
$cmin :: PipelineTrigger -> PipelineTrigger -> PipelineTrigger
max :: PipelineTrigger -> PipelineTrigger -> PipelineTrigger
$cmax :: PipelineTrigger -> PipelineTrigger -> PipelineTrigger
>= :: PipelineTrigger -> PipelineTrigger -> Bool
$c>= :: PipelineTrigger -> PipelineTrigger -> Bool
> :: PipelineTrigger -> PipelineTrigger -> Bool
$c> :: PipelineTrigger -> PipelineTrigger -> Bool
<= :: PipelineTrigger -> PipelineTrigger -> Bool
$c<= :: PipelineTrigger -> PipelineTrigger -> Bool
< :: PipelineTrigger -> PipelineTrigger -> Bool
$c< :: PipelineTrigger -> PipelineTrigger -> Bool
compare :: PipelineTrigger -> PipelineTrigger -> Ordering
$ccompare :: PipelineTrigger -> PipelineTrigger -> Ordering
Ord, PipelineTrigger -> PipelineTrigger -> Bool
(PipelineTrigger -> PipelineTrigger -> Bool)
-> (PipelineTrigger -> PipelineTrigger -> Bool)
-> Eq PipelineTrigger
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PipelineTrigger -> PipelineTrigger -> Bool
$c/= :: PipelineTrigger -> PipelineTrigger -> Bool
== :: PipelineTrigger -> PipelineTrigger -> Bool
$c== :: PipelineTrigger -> PipelineTrigger -> Bool
Eq, (forall x. PipelineTrigger -> Rep PipelineTrigger x)
-> (forall x. Rep PipelineTrigger x -> PipelineTrigger)
-> Generic PipelineTrigger
forall x. Rep PipelineTrigger x -> PipelineTrigger
forall x. PipelineTrigger -> Rep PipelineTrigger x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PipelineTrigger x -> PipelineTrigger
$cfrom :: forall x. PipelineTrigger -> Rep PipelineTrigger x
Generic)
  deriving newtype (Eq PipelineTrigger
Eq PipelineTrigger
-> (Int -> PipelineTrigger -> Int)
-> (PipelineTrigger -> Int)
-> Hashable PipelineTrigger
Int -> PipelineTrigger -> Int
PipelineTrigger -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: PipelineTrigger -> Int
$chash :: PipelineTrigger -> Int
hashWithSalt :: Int -> PipelineTrigger -> Int
$chashWithSalt :: Int -> PipelineTrigger -> Int
Hashable, Value -> Parser [PipelineTrigger]
Value -> Parser PipelineTrigger
(Value -> Parser PipelineTrigger)
-> (Value -> Parser [PipelineTrigger]) -> FromJSON PipelineTrigger
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [PipelineTrigger]
$cparseJSONList :: Value -> Parser [PipelineTrigger]
parseJSON :: Value -> Parser PipelineTrigger
$cparseJSON :: Value -> Parser PipelineTrigger
FromJSON, [PipelineTrigger] -> Encoding
[PipelineTrigger] -> Value
PipelineTrigger -> Encoding
PipelineTrigger -> Value
(PipelineTrigger -> Value)
-> (PipelineTrigger -> Encoding)
-> ([PipelineTrigger] -> Value)
-> ([PipelineTrigger] -> Encoding)
-> ToJSON PipelineTrigger
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [PipelineTrigger] -> Encoding
$ctoEncodingList :: [PipelineTrigger] -> Encoding
toJSONList :: [PipelineTrigger] -> Value
$ctoJSONList :: [PipelineTrigger] -> Value
toEncoding :: PipelineTrigger -> Encoding
$ctoEncoding :: PipelineTrigger -> Encoding
toJSON :: PipelineTrigger -> Value
$ctoJSON :: PipelineTrigger -> Value
ToJSON)

newtype PipelineReporter = PipelineReporter {PipelineReporter -> ConnectionName
connectionName :: ConnectionName}
  deriving (Int -> PipelineReporter -> ShowS
[PipelineReporter] -> ShowS
PipelineReporter -> String
(Int -> PipelineReporter -> ShowS)
-> (PipelineReporter -> String)
-> ([PipelineReporter] -> ShowS)
-> Show PipelineReporter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PipelineReporter] -> ShowS
$cshowList :: [PipelineReporter] -> ShowS
show :: PipelineReporter -> String
$cshow :: PipelineReporter -> String
showsPrec :: Int -> PipelineReporter -> ShowS
$cshowsPrec :: Int -> PipelineReporter -> ShowS
Show, Eq PipelineReporter
Eq PipelineReporter
-> (PipelineReporter -> PipelineReporter -> Ordering)
-> (PipelineReporter -> PipelineReporter -> Bool)
-> (PipelineReporter -> PipelineReporter -> Bool)
-> (PipelineReporter -> PipelineReporter -> Bool)
-> (PipelineReporter -> PipelineReporter -> Bool)
-> (PipelineReporter -> PipelineReporter -> PipelineReporter)
-> (PipelineReporter -> PipelineReporter -> PipelineReporter)
-> Ord PipelineReporter
PipelineReporter -> PipelineReporter -> Bool
PipelineReporter -> PipelineReporter -> Ordering
PipelineReporter -> PipelineReporter -> PipelineReporter
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 :: PipelineReporter -> PipelineReporter -> PipelineReporter
$cmin :: PipelineReporter -> PipelineReporter -> PipelineReporter
max :: PipelineReporter -> PipelineReporter -> PipelineReporter
$cmax :: PipelineReporter -> PipelineReporter -> PipelineReporter
>= :: PipelineReporter -> PipelineReporter -> Bool
$c>= :: PipelineReporter -> PipelineReporter -> Bool
> :: PipelineReporter -> PipelineReporter -> Bool
$c> :: PipelineReporter -> PipelineReporter -> Bool
<= :: PipelineReporter -> PipelineReporter -> Bool
$c<= :: PipelineReporter -> PipelineReporter -> Bool
< :: PipelineReporter -> PipelineReporter -> Bool
$c< :: PipelineReporter -> PipelineReporter -> Bool
compare :: PipelineReporter -> PipelineReporter -> Ordering
$ccompare :: PipelineReporter -> PipelineReporter -> Ordering
Ord, PipelineReporter -> PipelineReporter -> Bool
(PipelineReporter -> PipelineReporter -> Bool)
-> (PipelineReporter -> PipelineReporter -> Bool)
-> Eq PipelineReporter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PipelineReporter -> PipelineReporter -> Bool
$c/= :: PipelineReporter -> PipelineReporter -> Bool
== :: PipelineReporter -> PipelineReporter -> Bool
$c== :: PipelineReporter -> PipelineReporter -> Bool
Eq, (forall x. PipelineReporter -> Rep PipelineReporter x)
-> (forall x. Rep PipelineReporter x -> PipelineReporter)
-> Generic PipelineReporter
forall x. Rep PipelineReporter x -> PipelineReporter
forall x. PipelineReporter -> Rep PipelineReporter x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PipelineReporter x -> PipelineReporter
$cfrom :: forall x. PipelineReporter -> Rep PipelineReporter x
Generic)
  deriving newtype (Eq PipelineReporter
Eq PipelineReporter
-> (Int -> PipelineReporter -> Int)
-> (PipelineReporter -> Int)
-> Hashable PipelineReporter
Int -> PipelineReporter -> Int
PipelineReporter -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: PipelineReporter -> Int
$chash :: PipelineReporter -> Int
hashWithSalt :: Int -> PipelineReporter -> Int
$chashWithSalt :: Int -> PipelineReporter -> Int
Hashable, Value -> Parser [PipelineReporter]
Value -> Parser PipelineReporter
(Value -> Parser PipelineReporter)
-> (Value -> Parser [PipelineReporter])
-> FromJSON PipelineReporter
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [PipelineReporter]
$cparseJSONList :: Value -> Parser [PipelineReporter]
parseJSON :: Value -> Parser PipelineReporter
$cparseJSON :: Value -> Parser PipelineReporter
FromJSON, [PipelineReporter] -> Encoding
[PipelineReporter] -> Value
PipelineReporter -> Encoding
PipelineReporter -> Value
(PipelineReporter -> Value)
-> (PipelineReporter -> Encoding)
-> ([PipelineReporter] -> Value)
-> ([PipelineReporter] -> Encoding)
-> ToJSON PipelineReporter
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [PipelineReporter] -> Encoding
$ctoEncodingList :: [PipelineReporter] -> Encoding
toJSONList :: [PipelineReporter] -> Value
$ctoJSONList :: [PipelineReporter] -> Value
toEncoding :: PipelineReporter -> Encoding
$ctoEncoding :: PipelineReporter -> Encoding
toJSON :: PipelineReporter -> Value
$ctoJSON :: PipelineReporter -> Value
ToJSON)

data Pipeline = Pipeline
  { Pipeline -> PipelineName
name :: PipelineName,
    Pipeline -> [PipelineTrigger]
triggers :: [PipelineTrigger],
    Pipeline -> [PipelineReporter]
reporters :: [PipelineReporter]
  }
  deriving (Int -> Pipeline -> ShowS
[Pipeline] -> ShowS
Pipeline -> String
(Int -> Pipeline -> ShowS)
-> (Pipeline -> String) -> ([Pipeline] -> ShowS) -> Show Pipeline
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Pipeline] -> ShowS
$cshowList :: [Pipeline] -> ShowS
show :: Pipeline -> String
$cshow :: Pipeline -> String
showsPrec :: Int -> Pipeline -> ShowS
$cshowsPrec :: Int -> Pipeline -> ShowS
Show, Pipeline -> Pipeline -> Bool
(Pipeline -> Pipeline -> Bool)
-> (Pipeline -> Pipeline -> Bool) -> Eq Pipeline
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pipeline -> Pipeline -> Bool
$c/= :: Pipeline -> Pipeline -> Bool
== :: Pipeline -> Pipeline -> Bool
$c== :: Pipeline -> Pipeline -> Bool
Eq, Eq Pipeline
Eq Pipeline
-> (Pipeline -> Pipeline -> Ordering)
-> (Pipeline -> Pipeline -> Bool)
-> (Pipeline -> Pipeline -> Bool)
-> (Pipeline -> Pipeline -> Bool)
-> (Pipeline -> Pipeline -> Bool)
-> (Pipeline -> Pipeline -> Pipeline)
-> (Pipeline -> Pipeline -> Pipeline)
-> Ord Pipeline
Pipeline -> Pipeline -> Bool
Pipeline -> Pipeline -> Ordering
Pipeline -> Pipeline -> Pipeline
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 :: Pipeline -> Pipeline -> Pipeline
$cmin :: Pipeline -> Pipeline -> Pipeline
max :: Pipeline -> Pipeline -> Pipeline
$cmax :: Pipeline -> Pipeline -> Pipeline
>= :: Pipeline -> Pipeline -> Bool
$c>= :: Pipeline -> Pipeline -> Bool
> :: Pipeline -> Pipeline -> Bool
$c> :: Pipeline -> Pipeline -> Bool
<= :: Pipeline -> Pipeline -> Bool
$c<= :: Pipeline -> Pipeline -> Bool
< :: Pipeline -> Pipeline -> Bool
$c< :: Pipeline -> Pipeline -> Bool
compare :: Pipeline -> Pipeline -> Ordering
$ccompare :: Pipeline -> Pipeline -> Ordering
Ord, (forall x. Pipeline -> Rep Pipeline x)
-> (forall x. Rep Pipeline x -> Pipeline) -> Generic Pipeline
forall x. Rep Pipeline x -> Pipeline
forall x. Pipeline -> Rep Pipeline x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Pipeline x -> Pipeline
$cfrom :: forall x. Pipeline -> Rep Pipeline x
Generic, Eq Pipeline
Eq Pipeline
-> (Int -> Pipeline -> Int)
-> (Pipeline -> Int)
-> Hashable Pipeline
Int -> Pipeline -> Int
Pipeline -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Pipeline -> Int
$chash :: Pipeline -> Int
hashWithSalt :: Int -> Pipeline -> Int
$chashWithSalt :: Int -> Pipeline -> Int
Hashable, Value -> Parser [Pipeline]
Value -> Parser Pipeline
(Value -> Parser Pipeline)
-> (Value -> Parser [Pipeline]) -> FromJSON Pipeline
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [Pipeline]
$cparseJSONList :: Value -> Parser [Pipeline]
parseJSON :: Value -> Parser Pipeline
$cparseJSON :: Value -> Parser Pipeline
FromJSON, [Pipeline] -> Encoding
[Pipeline] -> Value
Pipeline -> Encoding
Pipeline -> Value
(Pipeline -> Value)
-> (Pipeline -> Encoding)
-> ([Pipeline] -> Value)
-> ([Pipeline] -> Encoding)
-> ToJSON Pipeline
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [Pipeline] -> Encoding
$ctoEncodingList :: [Pipeline] -> Encoding
toJSONList :: [Pipeline] -> Value
$ctoJSONList :: [Pipeline] -> Value
toEncoding :: Pipeline -> Encoding
$ctoEncoding :: Pipeline -> Encoding
toJSON :: Pipeline -> Value
$ctoJSON :: Pipeline -> Value
ToJSON)

-- | The sum of all the configuration elements.
data ZuulConfigElement
  = ZJob Job
  | ZProject Project
  | ZNodeset Nodeset
  | ZProjectTemplate ProjectTemplate
  | ZPipeline Pipeline
  | ZQueue QueueName
  | ZSemaphore SemaphoreName
  | ZSecret SecretName
  deriving (Int -> ZuulConfigElement -> ShowS
[ZuulConfigElement] -> ShowS
ZuulConfigElement -> String
(Int -> ZuulConfigElement -> ShowS)
-> (ZuulConfigElement -> String)
-> ([ZuulConfigElement] -> ShowS)
-> Show ZuulConfigElement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ZuulConfigElement] -> ShowS
$cshowList :: [ZuulConfigElement] -> ShowS
show :: ZuulConfigElement -> String
$cshow :: ZuulConfigElement -> String
showsPrec :: Int -> ZuulConfigElement -> ShowS
$cshowsPrec :: Int -> ZuulConfigElement -> ShowS
Show, ZuulConfigElement -> ZuulConfigElement -> Bool
(ZuulConfigElement -> ZuulConfigElement -> Bool)
-> (ZuulConfigElement -> ZuulConfigElement -> Bool)
-> Eq ZuulConfigElement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ZuulConfigElement -> ZuulConfigElement -> Bool
$c/= :: ZuulConfigElement -> ZuulConfigElement -> Bool
== :: ZuulConfigElement -> ZuulConfigElement -> Bool
$c== :: ZuulConfigElement -> ZuulConfigElement -> Bool
Eq, Eq ZuulConfigElement
Eq ZuulConfigElement
-> (ZuulConfigElement -> ZuulConfigElement -> Ordering)
-> (ZuulConfigElement -> ZuulConfigElement -> Bool)
-> (ZuulConfigElement -> ZuulConfigElement -> Bool)
-> (ZuulConfigElement -> ZuulConfigElement -> Bool)
-> (ZuulConfigElement -> ZuulConfigElement -> Bool)
-> (ZuulConfigElement -> ZuulConfigElement -> ZuulConfigElement)
-> (ZuulConfigElement -> ZuulConfigElement -> ZuulConfigElement)
-> Ord ZuulConfigElement
ZuulConfigElement -> ZuulConfigElement -> Bool
ZuulConfigElement -> ZuulConfigElement -> Ordering
ZuulConfigElement -> ZuulConfigElement -> ZuulConfigElement
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 :: ZuulConfigElement -> ZuulConfigElement -> ZuulConfigElement
$cmin :: ZuulConfigElement -> ZuulConfigElement -> ZuulConfigElement
max :: ZuulConfigElement -> ZuulConfigElement -> ZuulConfigElement
$cmax :: ZuulConfigElement -> ZuulConfigElement -> ZuulConfigElement
>= :: ZuulConfigElement -> ZuulConfigElement -> Bool
$c>= :: ZuulConfigElement -> ZuulConfigElement -> Bool
> :: ZuulConfigElement -> ZuulConfigElement -> Bool
$c> :: ZuulConfigElement -> ZuulConfigElement -> Bool
<= :: ZuulConfigElement -> ZuulConfigElement -> Bool
$c<= :: ZuulConfigElement -> ZuulConfigElement -> Bool
< :: ZuulConfigElement -> ZuulConfigElement -> Bool
$c< :: ZuulConfigElement -> ZuulConfigElement -> Bool
compare :: ZuulConfigElement -> ZuulConfigElement -> Ordering
$ccompare :: ZuulConfigElement -> ZuulConfigElement -> Ordering
Ord, (forall x. ZuulConfigElement -> Rep ZuulConfigElement x)
-> (forall x. Rep ZuulConfigElement x -> ZuulConfigElement)
-> Generic ZuulConfigElement
forall x. Rep ZuulConfigElement x -> ZuulConfigElement
forall x. ZuulConfigElement -> Rep ZuulConfigElement x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ZuulConfigElement x -> ZuulConfigElement
$cfrom :: forall x. ZuulConfigElement -> Rep ZuulConfigElement x
Generic, Value -> Parser [ZuulConfigElement]
Value -> Parser ZuulConfigElement
(Value -> Parser ZuulConfigElement)
-> (Value -> Parser [ZuulConfigElement])
-> FromJSON ZuulConfigElement
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [ZuulConfigElement]
$cparseJSONList :: Value -> Parser [ZuulConfigElement]
parseJSON :: Value -> Parser ZuulConfigElement
$cparseJSON :: Value -> Parser ZuulConfigElement
FromJSON, [ZuulConfigElement] -> Encoding
[ZuulConfigElement] -> Value
ZuulConfigElement -> Encoding
ZuulConfigElement -> Value
(ZuulConfigElement -> Value)
-> (ZuulConfigElement -> Encoding)
-> ([ZuulConfigElement] -> Value)
-> ([ZuulConfigElement] -> Encoding)
-> ToJSON ZuulConfigElement
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [ZuulConfigElement] -> Encoding
$ctoEncodingList :: [ZuulConfigElement] -> Encoding
toJSONList :: [ZuulConfigElement] -> Value
$ctoJSONList :: [ZuulConfigElement] -> Value
toEncoding :: ZuulConfigElement -> Encoding
$ctoEncoding :: ZuulConfigElement -> Encoding
toJSON :: ZuulConfigElement -> Value
$ctoJSON :: ZuulConfigElement -> Value
ToJSON)

instance From ZuulConfigElement ZuulConfigType where
  from :: ZuulConfigElement -> ZuulConfigType
from ZuulConfigElement
zce = case ZuulConfigElement
zce of
    ZJob Job
_ -> ZuulConfigType
JobT
    ZProject Project
_ -> ZuulConfigType
ProjectT
    ZNodeset Nodeset
_ -> ZuulConfigType
NodesetT
    ZProjectTemplate ProjectTemplate
_ -> ZuulConfigType
ProjectTemplateT
    ZPipeline Pipeline
_ -> ZuulConfigType
PipelineT
    ZQueue QueueName
_ -> ZuulConfigType
QueueT
    ZSemaphore SemaphoreName
_ -> ZuulConfigType
SemaphoreT
    ZSecret SecretName
_ -> ZuulConfigType
SecretT

-- | The sum of all the configuration types.
data ZuulConfigType
  = PipelineT
  | JobT
  | SemaphoreT
  | ProjectT
  | ProjectTemplateT
  | NodesetT
  | SecretT
  | QueueT
  deriving (Int -> ZuulConfigType -> ShowS
[ZuulConfigType] -> ShowS
ZuulConfigType -> String
(Int -> ZuulConfigType -> ShowS)
-> (ZuulConfigType -> String)
-> ([ZuulConfigType] -> ShowS)
-> Show ZuulConfigType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ZuulConfigType] -> ShowS
$cshowList :: [ZuulConfigType] -> ShowS
show :: ZuulConfigType -> String
$cshow :: ZuulConfigType -> String
showsPrec :: Int -> ZuulConfigType -> ShowS
$cshowsPrec :: Int -> ZuulConfigType -> ShowS
Show, ZuulConfigType -> ZuulConfigType -> Bool
(ZuulConfigType -> ZuulConfigType -> Bool)
-> (ZuulConfigType -> ZuulConfigType -> Bool) -> Eq ZuulConfigType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ZuulConfigType -> ZuulConfigType -> Bool
$c/= :: ZuulConfigType -> ZuulConfigType -> Bool
== :: ZuulConfigType -> ZuulConfigType -> Bool
$c== :: ZuulConfigType -> ZuulConfigType -> Bool
Eq, Eq ZuulConfigType
Eq ZuulConfigType
-> (ZuulConfigType -> ZuulConfigType -> Ordering)
-> (ZuulConfigType -> ZuulConfigType -> Bool)
-> (ZuulConfigType -> ZuulConfigType -> Bool)
-> (ZuulConfigType -> ZuulConfigType -> Bool)
-> (ZuulConfigType -> ZuulConfigType -> Bool)
-> (ZuulConfigType -> ZuulConfigType -> ZuulConfigType)
-> (ZuulConfigType -> ZuulConfigType -> ZuulConfigType)
-> Ord ZuulConfigType
ZuulConfigType -> ZuulConfigType -> Bool
ZuulConfigType -> ZuulConfigType -> Ordering
ZuulConfigType -> ZuulConfigType -> ZuulConfigType
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 :: ZuulConfigType -> ZuulConfigType -> ZuulConfigType
$cmin :: ZuulConfigType -> ZuulConfigType -> ZuulConfigType
max :: ZuulConfigType -> ZuulConfigType -> ZuulConfigType
$cmax :: ZuulConfigType -> ZuulConfigType -> ZuulConfigType
>= :: ZuulConfigType -> ZuulConfigType -> Bool
$c>= :: ZuulConfigType -> ZuulConfigType -> Bool
> :: ZuulConfigType -> ZuulConfigType -> Bool
$c> :: ZuulConfigType -> ZuulConfigType -> Bool
<= :: ZuulConfigType -> ZuulConfigType -> Bool
$c<= :: ZuulConfigType -> ZuulConfigType -> Bool
< :: ZuulConfigType -> ZuulConfigType -> Bool
$c< :: ZuulConfigType -> ZuulConfigType -> Bool
compare :: ZuulConfigType -> ZuulConfigType -> Ordering
$ccompare :: ZuulConfigType -> ZuulConfigType -> Ordering
Ord, (forall x. ZuulConfigType -> Rep ZuulConfigType x)
-> (forall x. Rep ZuulConfigType x -> ZuulConfigType)
-> Generic ZuulConfigType
forall x. Rep ZuulConfigType x -> ZuulConfigType
forall x. ZuulConfigType -> Rep ZuulConfigType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ZuulConfigType x -> ZuulConfigType
$cfrom :: forall x. ZuulConfigType -> Rep ZuulConfigType x
Generic, Int -> ZuulConfigType
ZuulConfigType -> Int
ZuulConfigType -> [ZuulConfigType]
ZuulConfigType -> ZuulConfigType
ZuulConfigType -> ZuulConfigType -> [ZuulConfigType]
ZuulConfigType
-> ZuulConfigType -> ZuulConfigType -> [ZuulConfigType]
(ZuulConfigType -> ZuulConfigType)
-> (ZuulConfigType -> ZuulConfigType)
-> (Int -> ZuulConfigType)
-> (ZuulConfigType -> Int)
-> (ZuulConfigType -> [ZuulConfigType])
-> (ZuulConfigType -> ZuulConfigType -> [ZuulConfigType])
-> (ZuulConfigType -> ZuulConfigType -> [ZuulConfigType])
-> (ZuulConfigType
    -> ZuulConfigType -> ZuulConfigType -> [ZuulConfigType])
-> Enum ZuulConfigType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: ZuulConfigType
-> ZuulConfigType -> ZuulConfigType -> [ZuulConfigType]
$cenumFromThenTo :: ZuulConfigType
-> ZuulConfigType -> ZuulConfigType -> [ZuulConfigType]
enumFromTo :: ZuulConfigType -> ZuulConfigType -> [ZuulConfigType]
$cenumFromTo :: ZuulConfigType -> ZuulConfigType -> [ZuulConfigType]
enumFromThen :: ZuulConfigType -> ZuulConfigType -> [ZuulConfigType]
$cenumFromThen :: ZuulConfigType -> ZuulConfigType -> [ZuulConfigType]
enumFrom :: ZuulConfigType -> [ZuulConfigType]
$cenumFrom :: ZuulConfigType -> [ZuulConfigType]
fromEnum :: ZuulConfigType -> Int
$cfromEnum :: ZuulConfigType -> Int
toEnum :: Int -> ZuulConfigType
$ctoEnum :: Int -> ZuulConfigType
pred :: ZuulConfigType -> ZuulConfigType
$cpred :: ZuulConfigType -> ZuulConfigType
succ :: ZuulConfigType -> ZuulConfigType
$csucc :: ZuulConfigType -> ZuulConfigType
Enum, ZuulConfigType
ZuulConfigType -> ZuulConfigType -> Bounded ZuulConfigType
forall a. a -> a -> Bounded a
maxBound :: ZuulConfigType
$cmaxBound :: ZuulConfigType
minBound :: ZuulConfigType
$cminBound :: ZuulConfigType
Bounded, Value -> Parser [ZuulConfigType]
Value -> Parser ZuulConfigType
(Value -> Parser ZuulConfigType)
-> (Value -> Parser [ZuulConfigType]) -> FromJSON ZuulConfigType
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [ZuulConfigType]
$cparseJSONList :: Value -> Parser [ZuulConfigType]
parseJSON :: Value -> Parser ZuulConfigType
$cparseJSON :: Value -> Parser ZuulConfigType
FromJSON, [ZuulConfigType] -> Encoding
[ZuulConfigType] -> Value
ZuulConfigType -> Encoding
ZuulConfigType -> Value
(ZuulConfigType -> Value)
-> (ZuulConfigType -> Encoding)
-> ([ZuulConfigType] -> Value)
-> ([ZuulConfigType] -> Encoding)
-> ToJSON ZuulConfigType
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [ZuulConfigType] -> Encoding
$ctoEncodingList :: [ZuulConfigType] -> Encoding
toJSONList :: [ZuulConfigType] -> Value
$ctoJSONList :: [ZuulConfigType] -> Value
toEncoding :: ZuulConfigType -> Encoding
$ctoEncoding :: ZuulConfigType -> Encoding
toJSON :: ZuulConfigType -> Value
$ctoJSON :: ZuulConfigType -> Value
ToJSON)

-- | The configuration source context location
data ConfigLoc = ConfigLoc
  { ConfigLoc -> CanonicalProjectName
project :: CanonicalProjectName,
    ConfigLoc -> BranchName
branch :: BranchName,
    ConfigLoc -> FilePathT
path :: FilePathT,
    ConfigLoc -> ConnectionUrl
url :: ConnectionUrl,
    ConfigLoc -> Set TenantName
tenants :: Set TenantName
  }
  deriving (Int -> ConfigLoc -> ShowS
[ConfigLoc] -> ShowS
ConfigLoc -> String
(Int -> ConfigLoc -> ShowS)
-> (ConfigLoc -> String)
-> ([ConfigLoc] -> ShowS)
-> Show ConfigLoc
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConfigLoc] -> ShowS
$cshowList :: [ConfigLoc] -> ShowS
show :: ConfigLoc -> String
$cshow :: ConfigLoc -> String
showsPrec :: Int -> ConfigLoc -> ShowS
$cshowsPrec :: Int -> ConfigLoc -> ShowS
Show, ConfigLoc -> ConfigLoc -> Bool
(ConfigLoc -> ConfigLoc -> Bool)
-> (ConfigLoc -> ConfigLoc -> Bool) -> Eq ConfigLoc
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConfigLoc -> ConfigLoc -> Bool
$c/= :: ConfigLoc -> ConfigLoc -> Bool
== :: ConfigLoc -> ConfigLoc -> Bool
$c== :: ConfigLoc -> ConfigLoc -> Bool
Eq, Eq ConfigLoc
Eq ConfigLoc
-> (ConfigLoc -> ConfigLoc -> Ordering)
-> (ConfigLoc -> ConfigLoc -> Bool)
-> (ConfigLoc -> ConfigLoc -> Bool)
-> (ConfigLoc -> ConfigLoc -> Bool)
-> (ConfigLoc -> ConfigLoc -> Bool)
-> (ConfigLoc -> ConfigLoc -> ConfigLoc)
-> (ConfigLoc -> ConfigLoc -> ConfigLoc)
-> Ord ConfigLoc
ConfigLoc -> ConfigLoc -> Bool
ConfigLoc -> ConfigLoc -> Ordering
ConfigLoc -> ConfigLoc -> ConfigLoc
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 :: ConfigLoc -> ConfigLoc -> ConfigLoc
$cmin :: ConfigLoc -> ConfigLoc -> ConfigLoc
max :: ConfigLoc -> ConfigLoc -> ConfigLoc
$cmax :: ConfigLoc -> ConfigLoc -> ConfigLoc
>= :: ConfigLoc -> ConfigLoc -> Bool
$c>= :: ConfigLoc -> ConfigLoc -> Bool
> :: ConfigLoc -> ConfigLoc -> Bool
$c> :: ConfigLoc -> ConfigLoc -> Bool
<= :: ConfigLoc -> ConfigLoc -> Bool
$c<= :: ConfigLoc -> ConfigLoc -> Bool
< :: ConfigLoc -> ConfigLoc -> Bool
$c< :: ConfigLoc -> ConfigLoc -> Bool
compare :: ConfigLoc -> ConfigLoc -> Ordering
$ccompare :: ConfigLoc -> ConfigLoc -> Ordering
Ord, (forall x. ConfigLoc -> Rep ConfigLoc x)
-> (forall x. Rep ConfigLoc x -> ConfigLoc) -> Generic ConfigLoc
forall x. Rep ConfigLoc x -> ConfigLoc
forall x. ConfigLoc -> Rep ConfigLoc x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ConfigLoc x -> ConfigLoc
$cfrom :: forall x. ConfigLoc -> Rep ConfigLoc x
Generic, Value -> Parser [ConfigLoc]
Value -> Parser ConfigLoc
(Value -> Parser ConfigLoc)
-> (Value -> Parser [ConfigLoc]) -> FromJSON ConfigLoc
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [ConfigLoc]
$cparseJSONList :: Value -> Parser [ConfigLoc]
parseJSON :: Value -> Parser ConfigLoc
$cparseJSON :: Value -> Parser ConfigLoc
FromJSON, [ConfigLoc] -> Encoding
[ConfigLoc] -> Value
ConfigLoc -> Encoding
ConfigLoc -> Value
(ConfigLoc -> Value)
-> (ConfigLoc -> Encoding)
-> ([ConfigLoc] -> Value)
-> ([ConfigLoc] -> Encoding)
-> ToJSON ConfigLoc
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [ConfigLoc] -> Encoding
$ctoEncodingList :: [ConfigLoc] -> Encoding
toJSONList :: [ConfigLoc] -> Value
$ctoJSONList :: [ConfigLoc] -> Value
toEncoding :: ConfigLoc -> Encoding
$ctoEncoding :: ConfigLoc -> Encoding
toJSON :: ConfigLoc -> Value
$ctoJSON :: ConfigLoc -> Value
ToJSON)

instance From ConfigLoc CanonicalProjectName where
  from :: ConfigLoc -> CanonicalProjectName
from ConfigLoc
loc = ConfigLoc
loc.project