-----------------------------------------------------------------------------
-- |
-- License     :  BSD-3-Clause
-- Maintainer  :  Todd Mohney <toddmohney@gmail.com>
--
module GitHub.Data.PublicSSHKeys where

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

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

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

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

instance FromJSON PublicSSHKey where
    parseJSON :: Value -> Parser PublicSSHKey
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"PublicSSHKey" forall a b. (a -> b) -> a -> b
$ \Object
o -> Id PublicSSHKey
-> Text
-> URL
-> Text
-> Bool
-> Maybe UTCTime
-> Bool
-> PublicSSHKey
PublicSSHKey
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"key"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"title"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"verified"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"created_at"
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"read_only"

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

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

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