Codec.Encryption.OpenPGP.Types

hOpenPGP-2.5.1: native Haskell implementation of OpenPGP (RFC4880)

Safe Haskell | None
Language | Haskell2010

Codec.Encryption.OpenPGP.Types

# Documentation

type Exportability = Bool #

type TrustLevel = Word8 #

type TrustAmount = Word8 #

type AlmostPublicDomainRegex = ByteString #

type Revocability = Bool #

type RevocationReason = Text #

type KeyServer = ByteString #

type SignatureHash = ByteString #

type PacketVersion = Word8 #

type V3Expiration = Word16 #

type CompressedDataPayload = ByteString #

type FileName = ByteString #

type ImageData = ByteString #

type NestedFlag = Bool #

class (Eq a, Ord a) => FutureFlag a where #

Minimal complete definition

fromFFlag, toFFlag

Methods

fromFFlag :: a -> Int #

toFFlag :: Int -> a #

Instances

FutureFlag NotationFlag # |
Methods fromFFlag :: NotationFlag -> Int # toFFlag :: Int -> NotationFlag #
FutureFlag RevocationClass # |
Methods fromFFlag :: RevocationClass -> Int # toFFlag :: Int -> RevocationClass #
FutureFlag KSPFlag # |
Methods fromFFlag :: KSPFlag -> Int # toFFlag :: Int -> KSPFlag #
FutureFlag KeyFlag # |
Methods fromFFlag :: KeyFlag -> Int # toFFlag :: Int -> KeyFlag #
FutureFlag FeatureFlag # |
Methods fromFFlag :: FeatureFlag -> Int # toFFlag :: Int -> FeatureFlag #

class (Eq a, Ord a) => FutureVal a where #

Minimal complete definition

fromFVal, toFVal

Methods

fromFVal :: a -> Word8 #

toFVal :: Word8 -> a #

Instances

FutureVal SymmetricAlgorithm # |
Methods fromFVal :: SymmetricAlgorithm -> Word8 # toFVal :: Word8 -> SymmetricAlgorithm #
FutureVal PubKeyAlgorithm # |
Methods fromFVal :: PubKeyAlgorithm -> Word8 # toFVal :: Word8 -> PubKeyAlgorithm #
FutureVal HashAlgorithm # |
Methods fromFVal :: HashAlgorithm -> Word8 # toFVal :: Word8 -> HashAlgorithm #
FutureVal CompressionAlgorithm # |
Methods fromFVal :: CompressionAlgorithm -> Word8 # toFVal :: Word8 -> CompressionAlgorithm #
FutureVal RevocationCode # |
Methods fromFVal :: RevocationCode -> Word8 # toFVal :: Word8 -> RevocationCode #
FutureVal SigType # |
Methods fromFVal :: SigType -> Word8 # toFVal :: Word8 -> SigType #
FutureVal DataType # |
Methods fromFVal :: DataType -> Word8 # toFVal :: Word8 -> DataType #
FutureVal ImageFormat # |
Methods fromFVal :: ImageFormat -> Word8 # toFVal :: Word8 -> ImageFormat #

data SymmetricAlgorithm #

Constructors

Plaintext |
IDEA |
TripleDES |
CAST5 |
Blowfish |
ReservedSAFER |
ReservedDES |
AES128 |
AES192 |
AES256 |
Twofish |
Camellia128 |
Camellia192 |
Camellia256 |
OtherSA Word8 |

Instances

Eq SymmetricAlgorithm # |
Methods (==) :: SymmetricAlgorithm -> SymmetricAlgorithm -> Bool # (/=) :: SymmetricAlgorithm -> SymmetricAlgorithm -> Bool #
Data SymmetricAlgorithm # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SymmetricAlgorithm -> c SymmetricAlgorithm # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SymmetricAlgorithm # toConstr :: SymmetricAlgorithm -> Constr # dataTypeOf :: SymmetricAlgorithm -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SymmetricAlgorithm) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SymmetricAlgorithm) # gmapT :: (forall b. Data b => b -> b) -> SymmetricAlgorithm -> SymmetricAlgorithm # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SymmetricAlgorithm -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SymmetricAlgorithm -> r # gmapQ :: (forall d. Data d => d -> u) -> SymmetricAlgorithm -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SymmetricAlgorithm -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SymmetricAlgorithm -> m SymmetricAlgorithm # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SymmetricAlgorithm -> m SymmetricAlgorithm # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SymmetricAlgorithm -> m SymmetricAlgorithm #
Ord SymmetricAlgorithm # |
Methods compare :: SymmetricAlgorithm -> SymmetricAlgorithm -> Ordering # (<) :: SymmetricAlgorithm -> SymmetricAlgorithm -> Bool # (<=) :: SymmetricAlgorithm -> SymmetricAlgorithm -> Bool # (>) :: SymmetricAlgorithm -> SymmetricAlgorithm -> Bool # (>=) :: SymmetricAlgorithm -> SymmetricAlgorithm -> Bool # max :: SymmetricAlgorithm -> SymmetricAlgorithm -> SymmetricAlgorithm # min :: SymmetricAlgorithm -> SymmetricAlgorithm -> SymmetricAlgorithm #
Show SymmetricAlgorithm # |
Methods showsPrec :: Int -> SymmetricAlgorithm -> ShowS # show :: SymmetricAlgorithm -> String # showList :: [SymmetricAlgorithm] -> ShowS #
Generic SymmetricAlgorithm # |
Associated Types type Rep SymmetricAlgorithm :: * -> * # Methods from :: SymmetricAlgorithm -> Rep SymmetricAlgorithm x # to :: Rep SymmetricAlgorithm x -> SymmetricAlgorithm #
ToJSON SymmetricAlgorithm # |
Methods toJSON :: SymmetricAlgorithm -> Value # toEncoding :: SymmetricAlgorithm -> Encoding #
FromJSON SymmetricAlgorithm # |
Methods parseJSON :: Value -> Parser SymmetricAlgorithm #
Hashable SymmetricAlgorithm # |
Methods hashWithSalt :: Int -> SymmetricAlgorithm -> Int # hash :: SymmetricAlgorithm -> Int #
Pretty SymmetricAlgorithm # |
Methods pretty :: SymmetricAlgorithm -> Doc e # prettyList :: [SymmetricAlgorithm] -> Doc e #
FutureVal SymmetricAlgorithm # |
Methods fromFVal :: SymmetricAlgorithm -> Word8 # toFVal :: Word8 -> SymmetricAlgorithm #
type Rep SymmetricAlgorithm # |
type Rep SymmetricAlgorithm = D1 (MetaData "SymmetricAlgorithm" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "Plaintext" PrefixI False) U1) ((:+:) (C1 (MetaCons "IDEA" PrefixI False) U1) (C1 (MetaCons "TripleDES" PrefixI False) U1))) ((:+:) ((:+:) (C1 (MetaCons "CAST5" PrefixI False) U1) (C1 (MetaCons "Blowfish" PrefixI False) U1)) ((:+:) (C1 (MetaCons "ReservedSAFER" PrefixI False) U1) (C1 (MetaCons "ReservedDES" PrefixI False) U1)))) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "AES128" PrefixI False) U1) (C1 (MetaCons "AES192" PrefixI False) U1)) ((:+:) (C1 (MetaCons "AES256" PrefixI False) U1) (C1 (MetaCons "Twofish" PrefixI False) U1))) ((:+:) ((:+:) (C1 (MetaCons "Camellia128" PrefixI False) U1) (C1 (MetaCons "Camellia192" PrefixI False) U1)) ((:+:) (C1 (MetaCons "Camellia256" PrefixI False) U1) (C1 (MetaCons "OtherSA" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word8)))))))

data NotationFlag #

Constructors

HumanReadable |
OtherNF Word8 |

Instances

Eq NotationFlag # |
Methods (==) :: NotationFlag -> NotationFlag -> Bool # (/=) :: NotationFlag -> NotationFlag -> Bool #
Data NotationFlag # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NotationFlag -> c NotationFlag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NotationFlag # toConstr :: NotationFlag -> Constr # dataTypeOf :: NotationFlag -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c NotationFlag) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NotationFlag) # gmapT :: (forall b. Data b => b -> b) -> NotationFlag -> NotationFlag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NotationFlag -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NotationFlag -> r # gmapQ :: (forall d. Data d => d -> u) -> NotationFlag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NotationFlag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NotationFlag -> m NotationFlag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NotationFlag -> m NotationFlag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NotationFlag -> m NotationFlag #
Ord NotationFlag # |
Methods compare :: NotationFlag -> NotationFlag -> Ordering # (<) :: NotationFlag -> NotationFlag -> Bool # (<=) :: NotationFlag -> NotationFlag -> Bool # (>) :: NotationFlag -> NotationFlag -> Bool # (>=) :: NotationFlag -> NotationFlag -> Bool # max :: NotationFlag -> NotationFlag -> NotationFlag # min :: NotationFlag -> NotationFlag -> NotationFlag #
Show NotationFlag # |
Methods showsPrec :: Int -> NotationFlag -> ShowS # show :: NotationFlag -> String # showList :: [NotationFlag] -> ShowS #
Generic NotationFlag # |
Associated Types type Rep NotationFlag :: * -> * # Methods from :: NotationFlag -> Rep NotationFlag x # to :: Rep NotationFlag x -> NotationFlag #
ToJSON NotationFlag # |
Methods toJSON :: NotationFlag -> Value # toEncoding :: NotationFlag -> Encoding #
FromJSON NotationFlag # |
Methods parseJSON :: Value -> Parser NotationFlag #
Hashable NotationFlag # |
Methods hashWithSalt :: Int -> NotationFlag -> Int # hash :: NotationFlag -> Int #
Pretty NotationFlag # |
Methods pretty :: NotationFlag -> Doc e # prettyList :: [NotationFlag] -> Doc e #
FutureFlag NotationFlag # |
Methods fromFFlag :: NotationFlag -> Int # toFFlag :: Int -> NotationFlag #
type Rep NotationFlag # |
type Rep NotationFlag = D1 (MetaData "NotationFlag" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) (C1 (MetaCons "HumanReadable" PrefixI False) U1) (C1 (MetaCons "OtherNF" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word8))))

newtype ThirtyTwoBitTimeStamp #

Constructors

ThirtyTwoBitTimeStamp |
Fields unThirtyTwoBitTimeStamp :: Word32

Instances

Bounded ThirtyTwoBitTimeStamp # |
Methods minBound :: ThirtyTwoBitTimeStamp # maxBound :: ThirtyTwoBitTimeStamp #
Enum ThirtyTwoBitTimeStamp # |
Methods succ :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp # pred :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp # toEnum :: Int -> ThirtyTwoBitTimeStamp # fromEnum :: ThirtyTwoBitTimeStamp -> Int # enumFrom :: ThirtyTwoBitTimeStamp -> [ThirtyTwoBitTimeStamp] # enumFromThen :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> [ThirtyTwoBitTimeStamp] # enumFromTo :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> [ThirtyTwoBitTimeStamp] # enumFromThenTo :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> [ThirtyTwoBitTimeStamp] #
Eq ThirtyTwoBitTimeStamp # |
Methods (==) :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool # (/=) :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool #
Integral ThirtyTwoBitTimeStamp # |
Methods quot :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp # rem :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp # div :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp # mod :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp # quotRem :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> (ThirtyTwoBitTimeStamp, ThirtyTwoBitTimeStamp) # divMod :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> (ThirtyTwoBitTimeStamp, ThirtyTwoBitTimeStamp) # toInteger :: ThirtyTwoBitTimeStamp -> Integer #
Data ThirtyTwoBitTimeStamp # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ThirtyTwoBitTimeStamp -> c ThirtyTwoBitTimeStamp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ThirtyTwoBitTimeStamp # toConstr :: ThirtyTwoBitTimeStamp -> Constr # dataTypeOf :: ThirtyTwoBitTimeStamp -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ThirtyTwoBitTimeStamp) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ThirtyTwoBitTimeStamp) # gmapT :: (forall b. Data b => b -> b) -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitTimeStamp -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitTimeStamp -> r # gmapQ :: (forall d. Data d => d -> u) -> ThirtyTwoBitTimeStamp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ThirtyTwoBitTimeStamp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ThirtyTwoBitTimeStamp -> m ThirtyTwoBitTimeStamp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ThirtyTwoBitTimeStamp -> m ThirtyTwoBitTimeStamp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ThirtyTwoBitTimeStamp -> m ThirtyTwoBitTimeStamp #
Num ThirtyTwoBitTimeStamp # |
Methods (+) :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp # (-) :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp # (*) :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp # negate :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp # abs :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp # signum :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp # fromInteger :: Integer -> ThirtyTwoBitTimeStamp #
Ord ThirtyTwoBitTimeStamp # |
Methods compare :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Ordering # (<) :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool # (<=) :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool # (>) :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool # (>=) :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool # max :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp # min :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp #
Real ThirtyTwoBitTimeStamp # |
Methods toRational :: ThirtyTwoBitTimeStamp -> Rational #
Show ThirtyTwoBitTimeStamp # |
Methods showsPrec :: Int -> ThirtyTwoBitTimeStamp -> ShowS # show :: ThirtyTwoBitTimeStamp -> String # showList :: [ThirtyTwoBitTimeStamp] -> ShowS #
Generic ThirtyTwoBitTimeStamp # |
Associated Types type Rep ThirtyTwoBitTimeStamp :: * -> * # Methods from :: ThirtyTwoBitTimeStamp -> Rep ThirtyTwoBitTimeStamp x # to :: Rep ThirtyTwoBitTimeStamp x -> ThirtyTwoBitTimeStamp #
ToJSON ThirtyTwoBitTimeStamp # |
Methods toJSON :: ThirtyTwoBitTimeStamp -> Value # toEncoding :: ThirtyTwoBitTimeStamp -> Encoding #
FromJSON ThirtyTwoBitTimeStamp # |
Methods parseJSON :: Value -> Parser ThirtyTwoBitTimeStamp #
Hashable ThirtyTwoBitTimeStamp # |
Methods hashWithSalt :: Int -> ThirtyTwoBitTimeStamp -> Int # hash :: ThirtyTwoBitTimeStamp -> Int #
Pretty ThirtyTwoBitTimeStamp # |
Methods pretty :: ThirtyTwoBitTimeStamp -> Doc e # prettyList :: [ThirtyTwoBitTimeStamp] -> Doc e #
Newtype ThirtyTwoBitTimeStamp Word32 # |
Methods pack :: Word32 -> ThirtyTwoBitTimeStamp # unpack :: ThirtyTwoBitTimeStamp -> Word32 #
type Rep ThirtyTwoBitTimeStamp # |
type Rep ThirtyTwoBitTimeStamp = D1 (MetaData "ThirtyTwoBitTimeStamp" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "ThirtyTwoBitTimeStamp" PrefixI True) (S1 (MetaSel (Just Symbol "unThirtyTwoBitTimeStamp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word32)))

durU :: (Integral a, Show a) => a -> Maybe (String, a) #

newtype ThirtyTwoBitDuration #

Constructors

ThirtyTwoBitDuration |
Fields unThirtyTwoBitDuration :: Word32

Instances

Bounded ThirtyTwoBitDuration # |
Methods minBound :: ThirtyTwoBitDuration # maxBound :: ThirtyTwoBitDuration #
Enum ThirtyTwoBitDuration # |
Methods succ :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration # pred :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration # toEnum :: Int -> ThirtyTwoBitDuration # fromEnum :: ThirtyTwoBitDuration -> Int # enumFrom :: ThirtyTwoBitDuration -> [ThirtyTwoBitDuration] # enumFromThen :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> [ThirtyTwoBitDuration] # enumFromTo :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> [ThirtyTwoBitDuration] # enumFromThenTo :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> [ThirtyTwoBitDuration] #
Eq ThirtyTwoBitDuration # |
Methods (==) :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool # (/=) :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool #
Integral ThirtyTwoBitDuration # |
Methods quot :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration # rem :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration # div :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration # mod :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration # quotRem :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> (ThirtyTwoBitDuration, ThirtyTwoBitDuration) # divMod :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> (ThirtyTwoBitDuration, ThirtyTwoBitDuration) # toInteger :: ThirtyTwoBitDuration -> Integer #
Data ThirtyTwoBitDuration # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ThirtyTwoBitDuration -> c ThirtyTwoBitDuration # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ThirtyTwoBitDuration # toConstr :: ThirtyTwoBitDuration -> Constr # dataTypeOf :: ThirtyTwoBitDuration -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ThirtyTwoBitDuration) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ThirtyTwoBitDuration) # gmapT :: (forall b. Data b => b -> b) -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitDuration -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitDuration -> r # gmapQ :: (forall d. Data d => d -> u) -> ThirtyTwoBitDuration -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ThirtyTwoBitDuration -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ThirtyTwoBitDuration -> m ThirtyTwoBitDuration # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ThirtyTwoBitDuration -> m ThirtyTwoBitDuration # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ThirtyTwoBitDuration -> m ThirtyTwoBitDuration #
Num ThirtyTwoBitDuration # |
Methods (+) :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration # (-) :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration # (*) :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration # negate :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration # abs :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration # signum :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration # fromInteger :: Integer -> ThirtyTwoBitDuration #
Ord ThirtyTwoBitDuration # |
Methods compare :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Ordering # (<) :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool # (<=) :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool # (>) :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool # (>=) :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool # max :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration # min :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration #
Real ThirtyTwoBitDuration # |
Methods toRational :: ThirtyTwoBitDuration -> Rational #
Show ThirtyTwoBitDuration # |
Methods showsPrec :: Int -> ThirtyTwoBitDuration -> ShowS # show :: ThirtyTwoBitDuration -> String # showList :: [ThirtyTwoBitDuration] -> ShowS #
Generic ThirtyTwoBitDuration # |
Associated Types type Rep ThirtyTwoBitDuration :: * -> * # Methods from :: ThirtyTwoBitDuration -> Rep ThirtyTwoBitDuration x # to :: Rep ThirtyTwoBitDuration x -> ThirtyTwoBitDuration #
ToJSON ThirtyTwoBitDuration # |
Methods toJSON :: ThirtyTwoBitDuration -> Value # toEncoding :: ThirtyTwoBitDuration -> Encoding #
FromJSON ThirtyTwoBitDuration # |
Methods parseJSON :: Value -> Parser ThirtyTwoBitDuration #
Hashable ThirtyTwoBitDuration # |
Methods hashWithSalt :: Int -> ThirtyTwoBitDuration -> Int # hash :: ThirtyTwoBitDuration -> Int #
Pretty ThirtyTwoBitDuration # |
Methods pretty :: ThirtyTwoBitDuration -> Doc e # prettyList :: [ThirtyTwoBitDuration] -> Doc e #
Newtype ThirtyTwoBitDuration Word32 # |
Methods pack :: Word32 -> ThirtyTwoBitDuration # unpack :: ThirtyTwoBitDuration -> Word32 #
type Rep ThirtyTwoBitDuration # |
type Rep ThirtyTwoBitDuration = D1 (MetaData "ThirtyTwoBitDuration" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "ThirtyTwoBitDuration" PrefixI True) (S1 (MetaSel (Just Symbol "unThirtyTwoBitDuration") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word32)))

data RevocationClass #

Constructors

SensitiveRK |
RClOther Word8 |

Instances

Eq RevocationClass # |
Methods (==) :: RevocationClass -> RevocationClass -> Bool # (/=) :: RevocationClass -> RevocationClass -> Bool #
Data RevocationClass # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RevocationClass -> c RevocationClass # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RevocationClass # toConstr :: RevocationClass -> Constr # dataTypeOf :: RevocationClass -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c RevocationClass) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RevocationClass) # gmapT :: (forall b. Data b => b -> b) -> RevocationClass -> RevocationClass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RevocationClass -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RevocationClass -> r # gmapQ :: (forall d. Data d => d -> u) -> RevocationClass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RevocationClass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RevocationClass -> m RevocationClass # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RevocationClass -> m RevocationClass # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RevocationClass -> m RevocationClass #
Ord RevocationClass # |
Methods compare :: RevocationClass -> RevocationClass -> Ordering # (<) :: RevocationClass -> RevocationClass -> Bool # (<=) :: RevocationClass -> RevocationClass -> Bool # (>) :: RevocationClass -> RevocationClass -> Bool # (>=) :: RevocationClass -> RevocationClass -> Bool # max :: RevocationClass -> RevocationClass -> RevocationClass # min :: RevocationClass -> RevocationClass -> RevocationClass #
Show RevocationClass # |
Methods showsPrec :: Int -> RevocationClass -> ShowS # show :: RevocationClass -> String # showList :: [RevocationClass] -> ShowS #
Generic RevocationClass # |
Associated Types type Rep RevocationClass :: * -> * # Methods from :: RevocationClass -> Rep RevocationClass x # to :: Rep RevocationClass x -> RevocationClass #
ToJSON RevocationClass # |
Methods toJSON :: RevocationClass -> Value # toEncoding :: RevocationClass -> Encoding #
FromJSON RevocationClass # |
Methods parseJSON :: Value -> Parser RevocationClass #
Hashable RevocationClass # |
Methods hashWithSalt :: Int -> RevocationClass -> Int # hash :: RevocationClass -> Int #
Pretty RevocationClass # |
Methods pretty :: RevocationClass -> Doc e # prettyList :: [RevocationClass] -> Doc e #
FutureFlag RevocationClass # |
Methods fromFFlag :: RevocationClass -> Int # toFFlag :: Int -> RevocationClass #
type Rep RevocationClass # |
type Rep RevocationClass = D1 (MetaData "RevocationClass" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) (C1 (MetaCons "SensitiveRK" PrefixI False) U1) (C1 (MetaCons "RClOther" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word8))))

data PubKeyAlgorithm #

Constructors

RSA |
DeprecatedRSAEncryptOnly |
DeprecatedRSASignOnly |
ElgamalEncryptOnly |
DSA |
ECDH |
ECDSA |
ForbiddenElgamal |
DH |
OtherPKA Word8 |

Instances

