-- |
-- Module: PowerDNS.API.Zones
-- Description: Zones endpoints for PowerDNS API
--
-- Implementation of the API endpoints described at [PowerDNS Zones API](https://doc.powerdns.com/authoritative/http-api/zone.html)

{-# LANGUAGE DataKinds          #-}
{-# LANGUAGE DeriveAnyClass     #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric      #-}
{-# LANGUAGE TypeOperators      #-}
{-# LANGUAGE OverloadedStrings  #-}
{-# LANGUAGE TemplateHaskell  #-}
module PowerDNS.API.Zones
  (
  -- * API
    ZonesAPI(..)

  -- * Data types
  , Zone(..)
  , Kind(..)
  , RRSets(..)
  , RRSet(..)
  , Record(..)
  , Comment(..)
  , ChangeType(..)
  , RecordType(..)

  -- * Utilities
  , CIText
  , Result(..)
  , mkCIText
  , original
  , caseFolded
  )
where

import           Data.Char (ord, toUpper)
import           Data.Data (Data)
import           Data.Function (on)
import           Data.String (IsString(..))
import           Data.Word (Word32)
import           GHC.Base (unsafeChr)
import           Text.Read (readPrec)

import           Control.DeepSeq (NFData(..), deepseq)
import           Data.Aeson.TH (allNullaryToStringTag,
                                constructorTagModifier, defaultOptions,
                                fieldLabelModifier,
                                deriveJSON, omitNothingFields)
import           Data.Aeson (FromJSON(..), ToJSON(..), object, (.:), (.=), withObject)
import           Data.Hashable (Hashable(..))
import qualified Data.Text as T
import           Data.Time.Clock.POSIX (POSIXTime)
import           Servant.API
import           Servant.API.Generic

import           PowerDNS.Internal.Utils (Empty(..), strip)

----------------------------------------------------------------------------------------

-- | Record according to [PowerDNS Documentation](https://doc.powerdns.com/authoritative/http-api/zone.html#record)
data Record = Record
  { Record -> Text
record_content :: T.Text
  , Record -> Bool
record_disabled :: Bool
  } deriving (Record -> Record -> Bool
(Record -> Record -> Bool)
-> (Record -> Record -> Bool) -> Eq Record
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Record -> Record -> Bool
== :: Record -> Record -> Bool
$c/= :: Record -> Record -> Bool
/= :: Record -> Record -> Bool
Eq, Eq Record
Eq Record
-> (Record -> Record -> Ordering)
-> (Record -> Record -> Bool)
-> (Record -> Record -> Bool)
-> (Record -> Record -> Bool)
-> (Record -> Record -> Bool)
-> (Record -> Record -> Record)
-> (Record -> Record -> Record)
-> Ord Record
Record -> Record -> Bool
Record -> Record -> Ordering
Record -> Record -> Record
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Record -> Record -> Ordering
compare :: Record -> Record -> Ordering
$c< :: Record -> Record -> Bool
< :: Record -> Record -> Bool
$c<= :: Record -> Record -> Bool
<= :: Record -> Record -> Bool
$c> :: Record -> Record -> Bool
> :: Record -> Record -> Bool
$c>= :: Record -> Record -> Bool
>= :: Record -> Record -> Bool
$cmax :: Record -> Record -> Record
max :: Record -> Record -> Record
$cmin :: Record -> Record -> Record
min :: Record -> Record -> Record
Ord, Int -> Record -> ShowS
[Record] -> ShowS
Record -> String
(Int -> Record -> ShowS)
-> (Record -> String) -> ([Record] -> ShowS) -> Show Record
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Record -> ShowS
showsPrec :: Int -> Record -> ShowS
$cshow :: Record -> String
show :: Record -> String
$cshowList :: [Record] -> ShowS
showList :: [Record] -> ShowS
Show, (forall x. Record -> Rep Record x)
-> (forall x. Rep Record x -> Record) -> Generic Record
forall x. Rep Record x -> Record
forall x. Record -> Rep Record x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Record -> Rep Record x
from :: forall x. Record -> Rep Record x
$cto :: forall x. Rep Record x -> Record
to :: forall x. Rep Record x -> Record
Generic, Record -> ()
(Record -> ()) -> NFData Record
forall a. (a -> ()) -> NFData a
$crnf :: Record -> ()
rnf :: Record -> ()
NFData, Typeable Record
Typeable Record
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Record -> c Record)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Record)
-> (Record -> Constr)
-> (Record -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Record))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Record))
-> ((forall b. Data b => b -> b) -> Record -> Record)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Record -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Record -> r)
-> (forall u. (forall d. Data d => d -> u) -> Record -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Record -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Record -> m Record)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Record -> m Record)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Record -> m Record)
-> Data Record
Record -> Constr
Record -> DataType
(forall b. Data b => b -> b) -> Record -> Record
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Record -> u
forall u. (forall d. Data d => d -> u) -> Record -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Record -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Record -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Record -> m Record
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Record -> m Record
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Record
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Record -> c Record
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Record)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Record)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Record -> c Record
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Record -> c Record
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Record
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Record
$ctoConstr :: Record -> Constr
toConstr :: Record -> Constr
$cdataTypeOf :: Record -> DataType
dataTypeOf :: Record -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Record)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Record)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Record)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Record)
$cgmapT :: (forall b. Data b => b -> b) -> Record -> Record
gmapT :: (forall b. Data b => b -> b) -> Record -> Record
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Record -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Record -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Record -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Record -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Record -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Record -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Record -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Record -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Record -> m Record
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Record -> m Record
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Record -> m Record
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Record -> m Record
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Record -> m Record
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Record -> m Record
Data)

$(deriveJSON defaultOptions { fieldLabelModifier = strip "record_"
                            , omitNothingFields = True } ''Record)


----------------------------------------------------------------------------------------

-- | Comment according to [PowerDNS Documentation](https://doc.powerdns.com/authoritative/http-api/zone.html#comment)
data Comment = Comment
  { Comment -> Maybe Text
comment_content :: Maybe T.Text
  , Comment -> Maybe Text
comment_account :: Maybe T.Text
  , Comment -> Maybe POSIXTime
comment_modified_at :: Maybe POSIXTime
  } deriving (Comment -> Comment -> Bool
(Comment -> Comment -> Bool)
-> (Comment -> Comment -> Bool) -> Eq Comment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Comment -> Comment -> Bool
== :: Comment -> Comment -> Bool
$c/= :: Comment -> Comment -> Bool
/= :: Comment -> Comment -> Bool
Eq, Eq Comment
Eq Comment
-> (Comment -> Comment -> Ordering)
-> (Comment -> Comment -> Bool)
-> (Comment -> Comment -> Bool)
-> (Comment -> Comment -> Bool)
-> (Comment -> Comment -> Bool)
-> (Comment -> Comment -> Comment)
-> (Comment -> Comment -> Comment)
-> Ord Comment
Comment -> Comment -> Bool
Comment -> Comment -> Ordering
Comment -> Comment -> Comment
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Comment -> Comment -> Ordering
compare :: Comment -> Comment -> Ordering
$c< :: Comment -> Comment -> Bool
< :: Comment -> Comment -> Bool
$c<= :: Comment -> Comment -> Bool
<= :: Comment -> Comment -> Bool
$c> :: Comment -> Comment -> Bool
> :: Comment -> Comment -> Bool
$c>= :: Comment -> Comment -> Bool
>= :: Comment -> Comment -> Bool
$cmax :: Comment -> Comment -> Comment
max :: Comment -> Comment -> Comment
$cmin :: Comment -> Comment -> Comment
min :: Comment -> Comment -> Comment
Ord, Int -> Comment -> ShowS
[Comment] -> ShowS
Comment -> String
(Int -> Comment -> ShowS)
-> (Comment -> String) -> ([Comment] -> ShowS) -> Show Comment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Comment -> ShowS
showsPrec :: Int -> Comment -> ShowS
$cshow :: Comment -> String
show :: Comment -> String
$cshowList :: [Comment] -> ShowS
showList :: [Comment] -> ShowS
Show, (forall x. Comment -> Rep Comment x)
-> (forall x. Rep Comment x -> Comment) -> Generic Comment
forall x. Rep Comment x -> Comment
forall x. Comment -> Rep Comment x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Comment -> Rep Comment x
from :: forall x. Comment -> Rep Comment x
$cto :: forall x. Rep Comment x -> Comment
to :: forall x. Rep Comment x -> Comment
Generic, Comment -> ()
(Comment -> ()) -> NFData Comment
forall a. (a -> ()) -> NFData a
$crnf :: Comment -> ()
rnf :: Comment -> ()
NFData, Typeable Comment
Typeable Comment
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Comment -> c Comment)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Comment)
-> (Comment -> Constr)
-> (Comment -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Comment))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Comment))
-> ((forall b. Data b => b -> b) -> Comment -> Comment)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Comment -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Comment -> r)
-> (forall u. (forall d. Data d => d -> u) -> Comment -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Comment -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Comment -> m Comment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Comment -> m Comment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Comment -> m Comment)
-> Data Comment
Comment -> Constr
Comment -> DataType
(forall b. Data b => b -> b) -> Comment -> Comment
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Comment -> u
forall u. (forall d. Data d => d -> u) -> Comment -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Comment
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Comment -> c Comment
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Comment)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Comment)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Comment -> c Comment
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Comment -> c Comment
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Comment
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Comment
$ctoConstr :: Comment -> Constr
toConstr :: Comment -> Constr
$cdataTypeOf :: Comment -> DataType
dataTypeOf :: Comment -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Comment)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Comment)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Comment)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Comment)
$cgmapT :: (forall b. Data b => b -> b) -> Comment -> Comment
gmapT :: (forall b. Data b => b -> b) -> Comment -> Comment
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Comment -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Comment -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Comment -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Comment -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
Data, Comment
Comment -> Empty Comment
forall a. a -> Empty a
$cempty :: Comment
empty :: Comment
Empty)

$(deriveJSON defaultOptions { fieldLabelModifier = strip "comment_" } ''Comment)

----------------------------------------------------------------------------------------