Eq PubKeyAlgorithm # |
Methods (==) :: PubKeyAlgorithm -> PubKeyAlgorithm -> Bool # (/=) :: PubKeyAlgorithm -> PubKeyAlgorithm -> Bool #
Data PubKeyAlgorithm # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PubKeyAlgorithm -> c PubKeyAlgorithm # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PubKeyAlgorithm # toConstr :: PubKeyAlgorithm -> Constr # dataTypeOf :: PubKeyAlgorithm -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PubKeyAlgorithm) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PubKeyAlgorithm) # gmapT :: (forall b. Data b => b -> b) -> PubKeyAlgorithm -> PubKeyAlgorithm # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PubKeyAlgorithm -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PubKeyAlgorithm -> r # gmapQ :: (forall d. Data d => d -> u) -> PubKeyAlgorithm -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PubKeyAlgorithm -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PubKeyAlgorithm -> m PubKeyAlgorithm # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PubKeyAlgorithm -> m PubKeyAlgorithm # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PubKeyAlgorithm -> m PubKeyAlgorithm #
Ord PubKeyAlgorithm # |
Methods compare :: PubKeyAlgorithm -> PubKeyAlgorithm -> Ordering # (<) :: PubKeyAlgorithm -> PubKeyAlgorithm -> Bool # (<=) :: PubKeyAlgorithm -> PubKeyAlgorithm -> Bool # (>) :: PubKeyAlgorithm -> PubKeyAlgorithm -> Bool # (>=) :: PubKeyAlgorithm -> PubKeyAlgorithm -> Bool # max :: PubKeyAlgorithm -> PubKeyAlgorithm -> PubKeyAlgorithm # min :: PubKeyAlgorithm -> PubKeyAlgorithm -> PubKeyAlgorithm #
Show PubKeyAlgorithm # |
Methods showsPrec :: Int -> PubKeyAlgorithm -> ShowS # show :: PubKeyAlgorithm -> String # showList :: [PubKeyAlgorithm] -> ShowS #
Generic PubKeyAlgorithm # |
Associated Types type Rep PubKeyAlgorithm :: * -> * # Methods from :: PubKeyAlgorithm -> Rep PubKeyAlgorithm x # to :: Rep PubKeyAlgorithm x -> PubKeyAlgorithm #
ToJSON PubKeyAlgorithm # |
Methods toJSON :: PubKeyAlgorithm -> Value # toEncoding :: PubKeyAlgorithm -> Encoding #
FromJSON PubKeyAlgorithm # |
Methods parseJSON :: Value -> Parser PubKeyAlgorithm #
Hashable PubKeyAlgorithm # |
Methods hashWithSalt :: Int -> PubKeyAlgorithm -> Int # hash :: PubKeyAlgorithm -> Int #
Pretty PubKeyAlgorithm # |
Methods pretty :: PubKeyAlgorithm -> Doc e # prettyList :: [PubKeyAlgorithm] -> Doc e #
FutureVal PubKeyAlgorithm # |
Methods fromFVal :: PubKeyAlgorithm -> Word8 # toFVal :: Word8 -> PubKeyAlgorithm #
type Rep PubKeyAlgorithm # |
type Rep PubKeyAlgorithm = D1 (MetaData "PubKeyAlgorithm" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "RSA" PrefixI False) U1) (C1 (MetaCons "DeprecatedRSAEncryptOnly" PrefixI False) U1)) ((:+:) (C1 (MetaCons "DeprecatedRSASignOnly" PrefixI False) U1) ((:+:) (C1 (MetaCons "ElgamalEncryptOnly" PrefixI False) U1) (C1 (MetaCons "DSA" PrefixI False) U1)))) ((:+:) ((:+:) (C1 (MetaCons "ECDH" PrefixI False) U1) (C1 (MetaCons "ECDSA" PrefixI False) U1)) ((:+:) (C1 (MetaCons "ForbiddenElgamal" PrefixI False) U1) ((:+:) (C1 (MetaCons "DH" PrefixI False) U1) (C1 (MetaCons "OtherPKA" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word8)))))))

newtype TwentyOctetFingerprint #

Constructors

TwentyOctetFingerprint |
Fields unTOF :: ByteString

Instances

Eq TwentyOctetFingerprint # |
Methods (==) :: TwentyOctetFingerprint -> TwentyOctetFingerprint -> Bool # (/=) :: TwentyOctetFingerprint -> TwentyOctetFingerprint -> Bool #
Data TwentyOctetFingerprint # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TwentyOctetFingerprint -> c TwentyOctetFingerprint # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TwentyOctetFingerprint # toConstr :: TwentyOctetFingerprint -> Constr # dataTypeOf :: TwentyOctetFingerprint -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TwentyOctetFingerprint) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TwentyOctetFingerprint) # gmapT :: (forall b. Data b => b -> b) -> TwentyOctetFingerprint -> TwentyOctetFingerprint # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TwentyOctetFingerprint -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TwentyOctetFingerprint -> r # gmapQ :: (forall d. Data d => d -> u) -> TwentyOctetFingerprint -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TwentyOctetFingerprint -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TwentyOctetFingerprint -> m TwentyOctetFingerprint # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TwentyOctetFingerprint -> m TwentyOctetFingerprint # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TwentyOctetFingerprint -> m TwentyOctetFingerprint #
Ord TwentyOctetFingerprint # |
Methods compare :: TwentyOctetFingerprint -> TwentyOctetFingerprint -> Ordering # (<) :: TwentyOctetFingerprint -> TwentyOctetFingerprint -> Bool # (<=) :: TwentyOctetFingerprint -> TwentyOctetFingerprint -> Bool # (>) :: TwentyOctetFingerprint -> TwentyOctetFingerprint -> Bool # (>=) :: TwentyOctetFingerprint -> TwentyOctetFingerprint -> Bool # max :: TwentyOctetFingerprint -> TwentyOctetFingerprint -> TwentyOctetFingerprint # min :: TwentyOctetFingerprint -> TwentyOctetFingerprint -> TwentyOctetFingerprint #
Read TwentyOctetFingerprint # |
Methods readsPrec :: Int -> ReadS TwentyOctetFingerprint # readList :: ReadS [TwentyOctetFingerprint] # readPrec :: ReadPrec TwentyOctetFingerprint # readListPrec :: ReadPrec [TwentyOctetFingerprint] #
Show TwentyOctetFingerprint # |
Methods showsPrec :: Int -> TwentyOctetFingerprint -> ShowS # show :: TwentyOctetFingerprint -> String # showList :: [TwentyOctetFingerprint] -> ShowS #
Generic TwentyOctetFingerprint # |
Associated Types type Rep TwentyOctetFingerprint :: * -> * # Methods from :: TwentyOctetFingerprint -> Rep TwentyOctetFingerprint x # to :: Rep TwentyOctetFingerprint x -> TwentyOctetFingerprint #
ToJSON TwentyOctetFingerprint # |
Methods toJSON :: TwentyOctetFingerprint -> Value # toEncoding :: TwentyOctetFingerprint -> Encoding #
FromJSON TwentyOctetFingerprint # |
Methods parseJSON :: Value -> Parser TwentyOctetFingerprint #
Hashable TwentyOctetFingerprint # |
Methods hashWithSalt :: Int -> TwentyOctetFingerprint -> Int # hash :: TwentyOctetFingerprint -> Int #
Pretty TwentyOctetFingerprint # |
Methods pretty :: TwentyOctetFingerprint -> Doc e # prettyList :: [TwentyOctetFingerprint] -> Doc e #
Newtype SpacedFingerprint TwentyOctetFingerprint # |
Methods pack :: TwentyOctetFingerprint -> SpacedFingerprint # unpack :: SpacedFingerprint -> TwentyOctetFingerprint #
Newtype TwentyOctetFingerprint ByteString # |
Methods pack :: ByteString -> TwentyOctetFingerprint # unpack :: TwentyOctetFingerprint -> ByteString #
type Rep TwentyOctetFingerprint # |
type Rep TwentyOctetFingerprint = D1 (MetaData "TwentyOctetFingerprint" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "TwentyOctetFingerprint" PrefixI True) (S1 (MetaSel (Just Symbol "unTOF") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString)))

newtype SpacedFingerprint #

Constructors

SpacedFingerprint |
Fields unSpacedFingerprint :: TwentyOctetFingerprint

Instances

Pretty SpacedFingerprint # |
Methods pretty :: SpacedFingerprint -> Doc e # prettyList :: [SpacedFingerprint] -> Doc e #
Newtype SpacedFingerprint TwentyOctetFingerprint # |
Methods pack :: TwentyOctetFingerprint -> SpacedFingerprint # unpack :: SpacedFingerprint -> TwentyOctetFingerprint #

w8sToHex :: [Word8] -> String #

hexToW8s :: ReadS Word8 #

newtype EightOctetKeyId #

Constructors

EightOctetKeyId |
Fields unEOKI :: ByteString

Instances

Eq EightOctetKeyId # |
Methods (==) :: EightOctetKeyId -> EightOctetKeyId -> Bool # (/=) :: EightOctetKeyId -> EightOctetKeyId -> Bool #
Data EightOctetKeyId # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EightOctetKeyId -> c EightOctetKeyId # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EightOctetKeyId # toConstr :: EightOctetKeyId -> Constr # dataTypeOf :: EightOctetKeyId -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c EightOctetKeyId) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EightOctetKeyId) # gmapT :: (forall b. Data b => b -> b) -> EightOctetKeyId -> EightOctetKeyId # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EightOctetKeyId -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EightOctetKeyId -> r # gmapQ :: (forall d. Data d => d -> u) -> EightOctetKeyId -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> EightOctetKeyId -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> EightOctetKeyId -> m EightOctetKeyId # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EightOctetKeyId -> m EightOctetKeyId # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EightOctetKeyId -> m EightOctetKeyId #
Ord EightOctetKeyId # |
Methods compare :: EightOctetKeyId -> EightOctetKeyId -> Ordering # (<) :: EightOctetKeyId -> EightOctetKeyId -> Bool # (<=) :: EightOctetKeyId -> EightOctetKeyId -> Bool # (>) :: EightOctetKeyId -> EightOctetKeyId -> Bool # (>=) :: EightOctetKeyId -> EightOctetKeyId -> Bool # max :: EightOctetKeyId -> EightOctetKeyId -> EightOctetKeyId # min :: EightOctetKeyId -> EightOctetKeyId -> EightOctetKeyId #
Read EightOctetKeyId # |
Methods readsPrec :: Int -> ReadS EightOctetKeyId # readList :: ReadS [EightOctetKeyId] # readPrec :: ReadPrec EightOctetKeyId # readListPrec :: ReadPrec [EightOctetKeyId] #
Show EightOctetKeyId # |
Methods showsPrec :: Int -> EightOctetKeyId -> ShowS # show :: EightOctetKeyId -> String # showList :: [EightOctetKeyId] -> ShowS #
Generic EightOctetKeyId # |
Associated Types type Rep EightOctetKeyId :: * -> * # Methods from :: EightOctetKeyId -> Rep EightOctetKeyId x # to :: Rep EightOctetKeyId x -> EightOctetKeyId #
ToJSON EightOctetKeyId # |
Methods toJSON :: EightOctetKeyId -> Value # toEncoding :: EightOctetKeyId -> Encoding #
FromJSON EightOctetKeyId # |
Methods parseJSON :: Value -> Parser EightOctetKeyId #
Hashable EightOctetKeyId # |
Methods hashWithSalt :: Int -> EightOctetKeyId -> Int # hash :: EightOctetKeyId -> Int #
Pretty EightOctetKeyId # |
Methods pretty :: EightOctetKeyId -> Doc e # prettyList :: [EightOctetKeyId] -> Doc e #
Newtype EightOctetKeyId ByteString # |
Methods pack :: ByteString -> EightOctetKeyId # unpack :: EightOctetKeyId -> ByteString #
type Rep EightOctetKeyId # |
type Rep EightOctetKeyId = D1 (MetaData "EightOctetKeyId" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "EightOctetKeyId" PrefixI True) (S1 (MetaSel (Just Symbol "unEOKI") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString)))

newtype NotationName #

Constructors

NotationName |
Fields unNotationName :: ByteString

Instances

Eq NotationName # |
Methods (==) :: NotationName -> NotationName -> Bool # (/=) :: NotationName -> NotationName -> Bool #
Data NotationName # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NotationName -> c NotationName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NotationName # toConstr :: NotationName -> Constr # dataTypeOf :: NotationName -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c NotationName) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NotationName) # gmapT :: (forall b. Data b => b -> b) -> NotationName -> NotationName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NotationName -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NotationName -> r # gmapQ :: (forall d. Data d => d -> u) -> NotationName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NotationName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NotationName -> m NotationName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NotationName -> m NotationName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NotationName -> m NotationName #
Ord NotationName # |
Methods compare :: NotationName -> NotationName -> Ordering # (<) :: NotationName -> NotationName -> Bool # (<=) :: NotationName -> NotationName -> Bool # (>) :: NotationName -> NotationName -> Bool # (>=) :: NotationName -> NotationName -> Bool # max :: NotationName -> NotationName -> NotationName # min :: NotationName -> NotationName -> NotationName #
Show NotationName # |
Methods showsPrec :: Int -> NotationName -> ShowS # show :: NotationName -> String # showList :: [NotationName] -> ShowS #
Generic NotationName # |
Associated Types type Rep NotationName :: * -> * # Methods from :: NotationName -> Rep NotationName x # to :: Rep NotationName x -> NotationName #
ToJSON NotationName # |
Methods toJSON :: NotationName -> Value # toEncoding :: NotationName -> Encoding #
FromJSON NotationName # |
Methods parseJSON :: Value -> Parser NotationName #
Hashable NotationName # |
Methods hashWithSalt :: Int -> NotationName -> Int # hash :: NotationName -> Int #
Pretty NotationName # |
Methods pretty :: NotationName -> Doc e # prettyList :: [NotationName] -> Doc e #
Newtype NotationName ByteString # |
Methods pack :: ByteString -> NotationName # unpack :: NotationName -> ByteString #
type Rep NotationName # |
type Rep NotationName = D1 (MetaData "NotationName" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "NotationName" PrefixI True) (S1 (MetaSel (Just Symbol "unNotationName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString)))

newtype NotationValue #

Constructors

NotationValue |
Fields unNotationValue :: ByteString

Instances

Eq NotationValue # |
Methods (==) :: NotationValue -> NotationValue -> Bool # (/=) :: NotationValue -> NotationValue -> Bool #
Data NotationValue # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NotationValue -> c NotationValue # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NotationValue # toConstr :: NotationValue -> Constr # dataTypeOf :: NotationValue -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c NotationValue) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NotationValue) # gmapT :: (forall b. Data b => b -> b) -> NotationValue -> NotationValue # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NotationValue -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NotationValue -> r # gmapQ :: (forall d. Data d => d -> u) -> NotationValue -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NotationValue -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NotationValue -> m NotationValue # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NotationValue -> m NotationValue # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NotationValue -> m NotationValue #
Ord NotationValue # |
Methods compare :: NotationValue -> NotationValue -> Ordering # (<) :: NotationValue -> NotationValue -> Bool # (<=) :: NotationValue -> NotationValue -> Bool # (>) :: NotationValue -> NotationValue -> Bool # (>=) :: NotationValue -> NotationValue -> Bool # max :: NotationValue -> NotationValue -> NotationValue # min :: NotationValue -> NotationValue -> NotationValue #
Show NotationValue # |
Methods showsPrec :: Int -> NotationValue -> ShowS # show :: NotationValue -> String # showList :: [NotationValue] -> ShowS #
Generic NotationValue # |
Associated Types type Rep NotationValue :: * -> * # Methods from :: NotationValue -> Rep NotationValue x # to :: Rep NotationValue x -> NotationValue #
ToJSON NotationValue # |
Methods toJSON :: NotationValue -> Value # toEncoding :: NotationValue -> Encoding #
FromJSON NotationValue # |
Methods parseJSON :: Value -> Parser NotationValue #
Hashable NotationValue # |
Methods hashWithSalt :: Int -> NotationValue -> Int # hash :: NotationValue -> Int #
Pretty NotationValue # |
Methods pretty :: NotationValue -> Doc e # prettyList :: [NotationValue] -> Doc e #
Newtype NotationValue ByteString # |
Methods pack :: ByteString -> NotationValue # unpack :: NotationValue -> ByteString #
type Rep NotationValue # |
type Rep NotationValue = D1 (MetaData "NotationValue" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "NotationValue" PrefixI True) (S1 (MetaSel (Just Symbol "unNotationValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString)))

data HashAlgorithm #

Constructors

DeprecatedMD5 |
SHA1 |
RIPEMD160 |
SHA256 |
SHA384 |
SHA512 |
SHA224 |
OtherHA Word8 |

Instances

Eq HashAlgorithm # |
Methods (==) :: HashAlgorithm -> HashAlgorithm -> Bool # (/=) :: HashAlgorithm -> HashAlgorithm -> Bool #
Data HashAlgorithm # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HashAlgorithm -> c HashAlgorithm # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HashAlgorithm # toConstr :: HashAlgorithm -> Constr # dataTypeOf :: HashAlgorithm -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c HashAlgorithm) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HashAlgorithm) # gmapT :: (forall b. Data b => b -> b) -> HashAlgorithm -> HashAlgorithm # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HashAlgorithm -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HashAlgorithm -> r # gmapQ :: (forall d. Data d => d -> u) -> HashAlgorithm -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HashAlgorithm -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HashAlgorithm -> m HashAlgorithm # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HashAlgorithm -> m HashAlgorithm # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HashAlgorithm -> m HashAlgorithm #
Ord HashAlgorithm # |
Methods compare :: HashAlgorithm -> HashAlgorithm -> Ordering # (<) :: HashAlgorithm -> HashAlgorithm -> Bool # (<=) :: HashAlgorithm -> HashAlgorithm -> Bool # (>) :: HashAlgorithm -> HashAlgorithm -> Bool # (>=) :: HashAlgorithm -> HashAlgorithm -> Bool # max :: HashAlgorithm -> HashAlgorithm -> HashAlgorithm # min :: HashAlgorithm -> HashAlgorithm -> HashAlgorithm #
Show HashAlgorithm # |
Methods showsPrec :: Int -> HashAlgorithm -> ShowS # show :: HashAlgorithm -> String # showList :: [HashAlgorithm] -> ShowS #
Generic HashAlgorithm # |
Associated Types type Rep HashAlgorithm :: * -> * # Methods from :: HashAlgorithm -> Rep HashAlgorithm x # to :: Rep HashAlgorithm x -> HashAlgorithm #
ToJSON HashAlgorithm # |
Methods toJSON :: HashAlgorithm -> Value # toEncoding :: HashAlgorithm -> Encoding #
FromJSON HashAlgorithm # |
Methods parseJSON :: Value -> Parser HashAlgorithm #
Hashable HashAlgorithm # |
Methods hashWithSalt :: Int -> HashAlgorithm -> Int # hash :: HashAlgorithm -> Int #
Pretty HashAlgorithm # |
Methods pretty :: HashAlgorithm -> Doc e # prettyList :: [HashAlgorithm] -> Doc e #
FutureVal HashAlgorithm # |
Methods fromFVal :: HashAlgorithm -> Word8 # toFVal :: Word8 -> HashAlgorithm #
type Rep HashAlgorithm # |
type Rep HashAlgorithm = D1 (MetaData "HashAlgorithm" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "DeprecatedMD5" PrefixI False) U1) (C1 (MetaCons "SHA1" PrefixI False) U1)) ((:+:) (C1 (MetaCons "RIPEMD160" PrefixI False) U1) (C1 (MetaCons "SHA256" PrefixI False) U1))) ((:+:) ((:+:) (C1 (MetaCons "SHA384" PrefixI False) U1) (C1 (MetaCons "SHA512" PrefixI False) U1)) ((:+:) (C1 (MetaCons "SHA224" PrefixI False) U1) (C1 (MetaCons "OtherHA" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word8))))))

data CompressionAlgorithm #

Constructors

Uncompressed |
ZIP |
ZLIB |
BZip2 |
OtherCA Word8 |

Instances

Eq CompressionAlgorithm # |
Methods (==) :: CompressionAlgorithm -> CompressionAlgorithm -> Bool # (/=) :: CompressionAlgorithm -> CompressionAlgorithm -> Bool #
Data CompressionAlgorithm # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CompressionAlgorithm -> c CompressionAlgorithm # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CompressionAlgorithm # toConstr :: CompressionAlgorithm -> Constr # dataTypeOf :: CompressionAlgorithm -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c CompressionAlgorithm) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompressionAlgorithm) # gmapT :: (forall b. Data b => b -> b) -> CompressionAlgorithm -> CompressionAlgorithm # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CompressionAlgorithm -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CompressionAlgorithm -> r # gmapQ :: (forall d. Data d => d -> u) -> CompressionAlgorithm -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CompressionAlgorithm -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CompressionAlgorithm -> m CompressionAlgorithm # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CompressionAlgorithm -> m CompressionAlgorithm # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CompressionAlgorithm -> m CompressionAlgorithm #
Ord CompressionAlgorithm # |
Methods compare :: CompressionAlgorithm -> CompressionAlgorithm -> Ordering # (<) :: CompressionAlgorithm -> CompressionAlgorithm -> Bool # (<=) :: CompressionAlgorithm -> CompressionAlgorithm -> Bool # (>) :: CompressionAlgorithm -> CompressionAlgorithm -> Bool # (>=) :: CompressionAlgorithm -> CompressionAlgorithm -> Bool # max :: CompressionAlgorithm -> CompressionAlgorithm -> CompressionAlgorithm # min :: CompressionAlgorithm -> CompressionAlgorithm -> CompressionAlgorithm #
Show CompressionAlgorithm # |
Methods showsPrec :: Int -> CompressionAlgorithm -> ShowS # show :: CompressionAlgorithm -> String # showList :: [CompressionAlgorithm] -> ShowS #
Generic CompressionAlgorithm # |
Associated Types type Rep CompressionAlgorithm :: * -> * # Methods from :: CompressionAlgorithm -> Rep CompressionAlgorithm x # to :: Rep CompressionAlgorithm x -> CompressionAlgorithm #
ToJSON CompressionAlgorithm # |
Methods toJSON :: CompressionAlgorithm -> Value # toEncoding :: CompressionAlgorithm -> Encoding #
FromJSON CompressionAlgorithm # |
Methods parseJSON :: Value -> Parser CompressionAlgorithm #
Hashable CompressionAlgorithm # |
Methods hashWithSalt :: Int -> CompressionAlgorithm -> Int # hash :: CompressionAlgorithm -> Int #
Pretty CompressionAlgorithm # |
Methods pretty :: CompressionAlgorithm -> Doc e # prettyList :: [CompressionAlgorithm] -> Doc e #
FutureVal CompressionAlgorithm # |
Methods fromFVal :: CompressionAlgorithm -> Word8 # toFVal :: Word8 -> CompressionAlgorithm #
type Rep CompressionAlgorithm # |
type Rep CompressionAlgorithm = D1 (MetaData "CompressionAlgorithm" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) ((:+:) (C1 (MetaCons "Uncompressed" PrefixI False) U1) (C1 (MetaCons "ZIP" PrefixI False) U1)) ((:+:) (C1 (MetaCons "ZLIB" PrefixI False) U1) ((:+:) (C1 (MetaCons "BZip2" PrefixI False) U1) (C1 (MetaCons "OtherCA" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word8))))))

data KSPFlag #

Constructors

NoModify |
KSPOther Int |

Instances

Eq KSPFlag # |
Methods (==) :: KSPFlag -> KSPFlag -> Bool # (/=) :: KSPFlag -> KSPFlag -> Bool #
Data KSPFlag # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> KSPFlag -> c KSPFlag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c KSPFlag # toConstr :: KSPFlag -> Constr # dataTypeOf :: KSPFlag -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c KSPFlag) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KSPFlag) # gmapT :: (forall b. Data b => b -> b) -> KSPFlag -> KSPFlag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> KSPFlag -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> KSPFlag -> r # gmapQ :: (forall d. Data d => d -> u) -> KSPFlag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> KSPFlag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> KSPFlag -> m KSPFlag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> KSPFlag -> m KSPFlag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> KSPFlag -> m KSPFlag #
Ord KSPFlag # |
Methods compare :: KSPFlag -> KSPFlag -> Ordering # (<) :: KSPFlag -> KSPFlag -> Bool # (<=) :: KSPFlag -> KSPFlag -> Bool # (>) :: KSPFlag -> KSPFlag -> Bool # (>=) :: KSPFlag -> KSPFlag -> Bool # max :: KSPFlag -> KSPFlag -> KSPFlag # min :: KSPFlag -> KSPFlag -> KSPFlag #
Show KSPFlag # |
Methods showsPrec :: Int -> KSPFlag -> ShowS # show :: KSPFlag -> String # showList :: [KSPFlag] -> ShowS #
Generic KSPFlag # |
Associated Types type Rep KSPFlag :: * -> * # Methods from :: KSPFlag -> Rep KSPFlag x # to :: Rep KSPFlag x -> KSPFlag #
ToJSON KSPFlag # |
Methods toJSON :: KSPFlag -> Value # toEncoding :: KSPFlag -> Encoding #
FromJSON KSPFlag # |
Methods parseJSON :: Value -> Parser KSPFlag #
Hashable KSPFlag # |
Methods hashWithSalt :: Int -> KSPFlag -> Int # hash :: KSPFlag -> Int #
Pretty KSPFlag # |
Methods pretty :: KSPFlag -> Doc e # prettyList :: [KSPFlag] -> Doc e #
FutureFlag KSPFlag # |
Methods fromFFlag :: KSPFlag -> Int # toFFlag :: Int -> KSPFlag #
type Rep KSPFlag # |
type Rep KSPFlag = D1 (MetaData "KSPFlag" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) (C1 (MetaCons "NoModify" PrefixI False) U1) (C1 (MetaCons "KSPOther" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int))))

data KeyFlag #

Constructors

GroupKey |
AuthKey |
SplitKey |
EncryptStorageKey |
EncryptCommunicationsKey |
SignDataKey |
CertifyKeysKey |
KFOther Int |

Instances

Eq KeyFlag # |
Methods (==) :: KeyFlag -> KeyFlag -> Bool # (/=) :: KeyFlag -> KeyFlag -> Bool #
Data KeyFlag # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> KeyFlag -> c KeyFlag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c KeyFlag # toConstr :: KeyFlag -> Constr # dataTypeOf :: KeyFlag -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c KeyFlag) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeyFlag) # gmapT :: (forall b. Data b => b -> b) -> KeyFlag -> KeyFlag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> KeyFlag -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> KeyFlag -> r # gmapQ :: (forall d. Data d => d -> u) -> KeyFlag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> KeyFlag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> KeyFlag -> m KeyFlag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> KeyFlag -> m KeyFlag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> KeyFlag -> m KeyFlag #
Ord KeyFlag # |
Methods compare :: KeyFlag -> KeyFlag -> Ordering # (<) :: KeyFlag -> KeyFlag -> Bool # (<=) :: KeyFlag -> KeyFlag -> Bool # (>) :: KeyFlag -> KeyFlag -> Bool # (>=) :: KeyFlag -> KeyFlag -> Bool # max :: KeyFlag -> KeyFlag -> KeyFlag # min :: KeyFlag -> KeyFlag -> KeyFlag #
Show KeyFlag # |
Methods showsPrec :: Int -> KeyFlag -> ShowS # show :: KeyFlag -> String # showList :: [KeyFlag] -> ShowS #
Generic KeyFlag # |
Associated Types type Rep KeyFlag :: * -> * # Methods from :: KeyFlag -> Rep KeyFlag x # to :: Rep KeyFlag x -> KeyFlag #
ToJSON KeyFlag # |
Methods toJSON :: KeyFlag -> Value # toEncoding :: KeyFlag -> Encoding #
FromJSON KeyFlag # |
Methods parseJSON :: Value -> Parser KeyFlag #
Hashable KeyFlag # |
Methods hashWithSalt :: Int -> KeyFlag -> Int # hash :: KeyFlag -> Int #
Pretty KeyFlag # |
Methods pretty :: KeyFlag -> Doc e # prettyList :: [KeyFlag] -> Doc e #
FutureFlag KeyFlag # |
Methods fromFFlag :: KeyFlag -> Int # toFFlag :: Int -> KeyFlag #
type Rep KeyFlag # |
type Rep KeyFlag = D1 (MetaData "KeyFlag" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "GroupKey" PrefixI False) U1) (C1 (MetaCons "AuthKey" PrefixI False) U1)) ((:+:) (C1 (MetaCons "SplitKey" PrefixI False) U1) (C1 (MetaCons "EncryptStorageKey" PrefixI False) U1))) ((:+:) ((:+:) (C1 (MetaCons "EncryptCommunicationsKey" PrefixI False) U1) (C1 (MetaCons "SignDataKey" PrefixI False) U1)) ((:+:) (C1 (MetaCons "CertifyKeysKey" PrefixI False) U1) (C1 (MetaCons "KFOther" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int))))))

data RevocationCode #

Constructors

NoReason |
KeySuperseded |
KeyMaterialCompromised |
KeyRetiredAndNoLongerUsed |
UserIdInfoNoLongerValid |
RCoOther Word8 |

Instances

Eq RevocationCode # |
Methods (==) :: RevocationCode -> RevocationCode -> Bool # (/=) :: RevocationCode -> RevocationCode -> Bool #
Data RevocationCode # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RevocationCode -> c RevocationCode # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RevocationCode # toConstr :: RevocationCode -> Constr # dataTypeOf :: RevocationCode -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c RevocationCode) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RevocationCode) # gmapT :: (forall b. Data b => b -> b) -> RevocationCode -> RevocationCode # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RevocationCode -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RevocationCode -> r # gmapQ :: (forall d. Data d => d -> u) -> RevocationCode -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RevocationCode -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RevocationCode -> m RevocationCode # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RevocationCode -> m RevocationCode # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RevocationCode -> m RevocationCode #
Ord RevocationCode # |
Methods compare :: RevocationCode -> RevocationCode -> Ordering # (<) :: RevocationCode -> RevocationCode -> Bool # (<=) :: RevocationCode -> RevocationCode -> Bool # (>) :: RevocationCode -> RevocationCode -> Bool # (>=) :: RevocationCode -> RevocationCode -> Bool # max :: RevocationCode -> RevocationCode -> RevocationCode # min :: RevocationCode -> RevocationCode -> RevocationCode #
Show RevocationCode # |
Methods showsPrec :: Int -> RevocationCode -> ShowS # show :: RevocationCode -> String # showList :: [RevocationCode] -> ShowS #
Generic RevocationCode # |
Associated Types type Rep RevocationCode :: * -> * # Methods from :: RevocationCode -> Rep RevocationCode x # to :: Rep RevocationCode x -> RevocationCode #
ToJSON RevocationCode # |
Methods toJSON :: RevocationCode -> Value # toEncoding :: RevocationCode -> Encoding #
FromJSON RevocationCode # |
Methods parseJSON :: Value -> Parser RevocationCode #
Hashable RevocationCode # |
Methods hashWithSalt :: Int -> RevocationCode -> Int # hash :: RevocationCode -> Int #
Pretty RevocationCode # |
Methods pretty :: RevocationCode -> Doc e # prettyList :: [RevocationCode] -> Doc e #
FutureVal RevocationCode # |
Methods fromFVal :: RevocationCode -> Word8 # toFVal :: Word8 -> RevocationCode #
type Rep RevocationCode # |
type Rep RevocationCode = D1 (MetaData "RevocationCode" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) ((:+:) (C1 (MetaCons "NoReason" PrefixI False) U1) ((:+:) (C1 (MetaCons "KeySuperseded" PrefixI False) U1) (C1 (MetaCons "KeyMaterialCompromised" PrefixI False) U1))) ((:+:) (C1 (MetaCons "KeyRetiredAndNoLongerUsed" PrefixI False) U1) ((:+:) (C1 (MetaCons "UserIdInfoNoLongerValid" PrefixI False) U1) (C1 (MetaCons "RCoOther" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word8))))))

data FeatureFlag #

Constructors

ModificationDetection |
FeatureOther Int |

Instances

Eq FeatureFlag # |
Methods (==) :: FeatureFlag -> FeatureFlag -> Bool # (/=) :: FeatureFlag -> FeatureFlag -> Bool #
Data FeatureFlag # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FeatureFlag -> c FeatureFlag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FeatureFlag # toConstr :: FeatureFlag -> Constr # dataTypeOf :: FeatureFlag -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FeatureFlag) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FeatureFlag) # gmapT :: (forall b. Data b => b -> b) -> FeatureFlag -> FeatureFlag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FeatureFlag -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FeatureFlag -> r # gmapQ :: (forall d. Data d => d -> u) -> FeatureFlag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FeatureFlag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FeatureFlag -> m FeatureFlag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FeatureFlag -> m FeatureFlag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FeatureFlag -> m FeatureFlag #
Ord FeatureFlag # |
Methods compare :: FeatureFlag -> FeatureFlag -> Ordering # (<) :: FeatureFlag -> FeatureFlag -> Bool # (<=) :: FeatureFlag -> FeatureFlag -> Bool # (>) :: FeatureFlag -> FeatureFlag -> Bool # (>=) :: FeatureFlag -> FeatureFlag -> Bool # max :: FeatureFlag -> FeatureFlag -> FeatureFlag # min :: FeatureFlag -> FeatureFlag -> FeatureFlag #
Show FeatureFlag # |
Methods showsPrec :: Int -> FeatureFlag -> ShowS # show :: FeatureFlag -> String # showList :: [FeatureFlag] -> ShowS #
Generic FeatureFlag # |
Associated Types type Rep FeatureFlag :: * -> * # Methods from :: FeatureFlag -> Rep FeatureFlag x # to :: Rep FeatureFlag x -> FeatureFlag #
ToJSON FeatureFlag # |
Methods toJSON :: FeatureFlag -> Value # toEncoding :: FeatureFlag -> Encoding #
FromJSON FeatureFlag # |
Methods parseJSON :: Value -> Parser FeatureFlag #
Hashable FeatureFlag # |
Methods hashWithSalt :: Int -> FeatureFlag -> Int # hash :: FeatureFlag -> Int #
Pretty FeatureFlag # |
Methods pretty :: FeatureFlag -> Doc e # prettyList :: [FeatureFlag] -> Doc e #
FutureFlag FeatureFlag # |
Methods fromFFlag :: FeatureFlag -> Int # toFFlag :: Int -> FeatureFlag #
type Rep FeatureFlag # |
type Rep FeatureFlag = D1 (MetaData "FeatureFlag" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) (C1 (MetaCons "ModificationDetection" PrefixI False) U1) (C1 (MetaCons "FeatureOther" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int))))

newtype URL #

Constructors

URL |
Fields unURL :: URI

Instances

Eq URL # |
Methods (==) :: URL -> URL -> Bool # (/=) :: URL -> URL -> Bool #
Data URL # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> URL -> c URL # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c URL # toConstr :: URL -> Constr # dataTypeOf :: URL -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c URL) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c URL) # gmapT :: (forall b. Data b => b -> b) -> URL -> URL # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r # gmapQ :: (forall d. Data d => d -> u) -> URL -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> URL -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> URL -> m URL # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> URL -> m URL # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> URL -> m URL #
Ord URL # |
Methods compare :: URL -> URL -> Ordering # (<) :: URL -> URL -> Bool # (<=) :: URL -> URL -> Bool # (>) :: URL -> URL -> Bool # (>=) :: URL -> URL -> Bool # max :: URL -> URL -> URL # min :: URL -> URL -> URL #
Show URL # |
Methods showsPrec :: Int -> URL -> ShowS # show :: URL -> String # showList :: [URL] -> ShowS #
Generic URL # |
Associated Types type Rep URL :: * -> * # Methods from :: URL -> Rep URL x # to :: Rep URL x -> URL #
ToJSON URL # |
Methods toJSON :: URL -> Value # toEncoding :: URL -> Encoding #
FromJSON URL # |
Methods parseJSON :: Value -> Parser URL #
Hashable URL # |
Methods hashWithSalt :: Int -> URL -> Int # hash :: URL -> Int #
Pretty URL # |
Methods pretty :: URL -> Doc e # prettyList :: [URL] -> Doc e #
Newtype URL URI # |
Methods pack :: URI -> URL # unpack :: URL -> URI #
type Rep URL # |
type Rep URL = D1 (MetaData "URL" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "URL" PrefixI True) (S1 (MetaSel (Just Symbol "unURL") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 URI)))

data SigType #

Constructors

BinarySig |
CanonicalTextSig |
StandaloneSig |
GenericCert |
PersonaCert |
CasualCert |
PositiveCert |
SubkeyBindingSig |
PrimaryKeyBindingSig |
SignatureDirectlyOnAKey |
KeyRevocationSig |
SubkeyRevocationSig |
CertRevocationSig |
TimestampSig |
ThirdPartyConfirmationSig |
OtherSig Word8 |

Instances

Eq SigType # |
Methods (==) :: SigType -> SigType -> Bool # (/=) :: SigType -> SigType -> Bool #
Data SigType # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SigType -> c SigType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SigType # toConstr :: SigType -> Constr # dataTypeOf :: SigType -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SigType) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SigType) # gmapT :: (forall b. Data b => b -> b) -> SigType -> SigType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SigType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SigType -> r # gmapQ :: (forall d. Data d => d -> u) -> SigType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SigType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SigType -> m SigType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SigType -> m SigType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SigType -> m SigType #
Ord SigType # |
Methods compare :: SigType -> SigType -> Ordering # (<) :: SigType -> SigType -> Bool # (<=) :: SigType -> SigType -> Bool # (>) :: SigType -> SigType -> Bool # (>=) :: SigType -> SigType -> Bool # max :: SigType -> SigType -> SigType # min :: SigType -> SigType -> SigType #
Show SigType # |
Methods showsPrec :: Int -> SigType -> ShowS # show :: SigType -> String # showList :: [SigType] -> ShowS #
Generic SigType # |
Associated Types type Rep SigType :: * -> * # Methods from :: SigType -> Rep SigType x # to :: Rep SigType x -> SigType #
ToJSON SigType # |
Methods toJSON :: SigType -> Value # toEncoding :: SigType -> Encoding #
FromJSON SigType # |
Methods parseJSON :: Value -> Parser SigType #
Hashable SigType # |
Methods hashWithSalt :: Int -> SigType -> Int # hash :: SigType -> Int #
Pretty SigType # |
Methods pretty :: SigType -> Doc e # prettyList :: [SigType] -> Doc e #
FutureVal SigType # |
Methods fromFVal :: SigType -> Word8 # toFVal :: Word8 -> SigType #
type Rep SigType # |
type Rep SigType = D1 (MetaData "SigType" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "BinarySig" PrefixI False) U1) (C1 (MetaCons "CanonicalTextSig" PrefixI False) U1)) ((:+:) (C1 (MetaCons "StandaloneSig" PrefixI False) U1) (C1 (MetaCons "GenericCert" PrefixI False) U1))) ((:+:) ((:+:) (C1 (MetaCons "PersonaCert" PrefixI False) U1) (C1 (MetaCons "CasualCert" PrefixI False) U1)) ((:+:) (C1 (MetaCons "PositiveCert" PrefixI False) U1) (C1 (MetaCons "SubkeyBindingSig" PrefixI False) U1)))) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "PrimaryKeyBindingSig" PrefixI False) U1) (C1 (MetaCons "SignatureDirectlyOnAKey" PrefixI False) U1)) ((:+:) (C1 (MetaCons "KeyRevocationSig" PrefixI False) U1) (C1 (MetaCons "SubkeyRevocationSig" PrefixI False) U1))) ((:+:) ((:+:) (C1 (MetaCons "CertRevocationSig" PrefixI False) U1) (C1 (MetaCons "TimestampSig" PrefixI False) U1)) ((:+:) (C1 (MetaCons "ThirdPartyConfirmationSig" PrefixI False) U1) (C1 (MetaCons "OtherSig" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word8)))))))

newtype MPI #

Constructors

MPI |
Fields unMPI :: Integer

Instances

Eq MPI # |
Methods (==) :: MPI -> MPI -> Bool # (/=) :: MPI -> MPI -> Bool #
Data MPI # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MPI -> c MPI # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MPI # toConstr :: MPI -> Constr # dataTypeOf :: MPI -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c MPI) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MPI) # gmapT :: (forall b. Data b => b -> b) -> MPI -> MPI # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MPI -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MPI -> r # gmapQ :: (forall d. Data d => d -> u) -> MPI -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> MPI -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> MPI -> m MPI # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MPI -> m MPI # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MPI -> m MPI #
Show MPI # |
Methods showsPrec :: Int -> MPI -> ShowS # show :: MPI -> String # showList :: [MPI] -> ShowS #
Generic MPI # |
Associated Types type Rep MPI :: * -> * # Methods from :: MPI -> Rep MPI x # to :: Rep MPI x -> MPI #
ToJSON MPI # |
Methods toJSON :: MPI -> Value # toEncoding :: MPI -> Encoding #
FromJSON MPI # |
Methods parseJSON :: Value -> Parser MPI #
Hashable MPI # |
Methods hashWithSalt :: Int -> MPI -> Int # hash :: MPI -> Int #
Pretty MPI # |
Methods pretty :: MPI -> Doc e # prettyList :: [MPI] -> Doc e #
Newtype MPI Integer # |
Methods pack :: Integer -> MPI # unpack :: MPI -> Integer #
type Rep MPI # |
type Rep MPI = D1 (MetaData "MPI" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "MPI" PrefixI True) (S1 (MetaSel (Just Symbol "unMPI") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer)))

data SignaturePayload #

Constructors

SigV3 SigType ThirtyTwoBitTimeStamp EightOctetKeyId PubKeyAlgorithm HashAlgorithm Word16 (NonEmpty MPI) |
SigV4 SigType PubKeyAlgorithm HashAlgorithm [SigSubPacket] [SigSubPacket] Word16 (NonEmpty MPI) |
SigVOther Word8 ByteString |

Instances

Eq SignaturePayload # |
Methods (==) :: SignaturePayload -> SignaturePayload -> Bool # (/=) :: SignaturePayload -> SignaturePayload -> Bool #
Data SignaturePayload # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SignaturePayload -> c SignaturePayload # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SignaturePayload # toConstr :: SignaturePayload -> Constr # dataTypeOf :: SignaturePayload -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SignaturePayload) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SignaturePayload) # gmapT :: (forall b. Data b => b -> b) -> SignaturePayload -> SignaturePayload # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SignaturePayload -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SignaturePayload -> r # gmapQ :: (forall d. Data d => d -> u) -> SignaturePayload -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SignaturePayload -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SignaturePayload -> m SignaturePayload # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SignaturePayload -> m SignaturePayload # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SignaturePayload -> m SignaturePayload #
Show SignaturePayload # |
Methods showsPrec :: Int -> SignaturePayload -> ShowS # show :: SignaturePayload -> String # showList :: [SignaturePayload] -> ShowS #
Generic SignaturePayload # |
Associated Types type Rep SignaturePayload :: * -> * # Methods from :: SignaturePayload -> Rep SignaturePayload x # to :: Rep SignaturePayload x -> SignaturePayload #
ToJSON SignaturePayload # |
Methods toJSON :: SignaturePayload -> Value # toEncoding :: SignaturePayload -> Encoding #
Hashable SignaturePayload # |
Methods hashWithSalt :: Int -> SignaturePayload -> Int # hash :: SignaturePayload -> Int #
Pretty SignaturePayload # |
Methods pretty :: SignaturePayload -> Doc e # prettyList :: [SignaturePayload] -> Doc e #
type Rep SignaturePayload # |
type Rep SignaturePayload = D1 (MetaData "SignaturePayload" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) (C1 (MetaCons "SigV3" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SigType)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ThirtyTwoBitTimeStamp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 EightOctetKeyId)))) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PubKeyAlgorithm)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 HashAlgorithm))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word16)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty MPI))))))) ((:+:) (C1 (MetaCons "SigV4" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SigType)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PubKeyAlgorithm)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 HashAlgorithm)))) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [SigSubPacket])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [SigSubPacket]))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word16)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty MPI))))))) (C1 (MetaCons "SigVOther" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word8)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString))))))

data SigSubPacketPayload #

Constructors

SigCreationTime ThirtyTwoBitTimeStamp |
SigExpirationTime ThirtyTwoBitDuration |
ExportableCertification Exportability |
TrustSignature TrustLevel TrustAmount |
RegularExpression AlmostPublicDomainRegex |
Revocable Revocability |
KeyExpirationTime ThirtyTwoBitDuration |
PreferredSymmetricAlgorithms [SymmetricAlgorithm] |
RevocationKey (Set RevocationClass) PubKeyAlgorithm TwentyOctetFingerprint |
Issuer EightOctetKeyId |
NotationData (Set NotationFlag) NotationName NotationValue |
PreferredHashAlgorithms [HashAlgorithm] |
PreferredCompressionAlgorithms [CompressionAlgorithm] |
KeyServerPreferences (Set KSPFlag) |
PreferredKeyServer KeyServer |
PrimaryUserId Bool |
PolicyURL URL |
KeyFlags (Set KeyFlag) |
SignersUserId Text |
ReasonForRevocation RevocationCode RevocationReason |
Features (Set FeatureFlag) |
SignatureTarget PubKeyAlgorithm HashAlgorithm SignatureHash |
EmbeddedSignature SignaturePayload |
UserDefinedSigSub Word8 ByteString |
OtherSigSub Word8 ByteString |

Instances