-- | Whether or not an 'RRSet' replace or delete an existing entry.
-- If the 'ChangeType' is left at @Nothing@ it will create a new domain entry.
data ChangeType = Replace
                | Delete
                deriving (ChangeType -> ChangeType -> Bool
(ChangeType -> ChangeType -> Bool)
-> (ChangeType -> ChangeType -> Bool) -> Eq ChangeType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ChangeType -> ChangeType -> Bool
== :: ChangeType -> ChangeType -> Bool
$c/= :: ChangeType -> ChangeType -> Bool
/= :: ChangeType -> ChangeType -> Bool
Eq, Eq ChangeType
Eq ChangeType
-> (ChangeType -> ChangeType -> Ordering)
-> (ChangeType -> ChangeType -> Bool)
-> (ChangeType -> ChangeType -> Bool)
-> (ChangeType -> ChangeType -> Bool)
-> (ChangeType -> ChangeType -> Bool)
-> (ChangeType -> ChangeType -> ChangeType)
-> (ChangeType -> ChangeType -> ChangeType)
-> Ord ChangeType
ChangeType -> ChangeType -> Bool
ChangeType -> ChangeType -> Ordering
ChangeType -> ChangeType -> ChangeType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ChangeType -> ChangeType -> Ordering
compare :: ChangeType -> ChangeType -> Ordering
$c< :: ChangeType -> ChangeType -> Bool
< :: ChangeType -> ChangeType -> Bool
$c<= :: ChangeType -> ChangeType -> Bool
<= :: ChangeType -> ChangeType -> Bool
$c> :: ChangeType -> ChangeType -> Bool
> :: ChangeType -> ChangeType -> Bool
$c>= :: ChangeType -> ChangeType -> Bool
>= :: ChangeType -> ChangeType -> Bool
$cmax :: ChangeType -> ChangeType -> ChangeType
max :: ChangeType -> ChangeType -> ChangeType
$cmin :: ChangeType -> ChangeType -> ChangeType
min :: ChangeType -> ChangeType -> ChangeType
Ord, Int -> ChangeType -> ShowS
[ChangeType] -> ShowS
ChangeType -> String
(Int -> ChangeType -> ShowS)
-> (ChangeType -> String)
-> ([ChangeType] -> ShowS)
-> Show ChangeType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ChangeType -> ShowS
showsPrec :: Int -> ChangeType -> ShowS
$cshow :: ChangeType -> String
show :: ChangeType -> String
$cshowList :: [ChangeType] -> ShowS
showList :: [ChangeType] -> ShowS
Show, (forall x. ChangeType -> Rep ChangeType x)
-> (forall x. Rep ChangeType x -> ChangeType) -> Generic ChangeType
forall x. Rep ChangeType x -> ChangeType
forall x. ChangeType -> Rep ChangeType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ChangeType -> Rep ChangeType x
from :: forall x. ChangeType -> Rep ChangeType x
$cto :: forall x. Rep ChangeType x -> ChangeType
to :: forall x. Rep ChangeType x -> ChangeType
Generic, ChangeType -> ()
(ChangeType -> ()) -> NFData ChangeType
forall a. (a -> ()) -> NFData a
$crnf :: ChangeType -> ()
rnf :: ChangeType -> ()
NFData, Typeable ChangeType
Typeable ChangeType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ChangeType -> c ChangeType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ChangeType)
-> (ChangeType -> Constr)
-> (ChangeType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ChangeType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ChangeType))
-> ((forall b. Data b => b -> b) -> ChangeType -> ChangeType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ChangeType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ChangeType -> r)
-> (forall u. (forall d. Data d => d -> u) -> ChangeType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ChangeType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ChangeType -> m ChangeType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ChangeType -> m ChangeType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ChangeType -> m ChangeType)
-> Data ChangeType
ChangeType -> Constr
ChangeType -> DataType
(forall b. Data b => b -> b) -> ChangeType -> ChangeType
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ChangeType -> u
forall u. (forall d. Data d => d -> u) -> ChangeType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChangeType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChangeType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChangeType -> m ChangeType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChangeType -> m ChangeType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChangeType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChangeType -> c ChangeType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChangeType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ChangeType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChangeType -> c ChangeType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChangeType -> c ChangeType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChangeType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChangeType
$ctoConstr :: ChangeType -> Constr
toConstr :: ChangeType -> Constr
$cdataTypeOf :: ChangeType -> DataType
dataTypeOf :: ChangeType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChangeType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChangeType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ChangeType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ChangeType)
$cgmapT :: (forall b. Data b => b -> b) -> ChangeType -> ChangeType
gmapT :: (forall b. Data b => b -> b) -> ChangeType -> ChangeType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChangeType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChangeType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChangeType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChangeType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ChangeType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ChangeType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ChangeType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ChangeType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChangeType -> m ChangeType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChangeType -> m ChangeType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChangeType -> m ChangeType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChangeType -> m ChangeType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChangeType -> m ChangeType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChangeType -> m ChangeType
Data)

$(deriveJSON defaultOptions { constructorTagModifier = fmap toUpper
                            , allNullaryToStringTag = True } ''ChangeType)



----------------------------------------------------------------------------------------