Eq SigSubPacketPayload # |
Methods (==) :: SigSubPacketPayload -> SigSubPacketPayload -> Bool # (/=) :: SigSubPacketPayload -> SigSubPacketPayload -> Bool #
Data SigSubPacketPayload # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SigSubPacketPayload -> c SigSubPacketPayload # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SigSubPacketPayload # toConstr :: SigSubPacketPayload -> Constr # dataTypeOf :: SigSubPacketPayload -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SigSubPacketPayload) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SigSubPacketPayload) # gmapT :: (forall b. Data b => b -> b) -> SigSubPacketPayload -> SigSubPacketPayload # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SigSubPacketPayload -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SigSubPacketPayload -> r # gmapQ :: (forall d. Data d => d -> u) -> SigSubPacketPayload -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SigSubPacketPayload -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SigSubPacketPayload -> m SigSubPacketPayload # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SigSubPacketPayload -> m SigSubPacketPayload # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SigSubPacketPayload -> m SigSubPacketPayload #
Show SigSubPacketPayload # |
Methods showsPrec :: Int -> SigSubPacketPayload -> ShowS # show :: SigSubPacketPayload -> String # showList :: [SigSubPacketPayload] -> ShowS #
Generic SigSubPacketPayload # |
Associated Types type Rep SigSubPacketPayload :: * -> * # Methods from :: SigSubPacketPayload -> Rep SigSubPacketPayload x # to :: Rep SigSubPacketPayload x -> SigSubPacketPayload #
ToJSON SigSubPacketPayload # |
Methods toJSON :: SigSubPacketPayload -> Value # toEncoding :: SigSubPacketPayload -> Encoding #
FromJSON SigSubPacketPayload # |
Methods parseJSON :: Value -> Parser SigSubPacketPayload #
Hashable SigSubPacketPayload # |
Methods hashWithSalt :: Int -> SigSubPacketPayload -> Int # hash :: SigSubPacketPayload -> Int #
Pretty SigSubPacketPayload # |
Methods pretty :: SigSubPacketPayload -> Doc e # prettyList :: [SigSubPacketPayload] -> Doc e #
type Rep SigSubPacketPayload # |
type Rep SigSubPacketPayload = D1 (MetaData "SigSubPacketPayload" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "SigCreationTime" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ThirtyTwoBitTimeStamp))) ((:+:) (C1 (MetaCons "SigExpirationTime" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ThirtyTwoBitDuration))) (C1 (MetaCons "ExportableCertification" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exportability))))) ((:+:) (C1 (MetaCons "TrustSignature" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 TrustLevel)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 TrustAmount)))) ((:+:) (C1 (MetaCons "RegularExpression" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 AlmostPublicDomainRegex))) (C1 (MetaCons "Revocable" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Revocability)))))) ((:+:) ((:+:) (C1 (MetaCons "KeyExpirationTime" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ThirtyTwoBitDuration))) ((:+:) (C1 (MetaCons "PreferredSymmetricAlgorithms" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [SymmetricAlgorithm]))) (C1 (MetaCons "RevocationKey" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Set RevocationClass))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PubKeyAlgorithm)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 TwentyOctetFingerprint))))))) ((:+:) (C1 (MetaCons "Issuer" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 EightOctetKeyId))) ((:+:) (C1 (MetaCons "NotationData" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Set NotationFlag))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 NotationName)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 NotationValue))))) (C1 (MetaCons "PreferredHashAlgorithms" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [HashAlgorithm]))))))) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "PreferredCompressionAlgorithms" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [CompressionAlgorithm]))) ((:+:) (C1 (MetaCons "KeyServerPreferences" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Set KSPFlag)))) (C1 (MetaCons "PreferredKeyServer" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 KeyServer))))) ((:+:) (C1 (MetaCons "PrimaryUserId" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool))) ((:+:) (C1 (MetaCons "PolicyURL" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 URL))) (C1 (MetaCons "KeyFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Set KeyFlag))))))) ((:+:) ((:+:) (C1 (MetaCons "SignersUserId" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text))) ((:+:) (C1 (MetaCons "ReasonForRevocation" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 RevocationCode)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 RevocationReason)))) (C1 (MetaCons "Features" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Set FeatureFlag)))))) ((:+:) ((:+:) (C1 (MetaCons "SignatureTarget" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PubKeyAlgorithm)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 HashAlgorithm)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SignatureHash))))) (C1 (MetaCons "EmbeddedSignature" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SignaturePayload)))) ((:+:) (C1 (MetaCons "UserDefinedSigSub" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word8)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString)))) (C1 (MetaCons "OtherSigSub" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word8)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString)))))))))

uc3 :: (a -> b -> c -> d) -> (a, b, c) -> d #

data SigSubPacket #

Constructors

SigSubPacket |
Fields _sspCriticality :: Bool _sspPayload :: SigSubPacketPayload

Instances

Eq SigSubPacket # |
Methods (==) :: SigSubPacket -> SigSubPacket -> Bool # (/=) :: SigSubPacket -> SigSubPacket -> Bool #
Data SigSubPacket # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SigSubPacket -> c SigSubPacket # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SigSubPacket # toConstr :: SigSubPacket -> Constr # dataTypeOf :: SigSubPacket -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SigSubPacket) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SigSubPacket) # gmapT :: (forall b. Data b => b -> b) -> SigSubPacket -> SigSubPacket # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SigSubPacket -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SigSubPacket -> r # gmapQ :: (forall d. Data d => d -> u) -> SigSubPacket -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SigSubPacket -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SigSubPacket -> m SigSubPacket # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SigSubPacket -> m SigSubPacket # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SigSubPacket -> m SigSubPacket #
Show SigSubPacket # |
Methods showsPrec :: Int -> SigSubPacket -> ShowS # show :: SigSubPacket -> String # showList :: [SigSubPacket] -> ShowS #
Generic SigSubPacket # |
Associated Types type Rep SigSubPacket :: * -> * # Methods from :: SigSubPacket -> Rep SigSubPacket x # to :: Rep SigSubPacket x -> SigSubPacket #
ToJSON SigSubPacket # |
Methods toJSON :: SigSubPacket -> Value # toEncoding :: SigSubPacket -> Encoding #
FromJSON SigSubPacket # |
Methods parseJSON :: Value -> Parser SigSubPacket #
Hashable SigSubPacket # |
Methods hashWithSalt :: Int -> SigSubPacket -> Int # hash :: SigSubPacket -> Int #
Pretty SigSubPacket # |
Methods pretty :: SigSubPacket -> Doc e # prettyList :: [SigSubPacket] -> Doc e #
type Rep SigSubPacket # |
type Rep SigSubPacket = D1 (MetaData "SigSubPacket" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) (C1 (MetaCons "SigSubPacket" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "_sspCriticality") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool)) (S1 (MetaSel (Just Symbol "_sspPayload") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SigSubPacketPayload))))

sspPayload :: Lens' SigSubPacket SigSubPacketPayload #

sspCriticality :: Lens' SigSubPacket Bool #

data KeyVersion #

Constructors

DeprecatedV3 |
V4 |

Instances

Eq KeyVersion # |
Methods (==) :: KeyVersion -> KeyVersion -> Bool # (/=) :: KeyVersion -> KeyVersion -> Bool #
Data KeyVersion # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> KeyVersion -> c KeyVersion # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c KeyVersion # toConstr :: KeyVersion -> Constr # dataTypeOf :: KeyVersion -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c KeyVersion) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeyVersion) # gmapT :: (forall b. Data b => b -> b) -> KeyVersion -> KeyVersion # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> KeyVersion -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> KeyVersion -> r # gmapQ :: (forall d. Data d => d -> u) -> KeyVersion -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> KeyVersion -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> KeyVersion -> m KeyVersion # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> KeyVersion -> m KeyVersion # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> KeyVersion -> m KeyVersion #
Ord KeyVersion # |
Methods compare :: KeyVersion -> KeyVersion -> Ordering # (<) :: KeyVersion -> KeyVersion -> Bool # (<=) :: KeyVersion -> KeyVersion -> Bool # (>) :: KeyVersion -> KeyVersion -> Bool # (>=) :: KeyVersion -> KeyVersion -> Bool # max :: KeyVersion -> KeyVersion -> KeyVersion # min :: KeyVersion -> KeyVersion -> KeyVersion #
Show KeyVersion # |
Methods showsPrec :: Int -> KeyVersion -> ShowS # show :: KeyVersion -> String # showList :: [KeyVersion] -> ShowS #
Generic KeyVersion # |
Associated Types type Rep KeyVersion :: * -> * # Methods from :: KeyVersion -> Rep KeyVersion x # to :: Rep KeyVersion x -> KeyVersion #
ToJSON KeyVersion # |
Methods toJSON :: KeyVersion -> Value # toEncoding :: KeyVersion -> Encoding #
FromJSON KeyVersion # |
Methods parseJSON :: Value -> Parser KeyVersion #
Hashable KeyVersion # |
Methods hashWithSalt :: Int -> KeyVersion -> Int # hash :: KeyVersion -> Int #
Pretty KeyVersion # |
Methods pretty :: KeyVersion -> Doc e # prettyList :: [KeyVersion] -> Doc e #
type Rep KeyVersion # |
type Rep KeyVersion = D1 (MetaData "KeyVersion" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) (C1 (MetaCons "DeprecatedV3" PrefixI False) U1) (C1 (MetaCons "V4" PrefixI False) U1))

newtype IV #

Constructors

IV |
Fields unIV :: ByteString

Instances

Eq IV # |
Methods (==) :: IV -> IV -> Bool # (/=) :: IV -> IV -> Bool #
Data IV # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IV -> c IV # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IV # toConstr :: IV -> Constr # dataTypeOf :: IV -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c IV) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IV) # gmapT :: (forall b. Data b => b -> b) -> IV -> IV # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IV -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IV -> r # gmapQ :: (forall d. Data d => d -> u) -> IV -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IV -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IV -> m IV # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IV -> m IV # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IV -> m IV #
Show IV # |
Methods showsPrec :: Int -> IV -> ShowS # show :: IV -> String # showList :: [IV] -> ShowS #
Generic IV # |
Associated Types type Rep IV :: * -> * # Methods from :: IV -> Rep IV x # to :: Rep IV x -> IV #
Monoid IV # |
Methods mempty :: IV # mappend :: IV -> IV -> IV # mconcat :: [IV] -> IV #
ToJSON IV # |
Methods toJSON :: IV -> Value # toEncoding :: IV -> Encoding #
Byteable IV # |
Methods toBytes :: IV -> ByteString # byteableLength :: IV -> Int # withBytePtr :: IV -> (Ptr Word8 -> IO b) -> IO b #
ByteArrayAccess IV # |
Methods length :: IV -> Int # withByteArray :: IV -> (Ptr p -> IO a) -> IO a #
Hashable IV # |
Methods hashWithSalt :: Int -> IV -> Int # hash :: IV -> Int #
Pretty IV # |
Methods pretty :: IV -> Doc e # prettyList :: [IV] -> Doc e #
Newtype IV ByteString # |
Methods pack :: ByteString -> IV # unpack :: IV -> ByteString #
type Rep IV # |
type Rep IV = D1 (MetaData "IV" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "IV" PrefixI True) (S1 (MetaSel (Just Symbol "unIV") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString)))

data DataType #

Constructors

BinaryData |
TextData |
UTF8Data |
OtherData Word8 |

Instances

Eq DataType # |
Methods (==) :: DataType -> DataType -> Bool # (/=) :: DataType -> DataType -> Bool #
Data DataType # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataType -> c DataType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataType # toConstr :: DataType -> Constr # dataTypeOf :: DataType -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c DataType) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataType) # gmapT :: (forall b. Data b => b -> b) -> DataType -> DataType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataType -> r # gmapQ :: (forall d. Data d => d -> u) -> DataType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataType -> m DataType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataType -> m DataType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataType -> m DataType #
Ord DataType # |
Methods compare :: DataType -> DataType -> Ordering # (<) :: DataType -> DataType -> Bool # (<=) :: DataType -> DataType -> Bool # (>) :: DataType -> DataType -> Bool # (>=) :: DataType -> DataType -> Bool # max :: DataType -> DataType -> DataType # min :: DataType -> DataType -> DataType #
Show DataType # |
Methods showsPrec :: Int -> DataType -> ShowS # show :: DataType -> String # showList :: [DataType] -> ShowS #
Generic DataType # |
Associated Types type Rep DataType :: * -> * # Methods from :: DataType -> Rep DataType x # to :: Rep DataType x -> DataType #
ToJSON DataType # |
Methods toJSON :: DataType -> Value # toEncoding :: DataType -> Encoding #
FromJSON DataType # |
Methods parseJSON :: Value -> Parser DataType #
Hashable DataType # |
Methods hashWithSalt :: Int -> DataType -> Int # hash :: DataType -> Int #
Pretty DataType # |
Methods pretty :: DataType -> Doc e # prettyList :: [DataType] -> Doc e #
FutureVal DataType # |
Methods fromFVal :: DataType -> Word8 # toFVal :: Word8 -> DataType #
type Rep DataType # |
type Rep DataType = D1 (MetaData "DataType" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) ((:+:) (C1 (MetaCons "BinaryData" PrefixI False) U1) (C1 (MetaCons "TextData" PrefixI False) U1)) ((:+:) (C1 (MetaCons "UTF8Data" PrefixI False) U1) (C1 (MetaCons "OtherData" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word8)))))

newtype Salt #

Constructors

Salt |
Fields unSalt :: ByteString

Instances

Eq Salt # |
Methods (==) :: Salt -> Salt -> Bool # (/=) :: Salt -> Salt -> Bool #
Data Salt # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Salt -> c Salt # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Salt # toConstr :: Salt -> Constr # dataTypeOf :: Salt -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Salt) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Salt) # gmapT :: (forall b. Data b => b -> b) -> Salt -> Salt # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Salt -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Salt -> r # gmapQ :: (forall d. Data d => d -> u) -> Salt -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Salt -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Salt -> m Salt # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Salt -> m Salt # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Salt -> m Salt #
Show Salt # |
Methods showsPrec :: Int -> Salt -> ShowS # show :: Salt -> String # showList :: [Salt] -> ShowS #
Generic Salt # |
Associated Types type Rep Salt :: * -> * # Methods from :: Salt -> Rep Salt x # to :: Rep Salt x -> Salt #
ToJSON Salt # |
Methods toJSON :: Salt -> Value # toEncoding :: Salt -> Encoding #
Byteable Salt # |
Methods toBytes :: Salt -> ByteString # byteableLength :: Salt -> Int # withBytePtr :: Salt -> (Ptr Word8 -> IO b) -> IO b #
Hashable Salt # |
Methods hashWithSalt :: Int -> Salt -> Int # hash :: Salt -> Int #
Pretty Salt # |
Methods pretty :: Salt -> Doc e # prettyList :: [Salt] -> Doc e #
Newtype Salt ByteString # |
Methods pack :: ByteString -> Salt # unpack :: Salt -> ByteString #
type Rep Salt # |
type Rep Salt = D1 (MetaData "Salt" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "Salt" PrefixI True) (S1 (MetaSel (Just Symbol "unSalt") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString)))

newtype IterationCount #

Constructors

IterationCount |
Fields unIterationCount :: Int

Instances

Bounded IterationCount # |
Methods minBound :: IterationCount # maxBound :: IterationCount #
Enum IterationCount # |
Methods succ :: IterationCount -> IterationCount # pred :: IterationCount -> IterationCount # toEnum :: Int -> IterationCount # fromEnum :: IterationCount -> Int # enumFrom :: IterationCount -> [IterationCount] # enumFromThen :: IterationCount -> IterationCount -> [IterationCount] # enumFromTo :: IterationCount -> IterationCount -> [IterationCount] # enumFromThenTo :: IterationCount -> IterationCount -> IterationCount -> [IterationCount] #
Eq IterationCount # |
Methods (==) :: IterationCount -> IterationCount -> Bool # (/=) :: IterationCount -> IterationCount -> Bool #
Integral IterationCount # |
Methods quot :: IterationCount -> IterationCount -> IterationCount # rem :: IterationCount -> IterationCount -> IterationCount # div :: IterationCount -> IterationCount -> IterationCount # mod :: IterationCount -> IterationCount -> IterationCount # quotRem :: IterationCount -> IterationCount -> (IterationCount, IterationCount) # divMod :: IterationCount -> IterationCount -> (IterationCount, IterationCount) # toInteger :: IterationCount -> Integer #
Data IterationCount # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IterationCount -> c IterationCount # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IterationCount # toConstr :: IterationCount -> Constr # dataTypeOf :: IterationCount -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c IterationCount) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IterationCount) # gmapT :: (forall b. Data b => b -> b) -> IterationCount -> IterationCount # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IterationCount -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IterationCount -> r # gmapQ :: (forall d. Data d => d -> u) -> IterationCount -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IterationCount -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IterationCount -> m IterationCount # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IterationCount -> m IterationCount # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IterationCount -> m IterationCount #
Num IterationCount # |
Methods (+) :: IterationCount -> IterationCount -> IterationCount # (-) :: IterationCount -> IterationCount -> IterationCount # (*) :: IterationCount -> IterationCount -> IterationCount # negate :: IterationCount -> IterationCount # abs :: IterationCount -> IterationCount # signum :: IterationCount -> IterationCount # fromInteger :: Integer -> IterationCount #
Ord IterationCount # |
Methods compare :: IterationCount -> IterationCount -> Ordering # (<) :: IterationCount -> IterationCount -> Bool # (<=) :: IterationCount -> IterationCount -> Bool # (>) :: IterationCount -> IterationCount -> Bool # (>=) :: IterationCount -> IterationCount -> Bool # max :: IterationCount -> IterationCount -> IterationCount # min :: IterationCount -> IterationCount -> IterationCount #
Real IterationCount # |
Methods toRational :: IterationCount -> Rational #
Show IterationCount # |
Methods showsPrec :: Int -> IterationCount -> ShowS # show :: IterationCount -> String # showList :: [IterationCount] -> ShowS #
Generic IterationCount # |
Associated Types type Rep IterationCount :: * -> * # Methods from :: IterationCount -> Rep IterationCount x # to :: Rep IterationCount x -> IterationCount #
ToJSON IterationCount # |
Methods toJSON :: IterationCount -> Value # toEncoding :: IterationCount -> Encoding #
FromJSON IterationCount # |
Methods parseJSON :: Value -> Parser IterationCount #
Hashable IterationCount # |
Methods hashWithSalt :: Int -> IterationCount -> Int # hash :: IterationCount -> Int #
Pretty IterationCount # |
Methods pretty :: IterationCount -> Doc e # prettyList :: [IterationCount] -> Doc e #
Newtype IterationCount Int # |
Methods pack :: Int -> IterationCount # unpack :: IterationCount -> Int #
type Rep IterationCount # |
type Rep IterationCount = D1 (MetaData "IterationCount" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "IterationCount" PrefixI True) (S1 (MetaSel (Just Symbol "unIterationCount") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))

data S2K #

Constructors

Simple HashAlgorithm |
Salted HashAlgorithm Salt |
IteratedSalted HashAlgorithm Salt IterationCount |
OtherS2K Word8 ByteString |

Instances

Eq S2K # |
Methods (==) :: S2K -> S2K -> Bool # (/=) :: S2K -> S2K -> Bool #
Data S2K # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> S2K -> c S2K # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c S2K # toConstr :: S2K -> Constr # dataTypeOf :: S2K -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c S2K) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c S2K) # gmapT :: (forall b. Data b => b -> b) -> S2K -> S2K # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> S2K -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> S2K -> r # gmapQ :: (forall d. Data d => d -> u) -> S2K -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> S2K -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> S2K -> m S2K # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> S2K -> m S2K # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> S2K -> m S2K #
Show S2K # |
Methods showsPrec :: Int -> S2K -> ShowS # show :: S2K -> String # showList :: [S2K] -> ShowS #
Generic S2K # |
Associated Types type Rep S2K :: * -> * # Methods from :: S2K -> Rep S2K x # to :: Rep S2K x -> S2K #
ToJSON S2K # |
Methods toJSON :: S2K -> Value # toEncoding :: S2K -> Encoding #
Hashable S2K # |
Methods hashWithSalt :: Int -> S2K -> Int # hash :: S2K -> Int #
Pretty S2K # |
Methods pretty :: S2K -> Doc e # prettyList :: [S2K] -> Doc e #
type Rep S2K # |
type Rep S2K = D1 (MetaData "S2K" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) ((:+:) (C1 (MetaCons "Simple" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 HashAlgorithm))) (C1 (MetaCons "Salted" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 HashAlgorithm)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Salt))))) ((:+:) (C1 (MetaCons "IteratedSalted" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 HashAlgorithm)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Salt)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 IterationCount))))) (C1 (MetaCons "OtherS2K" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word8)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString))))))

data ImageFormat #

Constructors

JPEG |
OtherImage Word8 |

Instances

Eq ImageFormat # |
Methods (==) :: ImageFormat -> ImageFormat -> Bool # (/=) :: ImageFormat -> ImageFormat -> Bool #
Data ImageFormat # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImageFormat -> c ImageFormat # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImageFormat # toConstr :: ImageFormat -> Constr # dataTypeOf :: ImageFormat -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ImageFormat) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImageFormat) # gmapT :: (forall b. Data b => b -> b) -> ImageFormat -> ImageFormat # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImageFormat -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImageFormat -> r # gmapQ :: (forall d. Data d => d -> u) -> ImageFormat -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ImageFormat -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImageFormat -> m ImageFormat # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImageFormat -> m ImageFormat # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImageFormat -> m ImageFormat #
Ord ImageFormat # |
Methods compare :: ImageFormat -> ImageFormat -> Ordering # (<) :: ImageFormat -> ImageFormat -> Bool # (<=) :: ImageFormat -> ImageFormat -> Bool # (>) :: ImageFormat -> ImageFormat -> Bool # (>=) :: ImageFormat -> ImageFormat -> Bool # max :: ImageFormat -> ImageFormat -> ImageFormat # min :: ImageFormat -> ImageFormat -> ImageFormat #
Show ImageFormat # |
Methods showsPrec :: Int -> ImageFormat -> ShowS # show :: ImageFormat -> String # showList :: [ImageFormat] -> ShowS #
Generic ImageFormat # |
Associated Types type Rep ImageFormat :: * -> * # Methods from :: ImageFormat -> Rep ImageFormat x # to :: Rep ImageFormat x -> ImageFormat #
ToJSON ImageFormat # |
Methods toJSON :: ImageFormat -> Value # toEncoding :: ImageFormat -> Encoding #
FromJSON ImageFormat # |
Methods parseJSON :: Value -> Parser ImageFormat #
Hashable ImageFormat # |
Methods hashWithSalt :: Int -> ImageFormat -> Int # hash :: ImageFormat -> Int #
Pretty ImageFormat # |
Methods pretty :: ImageFormat -> Doc e # prettyList :: [ImageFormat] -> Doc e #
FutureVal ImageFormat # |
Methods fromFVal :: ImageFormat -> Word8 # toFVal :: Word8 -> ImageFormat #
type Rep ImageFormat # |
type Rep ImageFormat = D1 (MetaData "ImageFormat" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) (C1 (MetaCons "JPEG" PrefixI False) U1) (C1 (MetaCons "OtherImage" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word8))))

data ImageHeader #

Constructors

ImageHV1 ImageFormat |

Instances

Eq ImageHeader # |
Methods (==) :: ImageHeader -> ImageHeader -> Bool # (/=) :: ImageHeader -> ImageHeader -> Bool #
Data ImageHeader # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImageHeader -> c ImageHeader # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImageHeader # toConstr :: ImageHeader -> Constr # dataTypeOf :: ImageHeader -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ImageHeader) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImageHeader) # gmapT :: (forall b. Data b => b -> b) -> ImageHeader -> ImageHeader # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImageHeader -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImageHeader -> r # gmapQ :: (forall d. Data d => d -> u) -> ImageHeader -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ImageHeader -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImageHeader -> m ImageHeader # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImageHeader -> m ImageHeader # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImageHeader -> m ImageHeader #
Ord ImageHeader # |
Methods compare :: ImageHeader -> ImageHeader -> Ordering # (<) :: ImageHeader -> ImageHeader -> Bool # (<=) :: ImageHeader -> ImageHeader -> Bool # (>) :: ImageHeader -> ImageHeader -> Bool # (>=) :: ImageHeader -> ImageHeader -> Bool # max :: ImageHeader -> ImageHeader -> ImageHeader # min :: ImageHeader -> ImageHeader -> ImageHeader #
Show ImageHeader # |
Methods showsPrec :: Int -> ImageHeader -> ShowS # show :: ImageHeader -> String # showList :: [ImageHeader] -> ShowS #
Generic ImageHeader # |
Associated Types type Rep ImageHeader :: * -> * # Methods from :: ImageHeader -> Rep ImageHeader x # to :: Rep ImageHeader x -> ImageHeader #
ToJSON ImageHeader # |
Methods toJSON :: ImageHeader -> Value # toEncoding :: ImageHeader -> Encoding #
FromJSON ImageHeader # |
Methods parseJSON :: Value -> Parser ImageHeader #
Hashable ImageHeader # |
Methods hashWithSalt :: Int -> ImageHeader -> Int # hash :: ImageHeader -> Int #
Pretty ImageHeader # |
Methods pretty :: ImageHeader -> Doc e # prettyList :: [ImageHeader] -> Doc e #
type Rep ImageHeader # |
type Rep ImageHeader = D1 (MetaData "ImageHeader" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) (C1 (MetaCons "ImageHV1" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ImageFormat)))