data RecordType = A
                | AAAA
                | AFSDB
                | ALIAS
                | APL
                | CAA
                | CERT
                | CDNSKEY
                | CDS
                | CNAME
                | DNSKEY
                | DNAME
                | DS
                | HINFO
                | KEY
                | LOC
                | MX
                | NAPTR
                | NS
                | NSEC
                | NSEC3
                | NSEC3PARAM
                | OPENPGPKEY
                | PTR
                | RP
                | RRSIG
                | SOA
                | SPF
                | SSHFP
                | SRV
                | TKEY
                | TSIG
                | TLSA
                | SMIMEA
                | TXT
                | URI
                | A6
                | DHCID
                | DLV
                | EUI48
                | EUI64
                | IPSECKEY
                | KX
                | MAILA
                | MAILB
                | MINFO
                | MR
                | RKEY
                | SIG
                | WKS
                deriving (RecordType -> RecordType -> Bool
(RecordType -> RecordType -> Bool)
-> (RecordType -> RecordType -> Bool) -> Eq RecordType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RecordType -> RecordType -> Bool
== :: RecordType -> RecordType -> Bool
$c/= :: RecordType -> RecordType -> Bool
/= :: RecordType -> RecordType -> Bool
Eq, Eq RecordType
Eq RecordType
-> (RecordType -> RecordType -> Ordering)
-> (RecordType -> RecordType -> Bool)
-> (RecordType -> RecordType -> Bool)
-> (RecordType -> RecordType -> Bool)
-> (RecordType -> RecordType -> Bool)
-> (RecordType -> RecordType -> RecordType)
-> (RecordType -> RecordType -> RecordType)
-> Ord RecordType
RecordType -> RecordType -> Bool
RecordType -> RecordType -> Ordering
RecordType -> RecordType -> RecordType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RecordType -> RecordType -> Ordering
compare :: RecordType -> RecordType -> Ordering
$c< :: RecordType -> RecordType -> Bool
< :: RecordType -> RecordType -> Bool
$c<= :: RecordType -> RecordType -> Bool
<= :: RecordType -> RecordType -> Bool
$c> :: RecordType -> RecordType -> Bool
> :: RecordType -> RecordType -> Bool
$c>= :: RecordType -> RecordType -> Bool
>= :: RecordType -> RecordType -> Bool
$cmax :: RecordType -> RecordType -> RecordType
max :: RecordType -> RecordType -> RecordType
$cmin :: RecordType -> RecordType -> RecordType
min :: RecordType -> RecordType -> RecordType
Ord, Int -> RecordType -> ShowS
[RecordType] -> ShowS
RecordType -> String
(Int -> RecordType -> ShowS)
-> (RecordType -> String)
-> ([RecordType] -> ShowS)
-> Show RecordType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RecordType -> ShowS
showsPrec :: Int -> RecordType -> ShowS
$cshow :: RecordType -> String
show :: RecordType -> String
$cshowList :: [RecordType] -> ShowS
showList :: [RecordType] -> ShowS
Show, (forall x. RecordType -> Rep RecordType x)
-> (forall x. Rep RecordType x -> RecordType) -> Generic RecordType
forall x. Rep RecordType x -> RecordType
forall x. RecordType -> Rep RecordType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RecordType -> Rep RecordType x
from :: forall x. RecordType -> Rep RecordType x
$cto :: forall x. Rep RecordType x -> RecordType
to :: forall x. Rep RecordType x -> RecordType
Generic, RecordType -> ()
(RecordType -> ()) -> NFData RecordType
forall a. (a -> ()) -> NFData a
$crnf :: RecordType -> ()
rnf :: RecordType -> ()
NFData, Typeable RecordType
Typeable RecordType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RecordType -> c RecordType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RecordType)
-> (RecordType -> Constr)
-> (RecordType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RecordType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RecordType))
-> ((forall b. Data b => b -> b) -> RecordType -> RecordType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RecordType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RecordType -> r)
-> (forall u. (forall d. Data d => d -> u) -> RecordType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RecordType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RecordType -> m RecordType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RecordType -> m RecordType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RecordType -> m RecordType)
-> Data RecordType
RecordType -> Constr
RecordType -> DataType
(forall b. Data b => b -> b) -> RecordType -> RecordType
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RecordType -> u
forall u. (forall d. Data d => d -> u) -> RecordType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RecordType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RecordType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RecordType -> m RecordType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RecordType -> m RecordType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RecordType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RecordType -> c RecordType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RecordType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RecordType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RecordType -> c RecordType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RecordType -> c RecordType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RecordType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RecordType
$ctoConstr :: RecordType -> Constr
toConstr :: RecordType -> Constr
$cdataTypeOf :: RecordType -> DataType
dataTypeOf :: RecordType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RecordType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RecordType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RecordType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RecordType)
$cgmapT :: (forall b. Data b => b -> b) -> RecordType -> RecordType
gmapT :: (forall b. Data b => b -> b) -> RecordType -> RecordType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RecordType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RecordType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RecordType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RecordType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RecordType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RecordType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RecordType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RecordType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RecordType -> m RecordType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RecordType -> m RecordType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RecordType -> m RecordType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RecordType -> m RecordType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RecordType -> m RecordType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RecordType -> m RecordType
Data)

$(deriveJSON defaultOptions { allNullaryToStringTag = True
                            } ''RecordType)


----------------------------------------------------------------------------------------

-- | A wrapper for 'T.Text' implementing limited case-sensitivity as per [RFC4343](https://datatracker.ietf.org/doc/html/rfc4343).
-- Use 'mkCIText' for construction.
--
-- See 'original' and 'caseFolded' for extracting a 'T.Text' back.

data CIText = CIText { CIText -> Text
ciOriginal :: T.Text, CIText -> Text
ciCaseFolded :: T.Text } deriving Typeable CIText
Typeable CIText
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CIText -> c CIText)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CIText)
-> (CIText -> Constr)
-> (CIText -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CIText))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CIText))
-> ((forall b. Data b => b -> b) -> CIText -> CIText)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CIText -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CIText -> r)
-> (forall u. (forall d. Data d => d -> u) -> CIText -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CIText -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CIText -> m CIText)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CIText -> m CIText)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CIText -> m CIText)
-> Data CIText
CIText -> Constr
CIText -> DataType
(forall b. Data b => b -> b) -> CIText -> CIText
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CIText -> u
forall u. (forall d. Data d => d -> u) -> CIText -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CIText -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CIText -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CIText -> m CIText
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CIText -> m CIText
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CIText
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CIText -> c CIText
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CIText)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CIText)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CIText -> c CIText
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CIText -> c CIText
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CIText
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CIText
$ctoConstr :: CIText -> Constr
toConstr :: CIText -> Constr
$cdataTypeOf :: CIText -> DataType
dataTypeOf :: CIText -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CIText)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CIText)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CIText)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CIText)
$cgmapT :: (forall b. Data b => b -> b) -> CIText -> CIText
gmapT :: (forall b. Data b => b -> b) -> CIText -> CIText
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CIText -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CIText -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CIText -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CIText -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CIText -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CIText -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CIText -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CIText -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CIText -> m CIText
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CIText -> m CIText
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CIText -> m CIText
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CIText -> m CIText
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CIText -> m CIText
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CIText -> m CIText
Data