data UserAttrSubPacket #

Constructors

ImageAttribute ImageHeader ImageData |
OtherUASub Word8 ByteString |

Instances

Eq UserAttrSubPacket # |
Methods (==) :: UserAttrSubPacket -> UserAttrSubPacket -> Bool # (/=) :: UserAttrSubPacket -> UserAttrSubPacket -> Bool #
Data UserAttrSubPacket # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UserAttrSubPacket -> c UserAttrSubPacket # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UserAttrSubPacket # toConstr :: UserAttrSubPacket -> Constr # dataTypeOf :: UserAttrSubPacket -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c UserAttrSubPacket) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UserAttrSubPacket) # gmapT :: (forall b. Data b => b -> b) -> UserAttrSubPacket -> UserAttrSubPacket # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UserAttrSubPacket -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UserAttrSubPacket -> r # gmapQ :: (forall d. Data d => d -> u) -> UserAttrSubPacket -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UserAttrSubPacket -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UserAttrSubPacket -> m UserAttrSubPacket # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UserAttrSubPacket -> m UserAttrSubPacket # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UserAttrSubPacket -> m UserAttrSubPacket #
Ord UserAttrSubPacket # |
Methods compare :: UserAttrSubPacket -> UserAttrSubPacket -> Ordering # (<) :: UserAttrSubPacket -> UserAttrSubPacket -> Bool # (<=) :: UserAttrSubPacket -> UserAttrSubPacket -> Bool # (>) :: UserAttrSubPacket -> UserAttrSubPacket -> Bool # (>=) :: UserAttrSubPacket -> UserAttrSubPacket -> Bool # max :: UserAttrSubPacket -> UserAttrSubPacket -> UserAttrSubPacket # min :: UserAttrSubPacket -> UserAttrSubPacket -> UserAttrSubPacket #
Show UserAttrSubPacket # |
Methods showsPrec :: Int -> UserAttrSubPacket -> ShowS # show :: UserAttrSubPacket -> String # showList :: [UserAttrSubPacket] -> ShowS #
Generic UserAttrSubPacket # |
Associated Types type Rep UserAttrSubPacket :: * -> * # Methods from :: UserAttrSubPacket -> Rep UserAttrSubPacket x # to :: Rep UserAttrSubPacket x -> UserAttrSubPacket #
ToJSON UserAttrSubPacket # |
Methods toJSON :: UserAttrSubPacket -> Value # toEncoding :: UserAttrSubPacket -> Encoding #
Hashable UserAttrSubPacket # |
Methods hashWithSalt :: Int -> UserAttrSubPacket -> Int # hash :: UserAttrSubPacket -> Int #
Pretty UserAttrSubPacket # |
Methods pretty :: UserAttrSubPacket -> Doc e # prettyList :: [UserAttrSubPacket] -> Doc e #
type Rep UserAttrSubPacket # |
type Rep UserAttrSubPacket = D1 (MetaData "UserAttrSubPacket" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) (C1 (MetaCons "ImageAttribute" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ImageHeader)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ImageData)))) (C1 (MetaCons "OtherUASub" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word8)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString)))))

data ECCCurve #

Constructors

BrokenNISTP256 |
BrokenNISTP384 |
BrokenNISTP521 |

Instances

Eq ECCCurve # |
Methods (==) :: ECCCurve -> ECCCurve -> Bool # (/=) :: ECCCurve -> ECCCurve -> Bool #
Data ECCCurve # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ECCCurve -> c ECCCurve # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ECCCurve # toConstr :: ECCCurve -> Constr # dataTypeOf :: ECCCurve -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ECCCurve) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ECCCurve) # gmapT :: (forall b. Data b => b -> b) -> ECCCurve -> ECCCurve # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ECCCurve -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ECCCurve -> r # gmapQ :: (forall d. Data d => d -> u) -> ECCCurve -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ECCCurve -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ECCCurve -> m ECCCurve # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ECCCurve -> m ECCCurve # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ECCCurve -> m ECCCurve #
Ord ECCCurve # |
Methods compare :: ECCCurve -> ECCCurve -> Ordering # (<) :: ECCCurve -> ECCCurve -> Bool # (<=) :: ECCCurve -> ECCCurve -> Bool # (>) :: ECCCurve -> ECCCurve -> Bool # (>=) :: ECCCurve -> ECCCurve -> Bool # max :: ECCCurve -> ECCCurve -> ECCCurve # min :: ECCCurve -> ECCCurve -> ECCCurve #
Show ECCCurve # |
Methods showsPrec :: Int -> ECCCurve -> ShowS # show :: ECCCurve -> String # showList :: [ECCCurve] -> ShowS #
Generic ECCCurve # |
Associated Types type Rep ECCCurve :: * -> * # Methods from :: ECCCurve -> Rep ECCCurve x # to :: Rep ECCCurve x -> ECCCurve #
Hashable ECCCurve # |
Methods hashWithSalt :: Int -> ECCCurve -> Int # hash :: ECCCurve -> Int #
type Rep ECCCurve # |
type Rep ECCCurve = D1 (MetaData "ECCCurve" "Codec.Encryption.OpenPGP.Types.Internal.Base" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) (C1 (MetaCons "BrokenNISTP256" PrefixI False) U1) ((:+:) (C1 (MetaCons "BrokenNISTP384" PrefixI False) U1) (C1 (MetaCons "BrokenNISTP521" PrefixI False) U1)))

newtype Block a #

Constructors

Block |
Fields unBlock :: [a]

Instances

Eq a => Eq (Block a) # |
Methods (==) :: Block a -> Block a -> Bool # (/=) :: Block a -> Block a -> Bool #
Show a => Show (Block a) # |
Methods showsPrec :: Int -> Block a -> ShowS # show :: Block a -> String # showList :: [Block a] -> ShowS #

newtype DSA_PublicKey #

Constructors

DSA_PublicKey |
Fields unDSA_PublicKey :: PublicKey

Instances

Eq DSA_PublicKey # |
Methods (==) :: DSA_PublicKey -> DSA_PublicKey -> Bool # (/=) :: DSA_PublicKey -> DSA_PublicKey -> Bool #
Data DSA_PublicKey # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DSA_PublicKey -> c DSA_PublicKey # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DSA_PublicKey # toConstr :: DSA_PublicKey -> Constr # dataTypeOf :: DSA_PublicKey -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c DSA_PublicKey) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DSA_PublicKey) # gmapT :: (forall b. Data b => b -> b) -> DSA_PublicKey -> DSA_PublicKey # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DSA_PublicKey -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DSA_PublicKey -> r # gmapQ :: (forall d. Data d => d -> u) -> DSA_PublicKey -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DSA_PublicKey -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DSA_PublicKey -> m DSA_PublicKey # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DSA_PublicKey -> m DSA_PublicKey # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DSA_PublicKey -> m DSA_PublicKey #
Ord DSA_PublicKey # |
Methods compare :: DSA_PublicKey -> DSA_PublicKey -> Ordering # (<) :: DSA_PublicKey -> DSA_PublicKey -> Bool # (<=) :: DSA_PublicKey -> DSA_PublicKey -> Bool # (>) :: DSA_PublicKey -> DSA_PublicKey -> Bool # (>=) :: DSA_PublicKey -> DSA_PublicKey -> Bool # max :: DSA_PublicKey -> DSA_PublicKey -> DSA_PublicKey # min :: DSA_PublicKey -> DSA_PublicKey -> DSA_PublicKey #
Show DSA_PublicKey # |
Methods showsPrec :: Int -> DSA_PublicKey -> ShowS # show :: DSA_PublicKey -> String # showList :: [DSA_PublicKey] -> ShowS #
Generic DSA_PublicKey # |
Associated Types type Rep DSA_PublicKey :: * -> * # Methods from :: DSA_PublicKey -> Rep DSA_PublicKey x # to :: Rep DSA_PublicKey x -> DSA_PublicKey #
ToJSON DSA_PublicKey # |
Methods toJSON :: DSA_PublicKey -> Value # toEncoding :: DSA_PublicKey -> Encoding #
Hashable DSA_PublicKey # |
Methods hashWithSalt :: Int -> DSA_PublicKey -> Int # hash :: DSA_PublicKey -> Int #
Pretty DSA_PublicKey # |
Methods pretty :: DSA_PublicKey -> Doc e # prettyList :: [DSA_PublicKey] -> Doc e #
type Rep DSA_PublicKey # |
type Rep DSA_PublicKey = D1 (MetaData "DSA_PublicKey" "Codec.Encryption.OpenPGP.Types.Internal.CryptoniteNewtypes" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "DSA_PublicKey" PrefixI True) (S1 (MetaSel (Just Symbol "unDSA_PublicKey") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PublicKey)))

newtype RSA_PublicKey #

Constructors

RSA_PublicKey |
Fields unRSA_PublicKey :: PublicKey

Instances

Eq RSA_PublicKey # |
Methods (==) :: RSA_PublicKey -> RSA_PublicKey -> Bool # (/=) :: RSA_PublicKey -> RSA_PublicKey -> Bool #
Data RSA_PublicKey # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RSA_PublicKey -> c RSA_PublicKey # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RSA_PublicKey # toConstr :: RSA_PublicKey -> Constr # dataTypeOf :: RSA_PublicKey -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c RSA_PublicKey) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RSA_PublicKey) # gmapT :: (forall b. Data b => b -> b) -> RSA_PublicKey -> RSA_PublicKey # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RSA_PublicKey -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RSA_PublicKey -> r # gmapQ :: (forall d. Data d => d -> u) -> RSA_PublicKey -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RSA_PublicKey -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RSA_PublicKey -> m RSA_PublicKey # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RSA_PublicKey -> m RSA_PublicKey # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RSA_PublicKey -> m RSA_PublicKey #
Ord RSA_PublicKey # |
Methods compare :: RSA_PublicKey -> RSA_PublicKey -> Ordering # (<) :: RSA_PublicKey -> RSA_PublicKey -> Bool # (<=) :: RSA_PublicKey -> RSA_PublicKey -> Bool # (>) :: RSA_PublicKey -> RSA_PublicKey -> Bool # (>=) :: RSA_PublicKey -> RSA_PublicKey -> Bool # max :: RSA_PublicKey -> RSA_PublicKey -> RSA_PublicKey # min :: RSA_PublicKey -> RSA_PublicKey -> RSA_PublicKey #
Show RSA_PublicKey # |
Methods showsPrec :: Int -> RSA_PublicKey -> ShowS # show :: RSA_PublicKey -> String # showList :: [RSA_PublicKey] -> ShowS #
Generic RSA_PublicKey # |
Associated Types type Rep RSA_PublicKey :: * -> * # Methods from :: RSA_PublicKey -> Rep RSA_PublicKey x # to :: Rep RSA_PublicKey x -> RSA_PublicKey #
ToJSON RSA_PublicKey # |
Methods toJSON :: RSA_PublicKey -> Value # toEncoding :: RSA_PublicKey -> Encoding #
Hashable RSA_PublicKey # |
Methods hashWithSalt :: Int -> RSA_PublicKey -> Int # hash :: RSA_PublicKey -> Int #
Pretty RSA_PublicKey # |
Methods pretty :: RSA_PublicKey -> Doc e # prettyList :: [RSA_PublicKey] -> Doc e #
type Rep RSA_PublicKey # |
type Rep RSA_PublicKey = D1 (MetaData "RSA_PublicKey" "Codec.Encryption.OpenPGP.Types.Internal.CryptoniteNewtypes" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "RSA_PublicKey" PrefixI True) (S1 (MetaSel (Just Symbol "unRSA_PublicKey") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PublicKey)))

newtype ECDSA_PublicKey #

Constructors

ECDSA_PublicKey |
Fields unECDSA_PublicKey :: PublicKey

Instances

Eq ECDSA_PublicKey # |
Methods (==) :: ECDSA_PublicKey -> ECDSA_PublicKey -> Bool # (/=) :: ECDSA_PublicKey -> ECDSA_PublicKey -> Bool #
Data ECDSA_PublicKey # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ECDSA_PublicKey -> c ECDSA_PublicKey # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ECDSA_PublicKey # toConstr :: ECDSA_PublicKey -> Constr # dataTypeOf :: ECDSA_PublicKey -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ECDSA_PublicKey) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ECDSA_PublicKey) # gmapT :: (forall b. Data b => b -> b) -> ECDSA_PublicKey -> ECDSA_PublicKey # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ECDSA_PublicKey -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ECDSA_PublicKey -> r # gmapQ :: (forall d. Data d => d -> u) -> ECDSA_PublicKey -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ECDSA_PublicKey -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ECDSA_PublicKey -> m ECDSA_PublicKey # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ECDSA_PublicKey -> m ECDSA_PublicKey # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ECDSA_PublicKey -> m ECDSA_PublicKey #
Ord ECDSA_PublicKey # |
Methods compare :: ECDSA_PublicKey -> ECDSA_PublicKey -> Ordering # (<) :: ECDSA_PublicKey -> ECDSA_PublicKey -> Bool # (<=) :: ECDSA_PublicKey -> ECDSA_PublicKey -> Bool # (>) :: ECDSA_PublicKey -> ECDSA_PublicKey -> Bool # (>=) :: ECDSA_PublicKey -> ECDSA_PublicKey -> Bool # max :: ECDSA_PublicKey -> ECDSA_PublicKey -> ECDSA_PublicKey # min :: ECDSA_PublicKey -> ECDSA_PublicKey -> ECDSA_PublicKey #
Show ECDSA_PublicKey # |
Methods showsPrec :: Int -> ECDSA_PublicKey -> ShowS # show :: ECDSA_PublicKey -> String # showList :: [ECDSA_PublicKey] -> ShowS #
Generic ECDSA_PublicKey # |
Associated Types type Rep ECDSA_PublicKey :: * -> * # Methods from :: ECDSA_PublicKey -> Rep ECDSA_PublicKey x # to :: Rep ECDSA_PublicKey x -> ECDSA_PublicKey #
ToJSON ECDSA_PublicKey # |
Methods toJSON :: ECDSA_PublicKey -> Value # toEncoding :: ECDSA_PublicKey -> Encoding #
Hashable ECDSA_PublicKey # |
Methods hashWithSalt :: Int -> ECDSA_PublicKey -> Int # hash :: ECDSA_PublicKey -> Int #
Pretty ECDSA_PublicKey # |
Methods pretty :: ECDSA_PublicKey -> Doc e # prettyList :: [ECDSA_PublicKey] -> Doc e #
type Rep ECDSA_PublicKey # |
type Rep ECDSA_PublicKey = D1 (MetaData "ECDSA_PublicKey" "Codec.Encryption.OpenPGP.Types.Internal.CryptoniteNewtypes" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "ECDSA_PublicKey" PrefixI True) (S1 (MetaSel (Just Symbol "unECDSA_PublicKey") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PublicKey)))

newtype DSA_PrivateKey #

Constructors

DSA_PrivateKey |
Fields unDSA_PrivateKey :: PrivateKey

Instances

Eq DSA_PrivateKey # |
Methods (==) :: DSA_PrivateKey -> DSA_PrivateKey -> Bool # (/=) :: DSA_PrivateKey -> DSA_PrivateKey -> Bool #
Data DSA_PrivateKey # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DSA_PrivateKey -> c DSA_PrivateKey # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DSA_PrivateKey # toConstr :: DSA_PrivateKey -> Constr # dataTypeOf :: DSA_PrivateKey -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c DSA_PrivateKey) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DSA_PrivateKey) # gmapT :: (forall b. Data b => b -> b) -> DSA_PrivateKey -> DSA_PrivateKey # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DSA_PrivateKey -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DSA_PrivateKey -> r # gmapQ :: (forall d. Data d => d -> u) -> DSA_PrivateKey -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DSA_PrivateKey -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DSA_PrivateKey -> m DSA_PrivateKey # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DSA_PrivateKey -> m DSA_PrivateKey # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DSA_PrivateKey -> m DSA_PrivateKey #
Ord DSA_PrivateKey # |
Methods compare :: DSA_PrivateKey -> DSA_PrivateKey -> Ordering # (<) :: DSA_PrivateKey -> DSA_PrivateKey -> Bool # (<=) :: DSA_PrivateKey -> DSA_PrivateKey -> Bool # (>) :: DSA_PrivateKey -> DSA_PrivateKey -> Bool # (>=) :: DSA_PrivateKey -> DSA_PrivateKey -> Bool # max :: DSA_PrivateKey -> DSA_PrivateKey -> DSA_PrivateKey # min :: DSA_PrivateKey -> DSA_PrivateKey -> DSA_PrivateKey #
Show DSA_PrivateKey # |
Methods showsPrec :: Int -> DSA_PrivateKey -> ShowS # show :: DSA_PrivateKey -> String # showList :: [DSA_PrivateKey] -> ShowS #
Generic DSA_PrivateKey # |
Associated Types type Rep DSA_PrivateKey :: * -> * # Methods from :: DSA_PrivateKey -> Rep DSA_PrivateKey x # to :: Rep DSA_PrivateKey x -> DSA_PrivateKey #
ToJSON DSA_PrivateKey # |
Methods toJSON :: DSA_PrivateKey -> Value # toEncoding :: DSA_PrivateKey -> Encoding #
Hashable DSA_PrivateKey # |
Methods hashWithSalt :: Int -> DSA_PrivateKey -> Int # hash :: DSA_PrivateKey -> Int #
Pretty DSA_PrivateKey # |
Methods pretty :: DSA_PrivateKey -> Doc e # prettyList :: [DSA_PrivateKey] -> Doc e #
type Rep DSA_PrivateKey # |
type Rep DSA_PrivateKey = D1 (MetaData "DSA_PrivateKey" "Codec.Encryption.OpenPGP.Types.Internal.CryptoniteNewtypes" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "DSA_PrivateKey" PrefixI True) (S1 (MetaSel (Just Symbol "unDSA_PrivateKey") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PrivateKey)))

newtype RSA_PrivateKey #

Constructors

RSA_PrivateKey |
Fields unRSA_PrivateKey :: PrivateKey

Instances

Eq RSA_PrivateKey # |
Methods (==) :: RSA_PrivateKey -> RSA_PrivateKey -> Bool # (/=) :: RSA_PrivateKey -> RSA_PrivateKey -> Bool #
Data RSA_PrivateKey # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RSA_PrivateKey -> c RSA_PrivateKey # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RSA_PrivateKey # toConstr :: RSA_PrivateKey -> Constr # dataTypeOf :: RSA_PrivateKey -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c RSA_PrivateKey) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RSA_PrivateKey) # gmapT :: (forall b. Data b => b -> b) -> RSA_PrivateKey -> RSA_PrivateKey # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RSA_PrivateKey -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RSA_PrivateKey -> r # gmapQ :: (forall d. Data d => d -> u) -> RSA_PrivateKey -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RSA_PrivateKey -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RSA_PrivateKey -> m RSA_PrivateKey # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RSA_PrivateKey -> m RSA_PrivateKey # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RSA_PrivateKey -> m RSA_PrivateKey #
Ord RSA_PrivateKey # |
Methods compare :: RSA_PrivateKey -> RSA_PrivateKey -> Ordering # (<) :: RSA_PrivateKey -> RSA_PrivateKey -> Bool # (<=) :: RSA_PrivateKey -> RSA_PrivateKey -> Bool # (>) :: RSA_PrivateKey -> RSA_PrivateKey -> Bool # (>=) :: RSA_PrivateKey -> RSA_PrivateKey -> Bool # max :: RSA_PrivateKey -> RSA_PrivateKey -> RSA_PrivateKey # min :: RSA_PrivateKey -> RSA_PrivateKey -> RSA_PrivateKey #
Show RSA_PrivateKey # |
Methods showsPrec :: Int -> RSA_PrivateKey -> ShowS # show :: RSA_PrivateKey -> String # showList :: [RSA_PrivateKey] -> ShowS #
Generic RSA_PrivateKey # |
Associated Types type Rep RSA_PrivateKey :: * -> * # Methods from :: RSA_PrivateKey -> Rep RSA_PrivateKey x # to :: Rep RSA_PrivateKey x -> RSA_PrivateKey #
ToJSON RSA_PrivateKey # |
Methods toJSON :: RSA_PrivateKey -> Value # toEncoding :: RSA_PrivateKey -> Encoding #
Hashable RSA_PrivateKey # |
Methods hashWithSalt :: Int -> RSA_PrivateKey -> Int # hash :: RSA_PrivateKey -> Int #
Pretty RSA_PrivateKey # |
Methods pretty :: RSA_PrivateKey -> Doc e # prettyList :: [RSA_PrivateKey] -> Doc e #
type Rep RSA_PrivateKey # |
type Rep RSA_PrivateKey = D1 (MetaData "RSA_PrivateKey" "Codec.Encryption.OpenPGP.Types.Internal.CryptoniteNewtypes" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "RSA_PrivateKey" PrefixI True) (S1 (MetaSel (Just Symbol "unRSA_PrivateKey") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PrivateKey)))

newtype ECDSA_PrivateKey #

Constructors

ECDSA_PrivateKey |
Fields unECDSA_PrivateKey :: PrivateKey

Instances