-- | Obtain the original 'T.Text' from a 'CIText'.
original :: CIText -> T.Text
original :: CIText -> Text
original = CIText -> Text
ciOriginal

-- | Obtain a [RFC4343](https://datatracker.ietf.org/doc/html/rfc4343) case-folded 'T.Text' from a 'CIText'.
caseFolded :: CIText -> T.Text
caseFolded :: CIText -> Text
caseFolded = CIText -> Text
ciCaseFolded

-- | Smart constructor for 'CIText'.
mkCIText :: T.Text -> CIText
mkCIText :: Text -> CIText
mkCIText Text
s = Text -> Text -> CIText
CIText Text
s ((Char -> Char) -> Text -> Text
T.map Char -> Char
foldCase Text
s)

instance IsString CIText where
  fromString :: String -> CIText
fromString = Text -> CIText
mkCIText (Text -> CIText) -> (String -> Text) -> String -> CIText
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
forall a. IsString a => String -> a
fromString

instance Semigroup CIText where
  CIText Text
o1 Text
f1 <> :: CIText -> CIText -> CIText
<> CIText Text
o2 Text
f2 = Text -> Text -> CIText
CIText (Text
o1 Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
o2) (Text
f1 Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
f2)

instance Monoid CIText where
  mempty :: CIText
mempty = Text -> Text -> CIText
CIText Text
forall a. Monoid a => a
mempty Text
forall a. Monoid a => a
mempty

instance Read CIText where
  readPrec :: ReadPrec CIText
readPrec = (Text -> CIText) -> ReadPrec Text -> ReadPrec CIText
forall a b. (a -> b) -> ReadPrec a -> ReadPrec b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> CIText
mkCIText ReadPrec Text
forall a. Read a => ReadPrec a
readPrec

instance Show CIText where
  showsPrec :: Int -> CIText -> ShowS
showsPrec Int
p = Int -> Text -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
p (Text -> ShowS) -> (CIText -> Text) -> CIText -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CIText -> Text
ciOriginal

instance Ord CIText where
  compare :: CIText -> CIText -> Ordering
compare = Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Text -> Text -> Ordering)
-> (CIText -> Text) -> CIText -> CIText -> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` CIText -> Text
ciCaseFolded

instance Eq CIText where
  == :: CIText -> CIText -> Bool
(==) = Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
(==) (Text -> Text -> Bool)
-> (CIText -> Text) -> CIText -> CIText -> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` CIText -> Text
ciCaseFolded

instance ToJSON CIText where
  toJSON :: CIText -> Value
toJSON = Text -> Value
forall a. ToJSON a => a -> Value
toJSON (Text -> Value) -> (CIText -> Text) -> CIText -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CIText -> Text
ciOriginal

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

instance Hashable CIText where
  hashWithSalt :: Int -> CIText -> Int
hashWithSalt Int
s = Int -> Text -> Int
forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
s (Text -> Int) -> (CIText -> Text) -> CIText -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CIText -> Text
ciCaseFolded

instance NFData CIText where
    rnf :: CIText -> ()