Eq ECDSA_PrivateKey # |
Methods (==) :: ECDSA_PrivateKey -> ECDSA_PrivateKey -> Bool # (/=) :: ECDSA_PrivateKey -> ECDSA_PrivateKey -> Bool #
Data ECDSA_PrivateKey # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ECDSA_PrivateKey -> c ECDSA_PrivateKey # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ECDSA_PrivateKey # toConstr :: ECDSA_PrivateKey -> Constr # dataTypeOf :: ECDSA_PrivateKey -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ECDSA_PrivateKey) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ECDSA_PrivateKey) # gmapT :: (forall b. Data b => b -> b) -> ECDSA_PrivateKey -> ECDSA_PrivateKey # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ECDSA_PrivateKey -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ECDSA_PrivateKey -> r # gmapQ :: (forall d. Data d => d -> u) -> ECDSA_PrivateKey -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ECDSA_PrivateKey -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ECDSA_PrivateKey -> m ECDSA_PrivateKey # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ECDSA_PrivateKey -> m ECDSA_PrivateKey # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ECDSA_PrivateKey -> m ECDSA_PrivateKey #
Ord ECDSA_PrivateKey # |
Methods compare :: ECDSA_PrivateKey -> ECDSA_PrivateKey -> Ordering # (<) :: ECDSA_PrivateKey -> ECDSA_PrivateKey -> Bool # (<=) :: ECDSA_PrivateKey -> ECDSA_PrivateKey -> Bool # (>) :: ECDSA_PrivateKey -> ECDSA_PrivateKey -> Bool # (>=) :: ECDSA_PrivateKey -> ECDSA_PrivateKey -> Bool # max :: ECDSA_PrivateKey -> ECDSA_PrivateKey -> ECDSA_PrivateKey # min :: ECDSA_PrivateKey -> ECDSA_PrivateKey -> ECDSA_PrivateKey #
Show ECDSA_PrivateKey # |
Methods showsPrec :: Int -> ECDSA_PrivateKey -> ShowS # show :: ECDSA_PrivateKey -> String # showList :: [ECDSA_PrivateKey] -> ShowS #
Generic ECDSA_PrivateKey # |
Associated Types type Rep ECDSA_PrivateKey :: * -> * # Methods from :: ECDSA_PrivateKey -> Rep ECDSA_PrivateKey x # to :: Rep ECDSA_PrivateKey x -> ECDSA_PrivateKey #
ToJSON ECDSA_PrivateKey # |
Methods toJSON :: ECDSA_PrivateKey -> Value # toEncoding :: ECDSA_PrivateKey -> Encoding #
Hashable ECDSA_PrivateKey # |
Methods hashWithSalt :: Int -> ECDSA_PrivateKey -> Int # hash :: ECDSA_PrivateKey -> Int #
Pretty ECDSA_PrivateKey # |
Methods pretty :: ECDSA_PrivateKey -> Doc e # prettyList :: [ECDSA_PrivateKey] -> Doc e #
type Rep ECDSA_PrivateKey # |
type Rep ECDSA_PrivateKey = D1 (MetaData "ECDSA_PrivateKey" "Codec.Encryption.OpenPGP.Types.Internal.CryptoniteNewtypes" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "ECDSA_PrivateKey" PrefixI True) (S1 (MetaSel (Just Symbol "unECDSA_PrivateKey") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PrivateKey)))

newtype DSA_Params #

Constructors

DSA_Params |
Fields unDSA_Params :: Params

Instances