rnf (CIText Text
o Text
f) = Text
o Text -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq` Text
f Text -> () -> ()
forall a b. NFData a => a -> b -> b
`deepseq` ()

{-# INLINE foldCase #-}
foldCase :: Char -> Char
foldCase :: Char -> Char
foldCase Char
x | Int
x' <- Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Char -> Int
ord Char
x)
           , Int
x' Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0x41
           , Int
x' Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0x5A
           = Int -> Char
unsafeChr (Int
x' Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
32)

           | Bool
otherwise
           = Char
x

----------------------------------------------------------------------------------------

-- | RRSet according to [PowerDNS Documentation](https://doc.powerdns.com/authoritative/http-api/zone.html#rrset).
--
-- Note that 'Eq' and 'Ord' use limited case-sensitivity on 'rrset_name' as per [RFC4343](https://datatracker.ietf.org/doc/html/rfc4343)
data RRSet = RRSet
  { RRSet -> CIText
rrset_name :: CIText
  , RRSet -> RecordType
rrset_type :: RecordType
  , RRSet -> Maybe Word32
rrset_ttl :: Maybe Word32
  , RRSet -> Maybe ChangeType
rrset_changetype :: Maybe ChangeType
  , RRSet -> Maybe [Record]
rrset_records :: Maybe [Record]
  , RRSet -> Maybe [Comment]
rrset_comments :: Maybe [Comment]
  } deriving (RRSet -> RRSet -> Bool
(RRSet -> RRSet -> Bool) -> (RRSet -> RRSet -> Bool) -> Eq RRSet
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RRSet -> RRSet -> Bool
== :: RRSet -> RRSet -> Bool
$c/= :: RRSet -> RRSet -> Bool
/= :: RRSet -> RRSet -> Bool
Eq, Eq RRSet
Eq RRSet
-> (RRSet -> RRSet -> Ordering)
-> (RRSet -> RRSet -> Bool)
-> (RRSet -> RRSet -> Bool)
-> (RRSet -> RRSet -> Bool)
-> (RRSet -> RRSet -> Bool)
-> (RRSet -> RRSet -> RRSet)
-> (RRSet -> RRSet -> RRSet)
-> Ord RRSet
RRSet -> RRSet -> Bool
RRSet -> RRSet -> Ordering
RRSet -> RRSet -> RRSet
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RRSet -> RRSet -> Ordering
compare :: RRSet -> RRSet -> Ordering
$c< :: RRSet -> RRSet -> Bool
< :: RRSet -> RRSet -> Bool
$c<= :: RRSet -> RRSet -> Bool
<= :: RRSet -> RRSet -> Bool
$c> :: RRSet -> RRSet -> Bool
> :: RRSet -> RRSet -> Bool
$c>= :: RRSet -> RRSet -> Bool
>= :: RRSet -> RRSet -> Bool
$cmax :: RRSet -> RRSet -> RRSet
max :: RRSet -> RRSet -> RRSet
$cmin :: RRSet -> RRSet -> RRSet
min :: RRSet -> RRSet -> RRSet
Ord, Int -> RRSet -> ShowS
[RRSet] -> ShowS
RRSet -> String
(Int -> RRSet -> ShowS)
-> (RRSet -> String) -> ([RRSet] -> ShowS) -> Show RRSet
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RRSet -> ShowS
showsPrec :: Int -> RRSet -> ShowS
$cshow :: RRSet -> String
show :: RRSet -> String
$cshowList :: [RRSet] -> ShowS
showList :: [RRSet] -> ShowS
Show, (forall x. RRSet -> Rep RRSet x)
-> (forall x. Rep RRSet x -> RRSet) -> Generic RRSet
forall x. Rep RRSet x -> RRSet
forall x. RRSet -> Rep RRSet x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RRSet -> Rep RRSet x
from :: forall x. RRSet -> Rep RRSet x
$cto :: forall x. Rep RRSet x -> RRSet
to :: forall x. Rep RRSet x -> RRSet
Generic, RRSet -> ()
(RRSet -> ()) -> NFData RRSet
forall a. (a -> ()) -> NFData a
$crnf :: RRSet -> ()
rnf :: RRSet -> ()
NFData, Typeable RRSet
Typeable RRSet
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RRSet -> c RRSet)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RRSet)
-> (RRSet -> Constr)
-> (RRSet -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RRSet))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RRSet))
-> ((forall b. Data b => b -> b) -> RRSet -> RRSet)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RRSet -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RRSet -> r)
-> (forall u. (forall d. Data d => d -> u) -> RRSet -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RRSet -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RRSet -> m RRSet)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RRSet -> m RRSet)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RRSet -> m RRSet)
-> Data RRSet
RRSet -> Constr
RRSet -> DataType
(forall b. Data b => b -> b) -> RRSet -> RRSet
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RRSet -> u
forall u. (forall d. Data d => d -> u) -> RRSet -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RRSet -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RRSet -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RRSet -> m RRSet
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RRSet -> m RRSet
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RRSet
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RRSet -> c RRSet
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RRSet)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RRSet)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RRSet -> c RRSet
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RRSet -> c RRSet
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RRSet
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RRSet
$ctoConstr :: RRSet -> Constr
toConstr :: RRSet -> Constr
$cdataTypeOf :: RRSet -> DataType
dataTypeOf :: RRSet -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RRSet)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RRSet)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RRSet)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RRSet)
$cgmapT :: (forall b. Data b => b -> b) -> RRSet -> RRSet
gmapT :: (forall b. Data b => b -> b) -> RRSet -> RRSet
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RRSet -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RRSet -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RRSet -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RRSet -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RRSet -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RRSet -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RRSet -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RRSet -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RRSet -> m RRSet
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RRSet -> m RRSet
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RRSet -> m RRSet
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RRSet -> m RRSet
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RRSet -> m RRSet
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RRSet -> m RRSet
Data)

$(deriveJSON defaultOptions { fieldLabelModifier = strip "rrset_"
                            , omitNothingFields = True } ''RRSet)

----------------------------------------------------------------------------------------

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

instance ToJSON RRSets
instance FromJSON RRSets

----------------------------------------------------------------------------------------

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

$(deriveJSON defaultOptions { allNullaryToStringTag = True } ''Kind)

----------------------------------------------------------------------------------------

-- | Zone according to [PowerDNS Documentation](https://doc.powerdns.com/authoritative/http-api/zone.html#zone).
-- All fields are optional because the PowerDNS API differs on which fields are required depending on the endpoint.
--
-- Note that 'Eq' and 'Ord' use limited case-sensitivity on 'zone_name' and equivalently contained rrset names
-- as per [RFC4343](https://datatracker.ietf.org/doc/html/rfc4343)
data Zone = Zone
  { Zone -> Maybe Text
zone_id :: Maybe T.Text
  , Zone -> Maybe CIText
zone_name :: Maybe CIText
  , Zone -> Maybe Text
zone_type :: Maybe T.Text
  , Zone -> Maybe Text
zone_url :: Maybe T.Text
  , Zone -> Maybe Kind
zone_kind :: Maybe Kind
  , Zone -> Maybe [RRSet]
zone_rrsets :: Maybe [RRSet]
  , Zone -> Maybe Integer
zone_serial :: Maybe Integer
  , Zone -> Maybe Integer
zone_notified_serial :: Maybe Integer
  , Zone -> Maybe Integer
zone_edited_serial :: Maybe Integer
  , Zone -> Maybe [Text]
zone_masters :: Maybe [T.Text]
  , Zone -> Maybe Bool
zone_dnssec :: Maybe Bool
  , Zone -> Maybe Text
zone_nsec3param :: Maybe T.Text
  , Zone -> Maybe Bool
zone_nsec3narrow :: Maybe Bool
  , Zone -> Maybe Bool
zone_presigned :: Maybe Bool
  , Zone -> Maybe Text
zone_soa_edit :: Maybe T.Text
  , Zone -> Maybe Text
zone_soa_edit_api :: Maybe T.Text
  , Zone -> Maybe Bool
zone_api_rectify :: Maybe Bool
  , Zone -> Maybe Text
zone_zone :: Maybe T.Text
  , Zone -> Maybe Text
zone_account :: Maybe T.Text
  , Zone -> Maybe [Text]
zone_nameservers :: Maybe [T.Text]
  , Zone -> Maybe [Text]
zone_master_tsig_key_ids :: Maybe [T.Text]
  , Zone -> Maybe [Text]
zone_slave_tsig_key_ids :: Maybe [T.Text]
  } deriving (Zone -> Zone -> Bool
(Zone -> Zone -> Bool) -> (Zone -> Zone -> Bool) -> Eq Zone
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Zone -> Zone -> Bool
== :: Zone -> Zone -> Bool
$c/= :: Zone -> Zone -> Bool
/= :: Zone -> Zone -> Bool
Eq, Eq Zone
Eq Zone
-> (Zone -> Zone -> Ordering)
-> (Zone -> Zone -> Bool)
-> (Zone -> Zone -> Bool)
-> (Zone -> Zone -> Bool)
-> (Zone -> Zone -> Bool)
-> (Zone -> Zone -> Zone)
-> (Zone -> Zone -> Zone)
-> Ord Zone
Zone -> Zone -> Bool
Zone -> Zone -> Ordering
Zone -> Zone -> Zone
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Zone -> Zone -> Ordering
compare :: Zone -> Zone -> Ordering
$c< :: Zone -> Zone -> Bool
< :: Zone -> Zone -> Bool
$c<= :: Zone -> Zone -> Bool
<= :: Zone -> Zone -> Bool
$c> :: Zone -> Zone -> Bool
> :: Zone -> Zone -> Bool
$c>= :: Zone -> Zone -> Bool
>= :: Zone -> Zone -> Bool
$cmax :: Zone -> Zone -> Zone
max :: Zone -> Zone -> Zone
$cmin :: Zone -> Zone -> Zone
min :: Zone -> Zone -> Zone
Ord, Int -> Zone -> ShowS
[Zone] -> ShowS
Zone -> String
(Int -> Zone -> ShowS)
-> (Zone -> String) -> ([Zone] -> ShowS) -> Show Zone
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Zone -> ShowS
showsPrec :: Int -> Zone -> ShowS
$cshow :: Zone -> String
show :: Zone -> String
$cshowList :: [Zone] -> ShowS
showList :: [Zone] -> ShowS
Show, (forall x. Zone -> Rep Zone x)
-> (forall x. Rep Zone x -> Zone) -> Generic Zone
forall x. Rep Zone x -> Zone
forall x. Zone -> Rep Zone x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Zone -> Rep Zone x
from :: forall x. Zone -> Rep Zone x
$cto :: forall x. Rep Zone x -> Zone
to :: forall x. Rep Zone x -> Zone
Generic, Zone -> ()
(Zone -> ()) -> NFData Zone
forall a. (a -> ()) -> NFData a
$crnf :: Zone -> ()
rnf :: Zone -> ()
NFData, Typeable Zone
Typeable Zone
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Zone -> c Zone)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Zone)
-> (Zone -> Constr)
-> (Zone -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Zone))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Zone))
-> ((forall b. Data b => b -> b) -> Zone -> Zone)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Zone -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Zone -> r)
-> (forall u. (forall d. Data d => d -> u) -> Zone -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Zone -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Zone -> m Zone)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Zone -> m Zone)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Zone -> m Zone)
-> Data Zone
Zone -> Constr
Zone -> DataType
(forall b. Data b => b -> b) -> Zone -> Zone
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Zone -> u
forall u. (forall d. Data d => d -> u) -> Zone -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Zone -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Zone -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Zone -> m Zone
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Zone -> m Zone
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Zone
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Zone -> c Zone
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Zone)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Zone)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Zone -> c Zone
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Zone -> c Zone
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Zone
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Zone
$ctoConstr :: Zone -> Constr
toConstr :: Zone -> Constr
$cdataTypeOf :: Zone -> DataType
dataTypeOf :: Zone -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Zone)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Zone)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Zone)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Zone)
$cgmapT :: (forall b. Data b => b -> b) -> Zone -> Zone
gmapT :: (forall b. Data b => b -> b) -> Zone -> Zone
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Zone -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Zone -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Zone -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Zone -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Zone -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Zone -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Zone -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Zone -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Zone -> m Zone
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Zone -> m Zone
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Zone -> m Zone
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Zone -> m Zone
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Zone -> m Zone
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Zone -> m Zone
Data, Zone
Zone -> Empty Zone
forall a. a -> Empty a
$cempty :: Zone
empty :: Zone
Empty)

$(deriveJSON defaultOptions { fieldLabelModifier = strip "zone_" } ''Zone)

----------------------------------------------------------------------------------------

data ZonesAPI f = ZonesAPI
  { forall f.
ZonesAPI f
-> f
   :- ("servers"
       :> (Capture "server_id" Text
           :> ("zones"
               :> (QueryParam "zone" Text
                   :> (QueryParam "dnssec" Bool :> Get '[JSON] [Zone])))))
apiListZones     :: f :- "servers" :> Capture "server_id" T.Text :> "zones"
                          :> QueryParam "zone" T.Text
                          :> QueryParam "dnssec" Bool
                          :> Get '[JSON] [Zone]

  , forall f.
ZonesAPI f
-> f
   :- ("servers"
       :> (Capture "server_id" Text
           :> ("zones"
               :> (QueryParam "rrset" Bool
                   :> (ReqBody '[JSON] Zone :> PostCreated '[JSON] Zone)))))
apiCreateZone    :: f :- "servers" :> Capture "server_id" T.Text :> "zones"
                          :> QueryParam "rrset" Bool
                          :> ReqBody '[JSON] Zone
                          :> PostCreated '[JSON] Zone

  , forall f.
ZonesAPI f
-> f
   :- ("servers"
       :> (Capture "server_id" Text
           :> ("zones"
               :> (Capture "zone_id" Text
                   :> (QueryParam "rrsets" Bool :> Get '[JSON] Zone)))))
apiGetZone       :: f :- "servers" :> Capture "server_id" T.Text :> "zones" :> Capture "zone_id" T.Text
                          :> QueryParam "rrsets" Bool
                          :> Get '[JSON] Zone

  , forall f.
ZonesAPI f
-> f
   :- ("servers"
       :> (Capture "server_id" Text
           :> ("zones" :> (Capture "zone_id" Text :> DeleteNoContent))))
apiDeleteZone    :: f :- "servers" :> Capture "server_id" T.Text :> "zones" :> Capture "zone_id" T.Text
                          :> DeleteNoContent

  , forall f.
ZonesAPI f
-> f
   :- ("servers"
       :> (Capture "server_id" Text
           :> ("zones"
               :> (Capture "zone_id" Text
                   :> (ReqBody '[JSON] RRSets :> PatchNoContent)))))
apiUpdateRecords :: f :- "servers" :> Capture "server_id" T.Text :> "zones" :> Capture "zone_id" T.Text
                          :> ReqBody '[JSON] RRSets
                          :> PatchNoContent

  , forall f.
ZonesAPI f
-> f
   :- ("servers"
       :> (Capture "server_id" Text
           :> ("zones"
               :> (Capture "zone_id" Text
                   :> (ReqBody '[JSON] Zone :> PutNoContent)))))
apiUpdateZone    :: f :- "servers" :> Capture "server_id" T.Text :> "zones" :> Capture "zone_id" T.Text
                          :> ReqBody '[JSON] Zone
                          :> PutNoContent

  , forall f.
ZonesAPI f
-> f
   :- ("servers"
       :> (Capture "server_id" Text
           :> ("zones"
               :> (Capture "zone_id" Text
                   :> ("axfr-retrieve" :> Put '[JSON] Result)))))
apiTriggerAxfr   :: f :- "servers" :> Capture "server_id" T.Text :> "zones" :> Capture "zone_id" T.Text :> "axfr-retrieve"
                          :> Put '[JSON] Result

  , forall f.
ZonesAPI f
-> f
   :- ("servers"
       :> (Capture "server_id" Text
           :> ("zones"
               :> (Capture "zone_id" Text :> ("notify" :> Put '[JSON] Result)))))
apiNotifySlaves  :: f :- "servers" :> Capture "server_id" T.Text :> "zones" :> Capture "zone_id" T.Text :> "notify"
                          :> Put '[JSON] Result

  , forall f.
ZonesAPI f
-> f
   :- ("servers"
       :> (Capture "server_id" Text
           :> ("zones"
               :> (Capture "zone_id" Text :> ("export" :> Get '[JSON] Result)))))
apiGetZoneAxfr   :: f :- "servers" :> Capture "server_id" T.Text :> "zones" :> Capture "zone_id" T.Text :> "export"
                          :> Get '[JSON] Result

  , forall f.
ZonesAPI f
-> f
   :- ("servers"
       :> (Capture "server_id" Text
           :> ("zones"
               :> (Capture "zone_id" Text :> ("rectify" :> Put '[JSON] Result)))))
apiRectifyZone   :: f :- "servers" :> Capture "server_id" T.Text :> "zones" :> Capture "zone_id" T.Text :> "rectify"
                          :> Put '[JSON] Result

  } deriving (forall x. ZonesAPI f -> Rep (ZonesAPI f) x)
-> (forall x. Rep (ZonesAPI f) x -> ZonesAPI f)
-> Generic (ZonesAPI f)
forall x. Rep (ZonesAPI f) x -> ZonesAPI f
forall x. ZonesAPI f -> Rep (ZonesAPI f) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall f x. Rep (ZonesAPI f) x -> ZonesAPI f
forall f x. ZonesAPI f -> Rep (ZonesAPI f) x
$cfrom :: forall f x. ZonesAPI f -> Rep (ZonesAPI f) x
from :: forall x. ZonesAPI f -> Rep (ZonesAPI f) x
$cto :: forall f x. Rep (ZonesAPI f) x -> ZonesAPI f
to :: forall x. Rep (ZonesAPI f) x -> ZonesAPI f
Generic

-- | A simple newtype wrapper, because the original PowerDNS API encodes some textual result types more equal than others.
newtype Result = Result T.Text

instance ToJSON Result where
  toJSON :: Result -> Value
toJSON (Result Text
t) = [Pair] -> Value
object [Key
"result" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
t]

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