Eq DSA_Params # |
Methods (==) :: DSA_Params -> DSA_Params -> Bool # (/=) :: DSA_Params -> DSA_Params -> Bool #
Data DSA_Params # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DSA_Params -> c DSA_Params # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DSA_Params # toConstr :: DSA_Params -> Constr # dataTypeOf :: DSA_Params -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c DSA_Params) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DSA_Params) # gmapT :: (forall b. Data b => b -> b) -> DSA_Params -> DSA_Params # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DSA_Params -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DSA_Params -> r # gmapQ :: (forall d. Data d => d -> u) -> DSA_Params -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DSA_Params -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DSA_Params -> m DSA_Params # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DSA_Params -> m DSA_Params # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DSA_Params -> m DSA_Params #
Show DSA_Params # |
Methods showsPrec :: Int -> DSA_Params -> ShowS # show :: DSA_Params -> String # showList :: [DSA_Params] -> ShowS #
Generic DSA_Params # |
Associated Types type Rep DSA_Params :: * -> * # Methods from :: DSA_Params -> Rep DSA_Params x # to :: Rep DSA_Params x -> DSA_Params #
ToJSON DSA_Params # |
Methods toJSON :: DSA_Params -> Value # toEncoding :: DSA_Params -> Encoding #
Hashable DSA_Params # |
Methods hashWithSalt :: Int -> DSA_Params -> Int # hash :: DSA_Params -> Int #
Pretty DSA_Params # |
Methods pretty :: DSA_Params -> Doc e # prettyList :: [DSA_Params] -> Doc e #
type Rep DSA_Params # |
type Rep DSA_Params = D1 (MetaData "DSA_Params" "Codec.Encryption.OpenPGP.Types.Internal.CryptoniteNewtypes" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" True) (C1 (MetaCons "DSA_Params" PrefixI True) (S1 (MetaSel (Just Symbol "unDSA_Params") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Params)))

class Packet a where #

Minimal complete definition

packetType, packetCode, toPkt, fromPkt

Associated Types

data PacketType a :: * #

Methods

packetType :: a -> PacketType a #

packetCode :: PacketType a -> Word8 #

toPkt :: a -> Pkt #

fromPkt :: Pkt -> a #

Instances

Packet BrokenPacket # |
Associated Types data PacketType BrokenPacket :: * # Methods packetType :: BrokenPacket -> PacketType BrokenPacket # packetCode :: PacketType BrokenPacket -> Word8 # toPkt :: BrokenPacket -> Pkt # fromPkt :: Pkt -> BrokenPacket #
Packet OtherPacket # |
Associated Types data PacketType OtherPacket :: * # Methods packetType :: OtherPacket -> PacketType OtherPacket # packetCode :: PacketType OtherPacket -> Word8 # toPkt :: OtherPacket -> Pkt # fromPkt :: Pkt -> OtherPacket #
Packet ModificationDetectionCode # |
Associated Types data PacketType ModificationDetectionCode :: * # Methods packetType :: ModificationDetectionCode -> PacketType ModificationDetectionCode # packetCode :: PacketType ModificationDetectionCode -> Word8 # toPkt :: ModificationDetectionCode -> Pkt # fromPkt :: Pkt -> ModificationDetectionCode #
Packet SymEncIntegrityProtectedData # |
Associated Types data PacketType SymEncIntegrityProtectedData :: * # Methods packetType :: SymEncIntegrityProtectedData -> PacketType SymEncIntegrityProtectedData # packetCode :: PacketType SymEncIntegrityProtectedData -> Word8 # toPkt :: SymEncIntegrityProtectedData -> Pkt # fromPkt :: Pkt -> SymEncIntegrityProtectedData #
Packet UserAttribute # |
Associated Types data PacketType UserAttribute :: * # Methods packetType :: UserAttribute -> PacketType UserAttribute # packetCode :: PacketType UserAttribute -> Word8 # toPkt :: UserAttribute -> Pkt # fromPkt :: Pkt -> UserAttribute #
Packet PublicSubkey # |
Associated Types data PacketType PublicSubkey :: * # Methods packetType :: PublicSubkey -> PacketType PublicSubkey # packetCode :: PacketType PublicSubkey -> Word8 # toPkt :: PublicSubkey -> Pkt # fromPkt :: Pkt -> PublicSubkey #
Packet UserId # |
Associated Types data PacketType UserId :: * # Methods packetType :: UserId -> PacketType UserId # packetCode :: PacketType UserId -> Word8 # toPkt :: UserId -> Pkt # fromPkt :: Pkt -> UserId #
Packet Trust # |
Associated Types data PacketType Trust :: * # Methods packetType :: Trust -> PacketType Trust # packetCode :: PacketType Trust -> Word8 # toPkt :: Trust -> Pkt # fromPkt :: Pkt -> Trust #
Packet LiteralData # |
Associated Types data PacketType LiteralData :: * # Methods packetType :: LiteralData -> PacketType LiteralData # packetCode :: PacketType LiteralData -> Word8 # toPkt :: LiteralData -> Pkt # fromPkt :: Pkt -> LiteralData #
Packet Marker # |
Associated Types data PacketType Marker :: * # Methods packetType :: Marker -> PacketType Marker # packetCode :: PacketType Marker -> Word8 # toPkt :: Marker -> Pkt # fromPkt :: Pkt -> Marker #
Packet SymEncData # |
Associated Types data PacketType SymEncData :: * # Methods packetType :: SymEncData -> PacketType SymEncData # packetCode :: PacketType SymEncData -> Word8 # toPkt :: SymEncData -> Pkt # fromPkt :: Pkt -> SymEncData #
Packet CompressedData # |
Associated Types data PacketType CompressedData :: * # Methods packetType :: CompressedData -> PacketType CompressedData # packetCode :: PacketType CompressedData -> Word8 # toPkt :: CompressedData -> Pkt # fromPkt :: Pkt -> CompressedData #
Packet SecretSubkey # |
Associated Types data PacketType SecretSubkey :: * # Methods packetType :: SecretSubkey -> PacketType SecretSubkey # packetCode :: PacketType SecretSubkey -> Word8 # toPkt :: SecretSubkey -> Pkt # fromPkt :: Pkt -> SecretSubkey #
Packet PublicKey # |
Associated Types data PacketType PublicKey :: * # Methods packetType :: PublicKey -> PacketType PublicKey # packetCode :: PacketType PublicKey -> Word8 # toPkt :: PublicKey -> Pkt # fromPkt :: Pkt -> PublicKey #
Packet SecretKey # |
Associated Types data PacketType SecretKey :: * # Methods packetType :: SecretKey -> PacketType SecretKey # packetCode :: PacketType SecretKey -> Word8 # toPkt :: SecretKey -> Pkt # fromPkt :: Pkt -> SecretKey #
Packet OnePassSignature # |
Associated Types data PacketType OnePassSignature :: * # Methods packetType :: OnePassSignature -> PacketType OnePassSignature # packetCode :: PacketType OnePassSignature -> Word8 # toPkt :: OnePassSignature -> Pkt # fromPkt :: Pkt -> OnePassSignature #
Packet SKESK # |
Associated Types data PacketType SKESK :: * # Methods packetType :: SKESK -> PacketType SKESK # packetCode :: PacketType SKESK -> Word8 # toPkt :: SKESK -> Pkt # fromPkt :: Pkt -> SKESK #
Packet Signature # |
Associated Types data PacketType Signature :: * # Methods packetType :: Signature -> PacketType Signature # packetCode :: PacketType Signature -> Word8 # toPkt :: Signature -> Pkt # fromPkt :: Pkt -> Signature #
Packet PKESK # |
Associated Types data PacketType PKESK :: * # Methods packetType :: PKESK -> PacketType PKESK # packetCode :: PacketType PKESK -> Word8 # toPkt :: PKESK -> Pkt # fromPkt :: Pkt -> PKESK #

data PKESK #

Constructors

PKESK |
Fields _pkeskPacketVersion :: PacketVersion _pkeskEightOctetKeyId :: EightOctetKeyId _pkeskPubKeyAlgorithm :: PubKeyAlgorithm _pkeskMPIs :: NonEmpty MPI

Instances

Eq PKESK # |
Methods (==) :: PKESK -> PKESK -> Bool # (/=) :: PKESK -> PKESK -> Bool #
Data PKESK # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PKESK -> c PKESK # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PKESK # toConstr :: PKESK -> Constr # dataTypeOf :: PKESK -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PKESK) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PKESK) # gmapT :: (forall b. Data b => b -> b) -> PKESK -> PKESK # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PKESK -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PKESK -> r # gmapQ :: (forall d. Data d => d -> u) -> PKESK -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PKESK -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PKESK -> m PKESK # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PKESK -> m PKESK # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PKESK -> m PKESK #
Show PKESK # |
Methods showsPrec :: Int -> PKESK -> ShowS # show :: PKESK -> String # showList :: [PKESK] -> ShowS #
Pretty PKESK # |
Methods pretty :: PKESK -> Doc e # prettyList :: [PKESK] -> Doc e #
Packet PKESK # |
Associated Types data PacketType PKESK :: * # Methods packetType :: PKESK -> PacketType PKESK # packetCode :: PacketType PKESK -> Word8 # toPkt :: PKESK -> Pkt # fromPkt :: Pkt -> PKESK #
Eq (PacketType PKESK) # |
Methods (==) :: PacketType PKESK -> PacketType PKESK -> Bool # (/=) :: PacketType PKESK -> PacketType PKESK -> Bool #
Show (PacketType PKESK) # |
Methods showsPrec :: Int -> PacketType PKESK -> ShowS # show :: PacketType PKESK -> String # showList :: [PacketType PKESK] -> ShowS #
data PacketType PKESK # |
data PacketType PKESK = PKESKType

data Signature #

Constructors

Signature |
Fields _signaturePayload :: SignaturePayload

Instances

Eq Signature # |
Methods (==) :: Signature -> Signature -> Bool # (/=) :: Signature -> Signature -> Bool #
Data Signature # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Signature -> c Signature # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Signature # toConstr :: Signature -> Constr # dataTypeOf :: Signature -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Signature) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Signature) # gmapT :: (forall b. Data b => b -> b) -> Signature -> Signature # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Signature -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Signature -> r # gmapQ :: (forall d. Data d => d -> u) -> Signature -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Signature -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Signature -> m Signature # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Signature -> m Signature # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Signature -> m Signature #
Show Signature # |
Methods showsPrec :: Int -> Signature -> ShowS # show :: Signature -> String # showList :: [Signature] -> ShowS #
Pretty Signature # |
Methods pretty :: Signature -> Doc e # prettyList :: [Signature] -> Doc e #
Packet Signature # |
Associated Types data PacketType Signature :: * # Methods packetType :: Signature -> PacketType Signature # packetCode :: PacketType Signature -> Word8 # toPkt :: Signature -> Pkt # fromPkt :: Pkt -> Signature #
Eq (PacketType Signature) # |
Methods (==) :: PacketType Signature -> PacketType Signature -> Bool # (/=) :: PacketType Signature -> PacketType Signature -> Bool #
Show (PacketType Signature) # |
Methods showsPrec :: Int -> PacketType Signature -> ShowS # show :: PacketType Signature -> String # showList :: [PacketType Signature] -> ShowS #
data PacketType Signature # |
data PacketType Signature = SignatureType

data SKESK #

Constructors

SKESK |
Fields _skeskPacketVersion :: PacketVersion _skeskSymmetricAlgorithm :: SymmetricAlgorithm _skeskS2K :: S2K _skeskESK :: Maybe ByteString

Instances

Eq SKESK # |
Methods (==) :: SKESK -> SKESK -> Bool # (/=) :: SKESK -> SKESK -> Bool #
Data SKESK # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SKESK -> c SKESK # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SKESK # toConstr :: SKESK -> Constr # dataTypeOf :: SKESK -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SKESK) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SKESK) # gmapT :: (forall b. Data b => b -> b) -> SKESK -> SKESK # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SKESK -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SKESK -> r # gmapQ :: (forall d. Data d => d -> u) -> SKESK -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SKESK -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SKESK -> m SKESK # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SKESK -> m SKESK # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SKESK -> m SKESK #
Show SKESK # |
Methods showsPrec :: Int -> SKESK -> ShowS # show :: SKESK -> String # showList :: [SKESK] -> ShowS #
Pretty SKESK # |
Methods pretty :: SKESK -> Doc e # prettyList :: [SKESK] -> Doc e #
Packet SKESK # |
Associated Types data PacketType SKESK :: * # Methods packetType :: SKESK -> PacketType SKESK # packetCode :: PacketType SKESK -> Word8 # toPkt :: SKESK -> Pkt # fromPkt :: Pkt -> SKESK #
Eq (PacketType SKESK) # |
Methods (==) :: PacketType SKESK -> PacketType SKESK -> Bool # (/=) :: PacketType SKESK -> PacketType SKESK -> Bool #
Show (PacketType SKESK) # |
Methods showsPrec :: Int -> PacketType SKESK -> ShowS # show :: PacketType SKESK -> String # showList :: [PacketType SKESK] -> ShowS #
data PacketType SKESK # |
data PacketType SKESK = SKESKType

data OnePassSignature #

Constructors

OnePassSignature |
Fields _onePassSignaturePacketVersion :: PacketVersion _onePassSignatureSigType :: SigType _onePassSignatureHashAlgorithm :: HashAlgorithm _onePassSignaturePubKeyAlgorithm :: PubKeyAlgorithm _onePassSignatureEightOctetKeyId :: EightOctetKeyId _onePassSignatureNestedFlag :: NestedFlag

Instances

Eq OnePassSignature # |
Methods (==) :: OnePassSignature -> OnePassSignature -> Bool # (/=) :: OnePassSignature -> OnePassSignature -> Bool #
Data OnePassSignature # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OnePassSignature -> c OnePassSignature # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OnePassSignature # toConstr :: OnePassSignature -> Constr # dataTypeOf :: OnePassSignature -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c OnePassSignature) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OnePassSignature) # gmapT :: (forall b. Data b => b -> b) -> OnePassSignature -> OnePassSignature # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OnePassSignature -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OnePassSignature -> r # gmapQ :: (forall d. Data d => d -> u) -> OnePassSignature -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OnePassSignature -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OnePassSignature -> m OnePassSignature # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OnePassSignature -> m OnePassSignature # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OnePassSignature -> m OnePassSignature #
Show OnePassSignature # |
Methods showsPrec :: Int -> OnePassSignature -> ShowS # show :: OnePassSignature -> String # showList :: [OnePassSignature] -> ShowS #
Pretty OnePassSignature # |
Methods pretty :: OnePassSignature -> Doc e # prettyList :: [OnePassSignature] -> Doc e #
Packet OnePassSignature # |
Associated Types data PacketType OnePassSignature :: * # Methods packetType :: OnePassSignature -> PacketType OnePassSignature # packetCode :: PacketType OnePassSignature -> Word8 # toPkt :: OnePassSignature -> Pkt # fromPkt :: Pkt -> OnePassSignature #
Eq (PacketType OnePassSignature) # |
Methods (==) :: PacketType OnePassSignature -> PacketType OnePassSignature -> Bool # (/=) :: PacketType OnePassSignature -> PacketType OnePassSignature -> Bool #
Show (PacketType OnePassSignature) # |
Methods showsPrec :: Int -> PacketType OnePassSignature -> ShowS # show :: PacketType OnePassSignature -> String # showList :: [PacketType OnePassSignature] -> ShowS #
data PacketType OnePassSignature # |
data PacketType OnePassSignature = OnePassSignatureType

data SecretKey #

Constructors

SecretKey |
Fields _secretKeyPKPayload :: PKPayload _secretKeySKAddendum :: SKAddendum

Instances

Eq SecretKey # |
Methods (==) :: SecretKey -> SecretKey -> Bool # (/=) :: SecretKey -> SecretKey -> Bool #
Data SecretKey # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SecretKey -> c SecretKey # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SecretKey # toConstr :: SecretKey -> Constr # dataTypeOf :: SecretKey -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SecretKey) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SecretKey) # gmapT :: (forall b. Data b => b -> b) -> SecretKey -> SecretKey # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SecretKey -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SecretKey -> r # gmapQ :: (forall d. Data d => d -> u) -> SecretKey -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SecretKey -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SecretKey -> m SecretKey # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SecretKey -> m SecretKey # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SecretKey -> m SecretKey #
Show SecretKey # |
Methods showsPrec :: Int -> SecretKey -> ShowS # show :: SecretKey -> String # showList :: [SecretKey] -> ShowS #
Pretty SecretKey # |
Methods pretty :: SecretKey -> Doc e # prettyList :: [SecretKey] -> Doc e #
Packet SecretKey # |
Associated Types data PacketType SecretKey :: * # Methods packetType :: SecretKey -> PacketType SecretKey # packetCode :: PacketType SecretKey -> Word8 # toPkt :: SecretKey -> Pkt # fromPkt :: Pkt -> SecretKey #
Eq (PacketType SecretKey) # |
Methods (==) :: PacketType SecretKey -> PacketType SecretKey -> Bool # (/=) :: PacketType SecretKey -> PacketType SecretKey -> Bool #
Show (PacketType SecretKey) # |
Methods showsPrec :: Int -> PacketType SecretKey -> ShowS # show :: PacketType SecretKey -> String # showList :: [PacketType SecretKey] -> ShowS #
data PacketType SecretKey # |
data PacketType SecretKey = SecretKeyType

data PublicKey #

Constructors

PublicKey |
Fields _publicKeyPKPayload :: PKPayload

Instances

Eq PublicKey # |
Methods (==) :: PublicKey -> PublicKey -> Bool # (/=) :: PublicKey -> PublicKey -> Bool #
Data PublicKey # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PublicKey -> c PublicKey # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PublicKey # toConstr :: PublicKey -> Constr # dataTypeOf :: PublicKey -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PublicKey) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PublicKey) # gmapT :: (forall b. Data b => b -> b) -> PublicKey -> PublicKey # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PublicKey -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PublicKey -> r # gmapQ :: (forall d. Data d => d -> u) -> PublicKey -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PublicKey -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey #
Show PublicKey # |
Methods showsPrec :: Int -> PublicKey -> ShowS # show :: PublicKey -> String # showList :: [PublicKey] -> ShowS #
Pretty PublicKey # |
Methods pretty :: PublicKey -> Doc e # prettyList :: [PublicKey] -> Doc e #
Packet PublicKey # |
Associated Types data PacketType PublicKey :: * # Methods packetType :: PublicKey -> PacketType PublicKey # packetCode :: PacketType PublicKey -> Word8 # toPkt :: PublicKey -> Pkt # fromPkt :: Pkt -> PublicKey #
Eq (PacketType PublicKey) # |
Methods (==) :: PacketType PublicKey -> PacketType PublicKey -> Bool # (/=) :: PacketType PublicKey -> PacketType PublicKey -> Bool #
Show (PacketType PublicKey) # |
Methods showsPrec :: Int -> PacketType PublicKey -> ShowS # show :: PacketType PublicKey -> String # showList :: [PacketType PublicKey] -> ShowS #
data PacketType PublicKey # |
data PacketType PublicKey = PublicKeyType

data SecretSubkey #

Constructors

SecretSubkey |
Fields _secretSubkeyPKPayload :: PKPayload _secretSubkeySKAddendum :: SKAddendum

Instances

Eq SecretSubkey # |
Methods (==) :: SecretSubkey -> SecretSubkey -> Bool # (/=) :: SecretSubkey -> SecretSubkey -> Bool #
Data SecretSubkey # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SecretSubkey -> c SecretSubkey # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SecretSubkey # toConstr :: SecretSubkey -> Constr # dataTypeOf :: SecretSubkey -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SecretSubkey) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SecretSubkey) # gmapT :: (forall b. Data b => b -> b) -> SecretSubkey -> SecretSubkey # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SecretSubkey -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SecretSubkey -> r # gmapQ :: (forall d. Data d => d -> u) -> SecretSubkey -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SecretSubkey -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SecretSubkey -> m SecretSubkey # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SecretSubkey -> m SecretSubkey # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SecretSubkey -> m SecretSubkey #
Show SecretSubkey # |
Methods showsPrec :: Int -> SecretSubkey -> ShowS # show :: SecretSubkey -> String # showList :: [SecretSubkey] -> ShowS #
Pretty SecretSubkey # |
Methods pretty :: SecretSubkey -> Doc e # prettyList :: [SecretSubkey] -> Doc e #
Packet SecretSubkey # |
Associated Types data PacketType SecretSubkey :: * # Methods packetType :: SecretSubkey -> PacketType SecretSubkey # packetCode :: PacketType SecretSubkey -> Word8 # toPkt :: SecretSubkey -> Pkt # fromPkt :: Pkt -> SecretSubkey #
Eq (PacketType SecretSubkey) # |
Methods (==) :: PacketType SecretSubkey -> PacketType SecretSubkey -> Bool # (/=) :: PacketType SecretSubkey -> PacketType SecretSubkey -> Bool #
Show (PacketType SecretSubkey) # |
Methods showsPrec :: Int -> PacketType SecretSubkey -> ShowS # show :: PacketType SecretSubkey -> String # showList :: [PacketType SecretSubkey] -> ShowS #
data PacketType SecretSubkey # |
data PacketType SecretSubkey = SecretSubkeyType

data CompressedData #

Constructors

CompressedData |
Fields _compressedDataCompressionAlgorithm :: CompressionAlgorithm _compressedDataPayload :: CompressedDataPayload

Instances

Eq CompressedData # |
Methods (==) :: CompressedData -> CompressedData -> Bool # (/=) :: CompressedData -> CompressedData -> Bool #
Data CompressedData # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CompressedData -> c CompressedData # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CompressedData # toConstr :: CompressedData -> Constr # dataTypeOf :: CompressedData -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c CompressedData) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompressedData) # gmapT :: (forall b. Data b => b -> b) -> CompressedData -> CompressedData # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CompressedData -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CompressedData -> r # gmapQ :: (forall d. Data d => d -> u) -> CompressedData -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CompressedData -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CompressedData -> m CompressedData # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CompressedData -> m CompressedData # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CompressedData -> m CompressedData #
Show CompressedData # |
Methods showsPrec :: Int -> CompressedData -> ShowS # show :: CompressedData -> String # showList :: [CompressedData] -> ShowS #
Pretty CompressedData # |
Methods pretty :: CompressedData -> Doc e # prettyList :: [CompressedData] -> Doc e #
Packet CompressedData # |
Associated Types data PacketType CompressedData :: * # Methods packetType :: CompressedData -> PacketType CompressedData # packetCode :: PacketType CompressedData -> Word8 # toPkt :: CompressedData -> Pkt # fromPkt :: Pkt -> CompressedData #
Eq (PacketType CompressedData) # |
Methods (==) :: PacketType CompressedData -> PacketType CompressedData -> Bool # (/=) :: PacketType CompressedData -> PacketType CompressedData -> Bool #
Show (PacketType CompressedData) # |
Methods showsPrec :: Int -> PacketType CompressedData -> ShowS # show :: PacketType CompressedData -> String # showList :: [PacketType CompressedData] -> ShowS #
data PacketType CompressedData # |
data PacketType CompressedData = CompressedDataType

data SymEncData #

Constructors

SymEncData |
Fields _symEncDataPayload :: ByteString

Instances

Eq SymEncData # |
Methods (==) :: SymEncData -> SymEncData -> Bool # (/=) :: SymEncData -> SymEncData -> Bool #
Data SymEncData # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SymEncData -> c SymEncData # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SymEncData # toConstr :: SymEncData -> Constr # dataTypeOf :: SymEncData -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SymEncData) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SymEncData) # gmapT :: (forall b. Data b => b -> b) -> SymEncData -> SymEncData # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SymEncData -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SymEncData -> r # gmapQ :: (forall d. Data d => d -> u) -> SymEncData -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SymEncData -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SymEncData -> m SymEncData # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SymEncData -> m SymEncData # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SymEncData -> m SymEncData #
Show SymEncData # |
Methods showsPrec :: Int -> SymEncData -> ShowS # show :: SymEncData -> String # showList :: [SymEncData] -> ShowS #
Pretty SymEncData # |
Methods pretty :: SymEncData -> Doc e # prettyList :: [SymEncData] -> Doc e #
Packet SymEncData # |
Associated Types data PacketType SymEncData :: * # Methods packetType :: SymEncData -> PacketType SymEncData # packetCode :: PacketType SymEncData -> Word8 # toPkt :: SymEncData -> Pkt # fromPkt :: Pkt -> SymEncData #
Eq (PacketType SymEncData) # |
Methods (==) :: PacketType SymEncData -> PacketType SymEncData -> Bool # (/=) :: PacketType SymEncData -> PacketType SymEncData -> Bool #
Show (PacketType SymEncData) # |
Methods showsPrec :: Int -> PacketType SymEncData -> ShowS # show :: PacketType SymEncData -> String # showList :: [PacketType SymEncData] -> ShowS #
data PacketType SymEncData # |
data PacketType SymEncData = SymEncDataType

data Marker #

Constructors

Marker |
Fields _markerPayload :: ByteString

Instances

Eq Marker # |
Methods (==) :: Marker -> Marker -> Bool # (/=) :: Marker -> Marker -> Bool #
Data Marker # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Marker -> c Marker # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Marker # toConstr :: Marker -> Constr # dataTypeOf :: Marker -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Marker) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Marker) # gmapT :: (forall b. Data b => b -> b) -> Marker -> Marker # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Marker -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Marker -> r # gmapQ :: (forall d. Data d => d -> u) -> Marker -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Marker -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Marker -> m Marker # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Marker -> m Marker # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Marker -> m Marker #
Show Marker # |
Methods showsPrec :: Int -> Marker -> ShowS # show :: Marker -> String # showList :: [Marker] -> ShowS #
Pretty Marker # |
Methods pretty :: Marker -> Doc e # prettyList :: [Marker] -> Doc e #
Packet Marker # |
Associated Types data PacketType Marker :: * # Methods packetType :: Marker -> PacketType Marker # packetCode :: PacketType Marker -> Word8 # toPkt :: Marker -> Pkt # fromPkt :: Pkt -> Marker #
Eq (PacketType Marker) # |
Methods (==) :: PacketType Marker -> PacketType Marker -> Bool # (/=) :: PacketType Marker -> PacketType Marker -> Bool #
Show (PacketType Marker) # |
Methods showsPrec :: Int -> PacketType Marker -> ShowS # show :: PacketType Marker -> String # showList :: [PacketType Marker] -> ShowS #
data PacketType Marker # |
data PacketType Marker = MarkerType

data LiteralData #

Constructors

LiteralData |
Fields _literalDataDataType :: DataType _literalDataFileName :: FileName _literalDataTimeStamp :: ThirtyTwoBitTimeStamp _literalDataPayload :: ByteString

Instances

Eq LiteralData # |
Methods (==) :: LiteralData -> LiteralData -> Bool # (/=) :: LiteralData -> LiteralData -> Bool #
Data LiteralData # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LiteralData -> c LiteralData # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LiteralData # toConstr :: LiteralData -> Constr # dataTypeOf :: LiteralData -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c LiteralData) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LiteralData) # gmapT :: (forall b. Data b => b -> b) -> LiteralData -> LiteralData # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LiteralData -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LiteralData -> r # gmapQ :: (forall d. Data d => d -> u) -> LiteralData -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> LiteralData -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> LiteralData -> m LiteralData # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LiteralData -> m LiteralData # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LiteralData -> m LiteralData #
Show LiteralData # |
Methods showsPrec :: Int -> LiteralData -> ShowS # show :: LiteralData -> String # showList :: [LiteralData] -> ShowS #
Pretty LiteralData # |
Methods pretty :: LiteralData -> Doc e # prettyList :: [LiteralData] -> Doc e #
Packet LiteralData # |
Associated Types data PacketType LiteralData :: * # Methods packetType :: LiteralData -> PacketType LiteralData # packetCode :: PacketType LiteralData -> Word8 # toPkt :: LiteralData -> Pkt # fromPkt :: Pkt -> LiteralData #
Eq (PacketType LiteralData) # |
Methods (==) :: PacketType LiteralData -> PacketType LiteralData -> Bool # (/=) :: PacketType LiteralData -> PacketType LiteralData -> Bool #
Show (PacketType LiteralData) # |
Methods showsPrec :: Int -> PacketType LiteralData -> ShowS # show :: PacketType LiteralData -> String # showList :: [PacketType LiteralData] -> ShowS #
data PacketType LiteralData # |
data PacketType LiteralData = LiteralDataType

data Trust #

Constructors

Trust |
Fields _trustPayload :: ByteString

Instances

Eq Trust # |
Methods (==) :: Trust -> Trust -> Bool # (/=) :: Trust -> Trust -> Bool #
Data Trust # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Trust -> c Trust # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Trust # toConstr :: Trust -> Constr # dataTypeOf :: Trust -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Trust) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Trust) # gmapT :: (forall b. Data b => b -> b) -> Trust -> Trust # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Trust -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Trust -> r # gmapQ :: (forall d. Data d => d -> u) -> Trust -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Trust -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Trust -> m Trust # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Trust -> m Trust # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Trust -> m Trust #
Show Trust # |
Methods showsPrec :: Int -> Trust -> ShowS # show :: Trust -> String # showList :: [Trust] -> ShowS #
Pretty Trust # |
Methods pretty :: Trust -> Doc e # prettyList :: [Trust] -> Doc e #
Packet Trust # |
Associated Types data PacketType Trust :: * # Methods packetType :: Trust -> PacketType Trust # packetCode :: PacketType Trust -> Word8 # toPkt :: Trust -> Pkt # fromPkt :: Pkt -> Trust #
Eq (PacketType Trust) # |
Methods (==) :: PacketType Trust -> PacketType Trust -> Bool # (/=) :: PacketType Trust -> PacketType Trust -> Bool #
Show (PacketType Trust) # |
Methods showsPrec :: Int -> PacketType Trust -> ShowS # show :: PacketType Trust -> String # showList :: [PacketType Trust] -> ShowS #
data PacketType Trust # |
data PacketType Trust = TrustType

data UserId #

Constructors

UserId |
Fields _userIdPayload :: Text

Instances

Eq UserId # |
Methods (==) :: UserId -> UserId -> Bool # (/=) :: UserId -> UserId -> Bool #
Data UserId # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UserId -> c UserId # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UserId # toConstr :: UserId -> Constr # dataTypeOf :: UserId -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c UserId) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UserId) # gmapT :: (forall b. Data b => b -> b) -> UserId -> UserId # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UserId -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UserId -> r # gmapQ :: (forall d. Data d => d -> u) -> UserId -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UserId -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UserId -> m UserId # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UserId -> m UserId # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UserId -> m UserId #
Show UserId # |
Methods showsPrec :: Int -> UserId -> ShowS # show :: UserId -> String # showList :: [UserId] -> ShowS #
Pretty UserId # |
Methods pretty :: UserId -> Doc e # prettyList :: [UserId] -> Doc e #
Packet UserId # |
Associated Types data PacketType UserId :: * # Methods packetType :: UserId -> PacketType UserId # packetCode :: PacketType UserId -> Word8 # toPkt :: UserId -> Pkt # fromPkt :: Pkt -> UserId #
Eq (PacketType UserId) # |
Methods (==) :: PacketType UserId -> PacketType UserId -> Bool # (/=) :: PacketType UserId -> PacketType UserId -> Bool #
Show (PacketType UserId) # |
Methods showsPrec :: Int -> PacketType UserId -> ShowS # show :: PacketType UserId -> String # showList :: [PacketType UserId] -> ShowS #
data PacketType UserId # |
data PacketType UserId = UserIdType

data PublicSubkey #

Constructors

PublicSubkey |
Fields _publicSubkeyPKPayload :: PKPayload

Instances

Eq PublicSubkey # |
Methods (==) :: PublicSubkey -> PublicSubkey -> Bool # (/=) :: PublicSubkey -> PublicSubkey -> Bool #
Data PublicSubkey # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PublicSubkey -> c PublicSubkey # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PublicSubkey # toConstr :: PublicSubkey -> Constr # dataTypeOf :: PublicSubkey -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PublicSubkey) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PublicSubkey) # gmapT :: (forall b. Data b => b -> b) -> PublicSubkey -> PublicSubkey # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PublicSubkey -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PublicSubkey -> r # gmapQ :: (forall d. Data d => d -> u) -> PublicSubkey -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PublicSubkey -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PublicSubkey -> m PublicSubkey # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PublicSubkey -> m PublicSubkey # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PublicSubkey -> m PublicSubkey #
Show PublicSubkey # |
Methods showsPrec :: Int -> PublicSubkey -> ShowS # show :: PublicSubkey -> String # showList :: [PublicSubkey] -> ShowS #
Pretty PublicSubkey # |
Methods pretty :: PublicSubkey -> Doc e # prettyList :: [PublicSubkey] -> Doc e #
Packet PublicSubkey # |
Associated Types data PacketType PublicSubkey :: * # Methods packetType :: PublicSubkey -> PacketType PublicSubkey # packetCode :: PacketType PublicSubkey -> Word8 # toPkt :: PublicSubkey -> Pkt # fromPkt :: Pkt -> PublicSubkey #
Eq (PacketType PublicSubkey) # |
Methods (==) :: PacketType PublicSubkey -> PacketType PublicSubkey -> Bool # (/=) :: PacketType PublicSubkey -> PacketType PublicSubkey -> Bool #
Show (PacketType PublicSubkey) # |
Methods showsPrec :: Int -> PacketType PublicSubkey -> ShowS # show :: PacketType PublicSubkey -> String # showList :: [PacketType PublicSubkey] -> ShowS #
data PacketType PublicSubkey # |
data PacketType PublicSubkey = PublicSubkeyType

data UserAttribute #

Constructors

UserAttribute |
Fields _userAttributeSubPackets :: [UserAttrSubPacket]

Instances

Eq UserAttribute # |
Methods (==) :: UserAttribute -> UserAttribute -> Bool # (/=) :: UserAttribute -> UserAttribute -> Bool #
Data UserAttribute # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UserAttribute -> c UserAttribute # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UserAttribute # toConstr :: UserAttribute -> Constr # dataTypeOf :: UserAttribute -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c UserAttribute) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UserAttribute) # gmapT :: (forall b. Data b => b -> b) -> UserAttribute -> UserAttribute # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UserAttribute -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UserAttribute -> r # gmapQ :: (forall d. Data d => d -> u) -> UserAttribute -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UserAttribute -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UserAttribute -> m UserAttribute # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UserAttribute -> m UserAttribute # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UserAttribute -> m UserAttribute #
Show UserAttribute # |
Methods showsPrec :: Int -> UserAttribute -> ShowS # show :: UserAttribute -> String # showList :: [UserAttribute] -> ShowS #
Pretty UserAttribute # |
Methods pretty :: UserAttribute -> Doc e # prettyList :: [UserAttribute] -> Doc e #
Packet UserAttribute # |
Associated Types data PacketType UserAttribute :: * # Methods packetType :: UserAttribute -> PacketType UserAttribute # packetCode :: PacketType UserAttribute -> Word8 # toPkt :: UserAttribute -> Pkt # fromPkt :: Pkt -> UserAttribute #
Eq (PacketType UserAttribute) # |
Methods (==) :: PacketType UserAttribute -> PacketType UserAttribute -> Bool # (/=) :: PacketType UserAttribute -> PacketType UserAttribute -> Bool #
Show (PacketType UserAttribute) # |
Methods showsPrec :: Int -> PacketType UserAttribute -> ShowS # show :: PacketType UserAttribute -> String # showList :: [PacketType UserAttribute] -> ShowS #
data PacketType UserAttribute # |
data PacketType UserAttribute = UserAttributeType

data SymEncIntegrityProtectedData #

Constructors

SymEncIntegrityProtectedData |
Fields _symEncIntegrityProtectedDataPacketVersion :: PacketVersion _symEncIntegrityProtectedDataPayload :: ByteString

Instances

Eq SymEncIntegrityProtectedData # |
Methods (==) :: SymEncIntegrityProtectedData -> SymEncIntegrityProtectedData -> Bool # (/=) :: SymEncIntegrityProtectedData -> SymEncIntegrityProtectedData -> Bool #
Data SymEncIntegrityProtectedData # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SymEncIntegrityProtectedData -> c SymEncIntegrityProtectedData # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SymEncIntegrityProtectedData # toConstr :: SymEncIntegrityProtectedData -> Constr # dataTypeOf :: SymEncIntegrityProtectedData -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SymEncIntegrityProtectedData) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SymEncIntegrityProtectedData) # gmapT :: (forall b. Data b => b -> b) -> SymEncIntegrityProtectedData -> SymEncIntegrityProtectedData # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SymEncIntegrityProtectedData -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SymEncIntegrityProtectedData -> r # gmapQ :: (forall d. Data d => d -> u) -> SymEncIntegrityProtectedData -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SymEncIntegrityProtectedData -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SymEncIntegrityProtectedData -> m SymEncIntegrityProtectedData # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SymEncIntegrityProtectedData -> m SymEncIntegrityProtectedData # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SymEncIntegrityProtectedData -> m SymEncIntegrityProtectedData #
Show SymEncIntegrityProtectedData # |
Methods showsPrec :: Int -> SymEncIntegrityProtectedData -> ShowS # show :: SymEncIntegrityProtectedData -> String # showList :: [SymEncIntegrityProtectedData] -> ShowS #
Pretty SymEncIntegrityProtectedData # |
Methods pretty :: SymEncIntegrityProtectedData -> Doc e # prettyList :: [SymEncIntegrityProtectedData] -> Doc e #
Packet SymEncIntegrityProtectedData # |
Associated Types data PacketType SymEncIntegrityProtectedData :: * # Methods packetType :: SymEncIntegrityProtectedData -> PacketType SymEncIntegrityProtectedData # packetCode :: PacketType SymEncIntegrityProtectedData -> Word8 # toPkt :: SymEncIntegrityProtectedData -> Pkt # fromPkt :: Pkt -> SymEncIntegrityProtectedData #
Eq (PacketType SymEncIntegrityProtectedData) # |
Methods (==) :: PacketType SymEncIntegrityProtectedData -> PacketType SymEncIntegrityProtectedData -> Bool # (/=) :: PacketType SymEncIntegrityProtectedData -> PacketType SymEncIntegrityProtectedData -> Bool #
Show (PacketType SymEncIntegrityProtectedData) # |
Methods showsPrec :: Int -> PacketType SymEncIntegrityProtectedData -> ShowS # show :: PacketType SymEncIntegrityProtectedData -> String # showList :: [PacketType SymEncIntegrityProtectedData] -> ShowS #
data PacketType SymEncIntegrityProtectedData # |
data PacketType SymEncIntegrityProtectedData = SymEncIntegrityProtectedDataType

data ModificationDetectionCode #

Constructors

ModificationDetectionCode |
Fields _modificationDetectionCodePayload :: ByteString

Instances

Eq ModificationDetectionCode # |
Methods (==) :: ModificationDetectionCode -> ModificationDetectionCode -> Bool # (/=) :: ModificationDetectionCode -> ModificationDetectionCode -> Bool #
Data ModificationDetectionCode # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModificationDetectionCode -> c ModificationDetectionCode # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModificationDetectionCode # toConstr :: ModificationDetectionCode -> Constr # dataTypeOf :: ModificationDetectionCode -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ModificationDetectionCode) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModificationDetectionCode) # gmapT :: (forall b. Data b => b -> b) -> ModificationDetectionCode -> ModificationDetectionCode # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModificationDetectionCode -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModificationDetectionCode -> r # gmapQ :: (forall d. Data d => d -> u) -> ModificationDetectionCode -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ModificationDetectionCode -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModificationDetectionCode -> m ModificationDetectionCode # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModificationDetectionCode -> m ModificationDetectionCode # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModificationDetectionCode -> m ModificationDetectionCode #
Show ModificationDetectionCode # |
Methods showsPrec :: Int -> ModificationDetectionCode -> ShowS # show :: ModificationDetectionCode -> String # showList :: [ModificationDetectionCode] -> ShowS #
Pretty ModificationDetectionCode # |
Methods pretty :: ModificationDetectionCode -> Doc e # prettyList :: [ModificationDetectionCode] -> Doc e #
Packet ModificationDetectionCode # |
Associated Types data PacketType ModificationDetectionCode :: * # Methods packetType :: ModificationDetectionCode -> PacketType ModificationDetectionCode # packetCode :: PacketType ModificationDetectionCode -> Word8 # toPkt :: ModificationDetectionCode -> Pkt # fromPkt :: Pkt -> ModificationDetectionCode #
Eq (PacketType ModificationDetectionCode) # |
Methods (==) :: PacketType ModificationDetectionCode -> PacketType ModificationDetectionCode -> Bool # (/=) :: PacketType ModificationDetectionCode -> PacketType ModificationDetectionCode -> Bool #
Show (PacketType ModificationDetectionCode) # |
Methods showsPrec :: Int -> PacketType ModificationDetectionCode -> ShowS # show :: PacketType ModificationDetectionCode -> String # showList :: [PacketType ModificationDetectionCode] -> ShowS #
data PacketType ModificationDetectionCode # |
data PacketType ModificationDetectionCode = ModificationDetectionCodeType

data OtherPacket #

Constructors

OtherPacket |
Fields _otherPacketType :: Word8 _otherPacketPayload :: ByteString

Instances

Eq OtherPacket # |
Methods (==) :: OtherPacket -> OtherPacket -> Bool # (/=) :: OtherPacket -> OtherPacket -> Bool #
Data OtherPacket # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OtherPacket -> c OtherPacket # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OtherPacket # toConstr :: OtherPacket -> Constr # dataTypeOf :: OtherPacket -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c OtherPacket) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OtherPacket) # gmapT :: (forall b. Data b => b -> b) -> OtherPacket -> OtherPacket # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OtherPacket -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OtherPacket -> r # gmapQ :: (forall d. Data d => d -> u) -> OtherPacket -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OtherPacket -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OtherPacket -> m OtherPacket # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OtherPacket -> m OtherPacket # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OtherPacket -> m OtherPacket #
Show OtherPacket # |
Methods showsPrec :: Int -> OtherPacket -> ShowS # show :: OtherPacket -> String # showList :: [OtherPacket] -> ShowS #
Pretty OtherPacket # |
Methods pretty :: OtherPacket -> Doc e # prettyList :: [OtherPacket] -> Doc e #
Packet OtherPacket # |
Associated Types data PacketType OtherPacket :: * # Methods packetType :: OtherPacket -> PacketType OtherPacket # packetCode :: PacketType OtherPacket -> Word8 # toPkt :: OtherPacket -> Pkt # fromPkt :: Pkt -> OtherPacket #
Eq (PacketType OtherPacket) # |
Methods (==) :: PacketType OtherPacket -> PacketType OtherPacket -> Bool # (/=) :: PacketType OtherPacket -> PacketType OtherPacket -> Bool #
Show (PacketType OtherPacket) # |
Methods showsPrec :: Int -> PacketType OtherPacket -> ShowS # show :: PacketType OtherPacket -> String # showList :: [PacketType OtherPacket] -> ShowS #
data PacketType OtherPacket # |
data PacketType OtherPacket = OtherPacketType

data BrokenPacket #

Constructors

BrokenPacket |
Fields _brokenPacketParseError :: String _brokenPacketType :: Word8 _brokenPacketPayload :: ByteString

Instances

Eq BrokenPacket # |
Methods (==) :: BrokenPacket -> BrokenPacket -> Bool # (/=) :: BrokenPacket -> BrokenPacket -> Bool #
Data BrokenPacket # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BrokenPacket -> c BrokenPacket # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BrokenPacket # toConstr :: BrokenPacket -> Constr # dataTypeOf :: BrokenPacket -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c BrokenPacket) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BrokenPacket) # gmapT :: (forall b. Data b => b -> b) -> BrokenPacket -> BrokenPacket # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BrokenPacket -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BrokenPacket -> r # gmapQ :: (forall d. Data d => d -> u) -> BrokenPacket -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BrokenPacket -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BrokenPacket -> m BrokenPacket # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BrokenPacket -> m BrokenPacket # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BrokenPacket -> m BrokenPacket #
Show BrokenPacket # |
Methods showsPrec :: Int -> BrokenPacket -> ShowS # show :: BrokenPacket -> String # showList :: [BrokenPacket] -> ShowS #
Pretty BrokenPacket # |
Methods pretty :: BrokenPacket -> Doc e # prettyList :: [BrokenPacket] -> Doc e #
Packet BrokenPacket # |
Associated Types data PacketType BrokenPacket :: * # Methods packetType :: BrokenPacket -> PacketType BrokenPacket # packetCode :: PacketType BrokenPacket -> Word8 # toPkt :: BrokenPacket -> Pkt # fromPkt :: Pkt -> BrokenPacket #
Eq (PacketType BrokenPacket) # |
Methods (==) :: PacketType BrokenPacket -> PacketType BrokenPacket -> Bool # (/=) :: PacketType BrokenPacket -> PacketType BrokenPacket -> Bool #
Show (PacketType BrokenPacket) # |
Methods showsPrec :: Int -> PacketType BrokenPacket -> ShowS # show :: PacketType BrokenPacket -> String # showList :: [PacketType BrokenPacket] -> ShowS #
data PacketType BrokenPacket # |
data PacketType BrokenPacket = BrokenPacketType

pkeskPubKeyAlgorithm :: Lens' PKESK PubKeyAlgorithm #

pkeskPacketVersion :: Lens' PKESK PacketVersion #

pkeskMPIs :: Lens' PKESK (NonEmpty MPI) #

pkeskEightOctetKeyId :: Lens' PKESK EightOctetKeyId #

signaturePayload :: Iso' Signature SignaturePayload #

skeskSymmetricAlgorithm :: Lens' SKESK SymmetricAlgorithm #

skeskS2K :: Lens' SKESK S2K #

skeskPacketVersion :: Lens' SKESK PacketVersion #

skeskESK :: Lens' SKESK (Maybe ByteString) #

onePassSignatureSigType :: Lens' OnePassSignature SigType #

onePassSignaturePubKeyAlgorithm :: Lens' OnePassSignature PubKeyAlgorithm #

onePassSignaturePacketVersion :: Lens' OnePassSignature PacketVersion #

onePassSignatureNestedFlag :: Lens' OnePassSignature NestedFlag #

onePassSignatureHashAlgorithm :: Lens' OnePassSignature HashAlgorithm #

onePassSignatureEightOctetKeyId :: Lens' OnePassSignature EightOctetKeyId #

secretKeySKAddendum :: Lens' SecretKey SKAddendum #

secretKeyPKPayload :: Lens' SecretKey PKPayload #

v3exp :: Lens' PKPayload V3Expiration #

timestamp :: Lens' PKPayload ThirtyTwoBitTimeStamp #

pubkey :: Lens' PKPayload PKey #

pkalgo :: Lens' PKPayload PubKeyAlgorithm #

keyVersion :: Lens' PKPayload KeyVersion #

publicKeyPKPayload :: Iso' PublicKey PKPayload #

secretSubkeySKAddendum :: Lens' SecretSubkey SKAddendum #

secretSubkeyPKPayload :: Lens' SecretSubkey PKPayload #

compressedDataPayload :: Lens' CompressedData CompressedDataPayload #

compressedDataCompressionAlgorithm :: Lens' CompressedData CompressionAlgorithm #

symEncDataPayload :: Iso' SymEncData ByteString #

markerPayload :: Iso' Marker ByteString #

literalDataTimeStamp :: Lens' LiteralData ThirtyTwoBitTimeStamp #

literalDataPayload :: Lens' LiteralData ByteString #

literalDataFileName :: Lens' LiteralData FileName #

literalDataDataType :: Lens' LiteralData DataType #

trustPayload :: Iso' Trust ByteString #

userIdPayload :: Iso' UserId Text #

publicSubkeyPKPayload :: Iso' PublicSubkey PKPayload #

userAttributeSubPackets :: Iso' UserAttribute [UserAttrSubPacket] #

symEncIntegrityProtectedDataPayload :: Lens' SymEncIntegrityProtectedData ByteString #

symEncIntegrityProtectedDataPacketVersion :: Lens' SymEncIntegrityProtectedData PacketVersion #

modificationDetectionCodePayload :: Iso' ModificationDetectionCode ByteString #

otherPacketType :: Lens' OtherPacket Word8 #

otherPacketPayload :: Lens' OtherPacket ByteString #

brokenPacketType :: Lens' BrokenPacket Word8 #

brokenPacketPayload :: Lens' BrokenPacket ByteString #

brokenPacketParseError :: Lens' BrokenPacket String #

data PKey #

Constructors

RSAPubKey RSA_PublicKey |
DSAPubKey DSA_PublicKey |
ElGamalPubKey [Integer] |
ECDHPubKey ECDSA_PublicKey HashAlgorithm SymmetricAlgorithm |
ECDSAPubKey ECDSA_PublicKey |
UnknownPKey ByteString |

Instances

Eq PKey # |
Methods (==) :: PKey -> PKey -> Bool # (/=) :: PKey -> PKey -> Bool #
Data PKey # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PKey -> c PKey # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PKey # toConstr :: PKey -> Constr # dataTypeOf :: PKey -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PKey) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PKey) # gmapT :: (forall b. Data b => b -> b) -> PKey -> PKey # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PKey -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PKey -> r # gmapQ :: (forall d. Data d => d -> u) -> PKey -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PKey -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PKey -> m PKey # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PKey -> m PKey # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PKey -> m PKey #
Ord PKey # |
Methods compare :: PKey -> PKey -> Ordering # (<) :: PKey -> PKey -> Bool # (<=) :: PKey -> PKey -> Bool # (>) :: PKey -> PKey -> Bool # (>=) :: PKey -> PKey -> Bool # max :: PKey -> PKey -> PKey # min :: PKey -> PKey -> PKey #
Show PKey # |
Methods showsPrec :: Int -> PKey -> ShowS # show :: PKey -> String # showList :: [PKey] -> ShowS #
Generic PKey # |
Associated Types type Rep PKey :: * -> * # Methods from :: PKey -> Rep PKey x # to :: Rep PKey x -> PKey #
ToJSON PKey # |
Methods toJSON :: PKey -> Value # toEncoding :: PKey -> Encoding #
Hashable PKey # |
Methods hashWithSalt :: Int -> PKey -> Int # hash :: PKey -> Int #
Pretty PKey # |
Methods pretty :: PKey -> Doc e # prettyList :: [PKey] -> Doc e #
type Rep PKey # |
type Rep PKey = D1 (MetaData "PKey" "Codec.Encryption.OpenPGP.Types.Internal.PKITypes" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) ((:+:) (C1 (MetaCons "RSAPubKey" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 RSA_PublicKey))) ((:+:) (C1 (MetaCons "DSAPubKey" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 DSA_PublicKey))) (C1 (MetaCons "ElGamalPubKey" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Integer]))))) ((:+:) (C1 (MetaCons "ECDHPubKey" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ECDSA_PublicKey)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 HashAlgorithm)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SymmetricAlgorithm))))) ((:+:) (C1 (MetaCons "ECDSAPubKey" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ECDSA_PublicKey))) (C1 (MetaCons "UnknownPKey" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString))))))

data SKey #

Constructors

RSAPrivateKey RSA_PrivateKey |
DSAPrivateKey DSA_PrivateKey |
ElGamalPrivateKey [Integer] |
ECDHPrivateKey ECDSA_PrivateKey |
ECDSAPrivateKey ECDSA_PrivateKey |
UnknownSKey ByteString |

Instances

Eq SKey # |
Methods (==) :: SKey -> SKey -> Bool # (/=) :: SKey -> SKey -> Bool #
Data SKey # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SKey -> c SKey # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SKey # toConstr :: SKey -> Constr # dataTypeOf :: SKey -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SKey) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SKey) # gmapT :: (forall b. Data b => b -> b) -> SKey -> SKey # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SKey -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SKey -> r # gmapQ :: (forall d. Data d => d -> u) -> SKey -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SKey -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SKey -> m SKey # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SKey -> m SKey # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SKey -> m SKey #
Show SKey # |
Methods showsPrec :: Int -> SKey -> ShowS # show :: SKey -> String # showList :: [SKey] -> ShowS #
Generic SKey # |
Associated Types type Rep SKey :: * -> * # Methods from :: SKey -> Rep SKey x # to :: Rep SKey x -> SKey #
ToJSON SKey # |
Methods toJSON :: SKey -> Value # toEncoding :: SKey -> Encoding #
Hashable SKey # |
Methods hashWithSalt :: Int -> SKey -> Int # hash :: SKey -> Int #
Pretty SKey # |
Methods pretty :: SKey -> Doc e # prettyList :: [SKey] -> Doc e #
type Rep SKey # |
type Rep SKey = D1 (MetaData "SKey" "Codec.Encryption.OpenPGP.Types.Internal.PKITypes" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) ((:+:) (C1 (MetaCons "RSAPrivateKey" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 RSA_PrivateKey))) ((:+:) (C1 (MetaCons "DSAPrivateKey" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 DSA_PrivateKey))) (C1 (MetaCons "ElGamalPrivateKey" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Integer]))))) ((:+:) (C1 (MetaCons "ECDHPrivateKey" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ECDSA_PrivateKey))) ((:+:) (C1 (MetaCons "ECDSAPrivateKey" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ECDSA_PrivateKey))) (C1 (MetaCons "UnknownSKey" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString))))))

data PKPayload #

Constructors

PKPayload |
Fields _keyVersion :: KeyVersion _timestamp :: ThirtyTwoBitTimeStamp _v3exp :: V3Expiration _pkalgo :: PubKeyAlgorithm _pubkey :: PKey

Instances

Eq PKPayload # |
Methods (==) :: PKPayload -> PKPayload -> Bool # (/=) :: PKPayload -> PKPayload -> Bool #
Data PKPayload # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PKPayload -> c PKPayload # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PKPayload # toConstr :: PKPayload -> Constr # dataTypeOf :: PKPayload -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PKPayload) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PKPayload) # gmapT :: (forall b. Data b => b -> b) -> PKPayload -> PKPayload # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PKPayload -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PKPayload -> r # gmapQ :: (forall d. Data d => d -> u) -> PKPayload -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PKPayload -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PKPayload -> m PKPayload # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PKPayload -> m PKPayload # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PKPayload -> m PKPayload #
Ord PKPayload # |
Methods compare :: PKPayload -> PKPayload -> Ordering # (<) :: PKPayload -> PKPayload -> Bool # (<=) :: PKPayload -> PKPayload -> Bool # (>) :: PKPayload -> PKPayload -> Bool # (>=) :: PKPayload -> PKPayload -> Bool # max :: PKPayload -> PKPayload -> PKPayload # min :: PKPayload -> PKPayload -> PKPayload #
Show PKPayload # |
Methods showsPrec :: Int -> PKPayload -> ShowS # show :: PKPayload -> String # showList :: [PKPayload] -> ShowS #
Generic PKPayload # |
Associated Types type Rep PKPayload :: * -> * # Methods from :: PKPayload -> Rep PKPayload x # to :: Rep PKPayload x -> PKPayload #
ToJSON PKPayload # |
Methods toJSON :: PKPayload -> Value # toEncoding :: PKPayload -> Encoding #
Hashable PKPayload # |
Methods hashWithSalt :: Int -> PKPayload -> Int # hash :: PKPayload -> Int #
Pretty PKPayload # |
Methods pretty :: PKPayload -> Doc e # prettyList :: [PKPayload] -> Doc e #
type Rep PKPayload # |
type Rep PKPayload = D1 (MetaData "PKPayload" "Codec.Encryption.OpenPGP.Types.Internal.PKITypes" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) (C1 (MetaCons "PKPayload" PrefixI True) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "_keyVersion") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 KeyVersion)) (S1 (MetaSel (Just Symbol "_timestamp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ThirtyTwoBitTimeStamp))) ((:*:) (S1 (MetaSel (Just Symbol "_v3exp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 V3Expiration)) ((:*:) (S1 (MetaSel (Just Symbol "_pkalgo") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PubKeyAlgorithm)) (S1 (MetaSel (Just Symbol "_pubkey") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PKey))))))

data SKAddendum #

Constructors

SUS16bit SymmetricAlgorithm S2K IV ByteString |
SUSSHA1 SymmetricAlgorithm S2K IV ByteString |
SUSym SymmetricAlgorithm IV ByteString |
SUUnencrypted SKey Word16 |

Instances

Eq SKAddendum # |
Methods (==) :: SKAddendum -> SKAddendum -> Bool # (/=) :: SKAddendum -> SKAddendum -> Bool #
Data SKAddendum # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SKAddendum -> c SKAddendum # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SKAddendum # toConstr :: SKAddendum -> Constr # dataTypeOf :: SKAddendum -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SKAddendum) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SKAddendum) # gmapT :: (forall b. Data b => b -> b) -> SKAddendum -> SKAddendum # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SKAddendum -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SKAddendum -> r # gmapQ :: (forall d. Data d => d -> u) -> SKAddendum -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SKAddendum -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SKAddendum -> m SKAddendum # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SKAddendum -> m SKAddendum # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SKAddendum -> m SKAddendum #
Ord SKAddendum # |
Methods compare :: SKAddendum -> SKAddendum -> Ordering # (<) :: SKAddendum -> SKAddendum -> Bool # (<=) :: SKAddendum -> SKAddendum -> Bool # (>) :: SKAddendum -> SKAddendum -> Bool # (>=) :: SKAddendum -> SKAddendum -> Bool # max :: SKAddendum -> SKAddendum -> SKAddendum # min :: SKAddendum -> SKAddendum -> SKAddendum #
Show SKAddendum # |
Methods showsPrec :: Int -> SKAddendum -> ShowS # show :: SKAddendum -> String # showList :: [SKAddendum] -> ShowS #
Generic SKAddendum # |
Associated Types type Rep SKAddendum :: * -> * # Methods from :: SKAddendum -> Rep SKAddendum x # to :: Rep SKAddendum x -> SKAddendum #
ToJSON SKAddendum # |
Methods toJSON :: SKAddendum -> Value # toEncoding :: SKAddendum -> Encoding #
Hashable SKAddendum # |
Methods hashWithSalt :: Int -> SKAddendum -> Int # hash :: SKAddendum -> Int #
Pretty SKAddendum # |
Methods pretty :: SKAddendum -> Doc e # prettyList :: [SKAddendum] -> Doc e #
type Rep SKAddendum # |
type Rep SKAddendum = D1 (MetaData "SKAddendum" "Codec.Encryption.OpenPGP.Types.Internal.PKITypes" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) ((:+:) (C1 (MetaCons "SUS16bit" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SymmetricAlgorithm)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 S2K))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 IV)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString))))) (C1 (MetaCons "SUSSHA1" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SymmetricAlgorithm)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 S2K))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 IV)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString)))))) ((:+:) (C1 (MetaCons "SUSym" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SymmetricAlgorithm)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 IV)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString))))) (C1 (MetaCons "SUUnencrypted" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SKey)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word16))))))

data Pkt #

Constructors

PKESKPkt PacketVersion EightOctetKeyId PubKeyAlgorithm (NonEmpty MPI) |
SignaturePkt SignaturePayload |
SKESKPkt PacketVersion SymmetricAlgorithm S2K (Maybe ByteString) |
OnePassSignaturePkt PacketVersion SigType HashAlgorithm PubKeyAlgorithm EightOctetKeyId NestedFlag |
SecretKeyPkt PKPayload SKAddendum |
PublicKeyPkt PKPayload |
SecretSubkeyPkt PKPayload SKAddendum |
CompressedDataPkt CompressionAlgorithm CompressedDataPayload |
SymEncDataPkt ByteString |
MarkerPkt ByteString |
LiteralDataPkt DataType FileName ThirtyTwoBitTimeStamp ByteString |
TrustPkt ByteString |
UserIdPkt Text |
PublicSubkeyPkt PKPayload |
UserAttributePkt [UserAttrSubPacket] |
SymEncIntegrityProtectedDataPkt PacketVersion ByteString |
ModificationDetectionCodePkt ByteString |
OtherPacketPkt Word8 ByteString |
BrokenPacketPkt String Word8 ByteString |

Instances

Eq Pkt # |
Methods (==) :: Pkt -> Pkt -> Bool # (/=) :: Pkt -> Pkt -> Bool #
Data Pkt # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pkt -> c Pkt # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pkt # toConstr :: Pkt -> Constr # dataTypeOf :: Pkt -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Pkt) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pkt) # gmapT :: (forall b. Data b => b -> b) -> Pkt -> Pkt # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pkt -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pkt -> r # gmapQ :: (forall d. Data d => d -> u) -> Pkt -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Pkt -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pkt -> m Pkt # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pkt -> m Pkt # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pkt -> m Pkt #
Ord Pkt # |
Methods compare :: Pkt -> Pkt -> Ordering # (<) :: Pkt -> Pkt -> Bool # (<=) :: Pkt -> Pkt -> Bool # (>) :: Pkt -> Pkt -> Bool # (>=) :: Pkt -> Pkt -> Bool # max :: Pkt -> Pkt -> Pkt # min :: Pkt -> Pkt -> Pkt #
Show Pkt # |
Methods showsPrec :: Int -> Pkt -> ShowS # show :: Pkt -> String # showList :: [Pkt] -> ShowS #
Generic Pkt # |
Associated Types type Rep Pkt :: * -> * # Methods from :: Pkt -> Rep Pkt x # to :: Rep Pkt x -> Pkt #
ToJSON Pkt # |
Methods toJSON :: Pkt -> Value # toEncoding :: Pkt -> Encoding #
Hashable Pkt # |
Methods hashWithSalt :: Int -> Pkt -> Int # hash :: Pkt -> Int #
Pretty Pkt # |
Methods pretty :: Pkt -> Doc e # prettyList :: [Pkt] -> Doc e #
type Rep Pkt # |
type Rep Pkt = D1 (MetaData "Pkt" "Codec.Encryption.OpenPGP.Types.Internal.Pkt" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) ((:+:) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "PKESKPkt" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PacketVersion)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 EightOctetKeyId))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PubKeyAlgorithm)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty MPI)))))) (C1 (MetaCons "SignaturePkt" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SignaturePayload)))) ((:+:) (C1 (MetaCons "SKESKPkt" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PacketVersion)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SymmetricAlgorithm))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 S2K)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe ByteString)))))) (C1 (MetaCons "OnePassSignaturePkt" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PacketVersion)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SigType)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 HashAlgorithm)))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PubKeyAlgorithm)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 EightOctetKeyId)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 NestedFlag)))))))) ((:+:) ((:+:) (C1 (MetaCons "SecretKeyPkt" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PKPayload)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SKAddendum)))) (C1 (MetaCons "PublicKeyPkt" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PKPayload)))) ((:+:) (C1 (MetaCons "SecretSubkeyPkt" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PKPayload)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SKAddendum)))) ((:+:) (C1 (MetaCons "CompressedDataPkt" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 CompressionAlgorithm)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 CompressedDataPayload)))) (C1 (MetaCons "SymEncDataPkt" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString))))))) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "MarkerPkt" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString))) (C1 (MetaCons "LiteralDataPkt" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 DataType)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 FileName))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ThirtyTwoBitTimeStamp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString)))))) ((:+:) (C1 (MetaCons "TrustPkt" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString))) ((:+:) (C1 (MetaCons "UserIdPkt" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text))) (C1 (MetaCons "PublicSubkeyPkt" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PKPayload)))))) ((:+:) ((:+:) (C1 (MetaCons "UserAttributePkt" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [UserAttrSubPacket]))) (C1 (MetaCons "SymEncIntegrityProtectedDataPkt" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PacketVersion)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString))))) ((:+:) (C1 (MetaCons "ModificationDetectionCodePkt" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString))) ((:+:) (C1 (MetaCons "OtherPacketPkt" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word8)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString)))) (C1 (MetaCons "BrokenPacketPkt" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word8)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ByteString))))))))))

pktTag :: Pkt -> Word8 #

data Verification #

Constructors

Verification |
Fields _verificationSigner :: PKPayload _verificationSignature :: SignaturePayload

verificationSigner :: Lens' Verification PKPayload #

verificationSignature :: Lens' Verification SignaturePayload #

data TK #

Constructors

TK |
Fields _tkKey :: (PKPayload, Maybe SKAddendum) _tkRevs :: [SignaturePayload] _tkUIDs :: [(Text, [SignaturePayload])] _tkUAts :: [([UserAttrSubPacket], [SignaturePayload])] _tkSubs :: [(Pkt, [SignaturePayload])]

Instances

Eq TK # |
Methods (==) :: TK -> TK -> Bool # (/=) :: TK -> TK -> Bool #
Data TK # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TK -> c TK # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TK # toConstr :: TK -> Constr # dataTypeOf :: TK -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TK) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TK) # gmapT :: (forall b. Data b => b -> b) -> TK -> TK # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TK -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TK -> r # gmapQ :: (forall d. Data d => d -> u) -> TK -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TK -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TK -> m TK # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TK -> m TK # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TK -> m TK #
Ord TK # |
Methods compare :: TK -> TK -> Ordering # (<) :: TK -> TK -> Bool # (<=) :: TK -> TK -> Bool # (>) :: TK -> TK -> Bool # (>=) :: TK -> TK -> Bool # max :: TK -> TK -> TK # min :: TK -> TK -> TK #
Show TK # |
Methods showsPrec :: Int -> TK -> ShowS # show :: TK -> String # showList :: [TK] -> ShowS #
Generic TK # |
Associated Types type Rep TK :: * -> * # Methods from :: TK -> Rep TK x # to :: Rep TK x -> TK #
ToJSON TK # |
Methods toJSON :: TK -> Value # toEncoding :: TK -> Encoding #
type Rep TK # |
type Rep TK = D1 (MetaData "TK" "Codec.Encryption.OpenPGP.Types.Internal.TK" "hOpenPGP-2.5.1-9U0i0pLIOWI2N4Xklpra76" False) (C1 (MetaCons "TK" PrefixI True) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "_tkKey") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (PKPayload, Maybe SKAddendum))) (S1 (MetaSel (Just Symbol "_tkRevs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [SignaturePayload]))) ((:*:) (S1 (MetaSel (Just Symbol "_tkUIDs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(Text, [SignaturePayload])])) ((:*:) (S1 (MetaSel (Just Symbol "_tkUAts") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [([UserAttrSubPacket], [SignaturePayload])])) (S1 (MetaSel (Just Symbol "_tkSubs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(Pkt, [SignaturePayload])]))))))

type KeyringIxs = '[EightOctetKeyId, TwentyOctetFingerprint, Text] #

type Keyring = IxSet KeyringIxs TK #

tkUIDs :: Lens' TK [(Text, [SignaturePayload])] #

tkUAts :: Lens' TK [([UserAttrSubPacket], [SignaturePayload])] #

tkSubs :: Lens' TK [(Pkt, [SignaturePayload])] #

tkRevs :: Lens' TK [SignaturePayload] #

tkKey :: Lens' TK (PKPayload, Maybe SKAddendum) #