{-# LANGUAGE DeriveDataTypeable #-}
--------------------------------------------------------------------------------
-- |
-- Module      : Network.OpenID.Types
-- Copyright   : (c) Trevor Elliott, 2008
-- License     : BSD3
--
-- Maintainer  : Trevor Elliott <trevor@geekgateway.com>
-- Stability   : 
-- Portability : 
--

module OpenId2.Types (
    Provider (..)
  , Identifier (..)
  , IdentType (..)
  , AuthenticateException (..)
  ) where

-- Libraries
import Data.Data (Data)
import Data.Typeable (Typeable)
import Web.Authenticate.Internal
import Data.Text (Text)

-- | An OpenID provider.
newtype Provider = Provider { Provider -> Text
providerURI :: Text } deriving (Provider -> Provider -> Bool
(Provider -> Provider -> Bool)
-> (Provider -> Provider -> Bool) -> Eq Provider
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Provider -> Provider -> Bool
$c/= :: Provider -> Provider -> Bool
== :: Provider -> Provider -> Bool
$c== :: Provider -> Provider -> Bool
Eq,Int -> Provider -> ShowS
[Provider] -> ShowS
Provider -> String
(Int -> Provider -> ShowS)
-> (Provider -> String) -> ([Provider] -> ShowS) -> Show Provider
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Provider] -> ShowS
$cshowList :: [Provider] -> ShowS
show :: Provider -> String
$cshow :: Provider -> String
showsPrec :: Int -> Provider -> ShowS
$cshowsPrec :: Int -> Provider -> ShowS
Show)

-- | A valid OpenID identifier.
newtype Identifier = Identifier { Identifier -> Text
identifier :: Text }
    deriving (Identifier -> Identifier -> Bool
(Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool) -> Eq Identifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Identifier -> Identifier -> Bool
$c/= :: Identifier -> Identifier -> Bool
== :: Identifier -> Identifier -> Bool
$c== :: Identifier -> Identifier -> Bool
Eq, Eq Identifier
Eq Identifier
-> (Identifier -> Identifier -> Ordering)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Identifier)
-> (Identifier -> Identifier -> Identifier)
-> Ord Identifier
Identifier -> Identifier -> Bool
Identifier -> Identifier -> Ordering
Identifier -> Identifier -> Identifier
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Identifier -> Identifier -> Identifier
$cmin :: Identifier -> Identifier -> Identifier
max :: Identifier -> Identifier -> Identifier
$cmax :: Identifier -> Identifier -> Identifier
>= :: Identifier -> Identifier -> Bool
$c>= :: Identifier -> Identifier -> Bool
> :: Identifier -> Identifier -> Bool
$c> :: Identifier -> Identifier -> Bool
<= :: Identifier -> Identifier -> Bool
$c<= :: Identifier -> Identifier -> Bool
< :: Identifier -> Identifier -> Bool
$c< :: Identifier -> Identifier -> Bool
compare :: Identifier -> Identifier -> Ordering
$ccompare :: Identifier -> Identifier -> Ordering
$cp1Ord :: Eq Identifier
Ord, Int -> Identifier -> ShowS
[Identifier] -> ShowS
Identifier -> String
(Int -> Identifier -> ShowS)
-> (Identifier -> String)
-> ([Identifier] -> ShowS)
-> Show Identifier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Identifier] -> ShowS
$cshowList :: [Identifier] -> ShowS
show :: Identifier -> String
$cshow :: Identifier -> String
showsPrec :: Int -> Identifier -> ShowS
$cshowsPrec :: Int -> Identifier -> ShowS
Show, ReadPrec [Identifier]
ReadPrec Identifier
Int -> ReadS Identifier
ReadS [Identifier]
(Int -> ReadS Identifier)
-> ReadS [Identifier]
-> ReadPrec Identifier
-> ReadPrec [Identifier]
-> Read Identifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Identifier]
$creadListPrec :: ReadPrec [Identifier]
readPrec :: ReadPrec Identifier
$creadPrec :: ReadPrec Identifier
readList :: ReadS [Identifier]
$creadList :: ReadS [Identifier]
readsPrec :: Int -> ReadS Identifier
$creadsPrec :: Int -> ReadS Identifier
Read, Typeable Identifier
DataType
Constr
Typeable Identifier
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Identifier -> c Identifier)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Identifier)
-> (Identifier -> Constr)
-> (Identifier -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Identifier))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Identifier))
-> ((forall b. Data b => b -> b) -> Identifier -> Identifier)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Identifier -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Identifier -> r)
-> (forall u. (forall d. Data d => d -> u) -> Identifier -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Identifier -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier)
-> Data Identifier
Identifier -> DataType
Identifier -> Constr
(forall b. Data b => b -> b) -> Identifier -> Identifier
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identifier -> c Identifier
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Identifier
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Identifier -> u
forall u. (forall d. Data d => d -> u) -> Identifier -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Identifier
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identifier -> c Identifier
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Identifier)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Identifier)
$cIdentifier :: Constr
$tIdentifier :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Identifier -> m Identifier
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
gmapMp :: (forall d. Data d => d -> m d) -> Identifier -> m Identifier
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
gmapM :: (forall d. Data d => d -> m d) -> Identifier -> m Identifier
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
gmapQi :: Int -> (forall d. Data d => d -> u) -> Identifier -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Identifier -> u
gmapQ :: (forall d. Data d => d -> u) -> Identifier -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Identifier -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
gmapT :: (forall b. Data b => b -> b) -> Identifier -> Identifier
$cgmapT :: (forall b. Data b => b -> b) -> Identifier -> Identifier
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Identifier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Identifier)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Identifier)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Identifier)
dataTypeOf :: Identifier -> DataType
$cdataTypeOf :: Identifier -> DataType
toConstr :: Identifier -> Constr
$ctoConstr :: Identifier -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Identifier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Identifier
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identifier -> c Identifier
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identifier -> c Identifier
$cp1Data :: Typeable Identifier
Data, Typeable)

data IdentType = OPIdent | ClaimedIdent
    deriving (IdentType -> IdentType -> Bool
(IdentType -> IdentType -> Bool)
-> (IdentType -> IdentType -> Bool) -> Eq IdentType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IdentType -> IdentType -> Bool
$c/= :: IdentType -> IdentType -> Bool
== :: IdentType -> IdentType -> Bool
$c== :: IdentType -> IdentType -> Bool
Eq, Eq IdentType
Eq IdentType
-> (IdentType -> IdentType -> Ordering)
-> (IdentType -> IdentType -> Bool)
-> (IdentType -> IdentType -> Bool)
-> (IdentType -> IdentType -> Bool)
-> (IdentType -> IdentType -> Bool)
-> (IdentType -> IdentType -> IdentType)
-> (IdentType -> IdentType -> IdentType)
-> Ord IdentType
IdentType -> IdentType -> Bool
IdentType -> IdentType -> Ordering
IdentType -> IdentType -> IdentType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: IdentType -> IdentType -> IdentType
$cmin :: IdentType -> IdentType -> IdentType
max :: IdentType -> IdentType -> IdentType
$cmax :: IdentType -> IdentType -> IdentType
>= :: IdentType -> IdentType -> Bool
$c>= :: IdentType -> IdentType -> Bool
> :: IdentType -> IdentType -> Bool
$c> :: IdentType -> IdentType -> Bool
<= :: IdentType -> IdentType -> Bool
$c<= :: IdentType -> IdentType -> Bool
< :: IdentType -> IdentType -> Bool
$c< :: IdentType -> IdentType -> Bool
compare :: IdentType -> IdentType -> Ordering
$ccompare :: IdentType -> IdentType -> Ordering
$cp1Ord :: Eq IdentType
Ord, Int -> IdentType -> ShowS
[IdentType] -> ShowS
IdentType -> String
(Int -> IdentType -> ShowS)
-> (IdentType -> String)
-> ([IdentType] -> ShowS)
-> Show IdentType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IdentType] -> ShowS
$cshowList :: [IdentType] -> ShowS
show :: IdentType -> String
$cshow :: IdentType -> String
showsPrec :: Int -> IdentType -> ShowS
$cshowsPrec :: Int -> IdentType -> ShowS
Show, ReadPrec [IdentType]
ReadPrec IdentType
Int -> ReadS IdentType
ReadS [IdentType]
(Int -> ReadS IdentType)
-> ReadS [IdentType]
-> ReadPrec IdentType
-> ReadPrec [IdentType]
-> Read IdentType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [IdentType]
$creadListPrec :: ReadPrec [IdentType]
readPrec :: ReadPrec IdentType
$creadPrec :: ReadPrec IdentType
readList :: ReadS [IdentType]
$creadList :: ReadS [IdentType]
readsPrec :: Int -> ReadS IdentType
$creadsPrec :: Int -> ReadS IdentType
Read, Typeable IdentType
DataType
Constr
Typeable IdentType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IdentType -> c IdentType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c IdentType)
-> (IdentType -> Constr)
-> (IdentType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c IdentType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IdentType))
-> ((forall b. Data b => b -> b) -> IdentType -> IdentType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IdentType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IdentType -> r)
-> (forall u. (forall d. Data d => d -> u) -> IdentType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> IdentType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> IdentType -> m IdentType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IdentType -> m IdentType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IdentType -> m IdentType)
-> Data IdentType
IdentType -> DataType
IdentType -> Constr
(forall b. Data b => b -> b) -> IdentType -> IdentType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IdentType -> c IdentType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IdentType
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> IdentType -> u
forall u. (forall d. Data d => d -> u) -> IdentType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IdentType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IdentType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IdentType -> m IdentType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IdentType -> m IdentType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IdentType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IdentType -> c IdentType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IdentType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IdentType)
$cClaimedIdent :: Constr
$cOPIdent :: Constr
$tIdentType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> IdentType -> m IdentType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IdentType -> m IdentType
gmapMp :: (forall d. Data d => d -> m d) -> IdentType -> m IdentType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IdentType -> m IdentType
gmapM :: (forall d. Data d => d -> m d) -> IdentType -> m IdentType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IdentType -> m IdentType
gmapQi :: Int -> (forall d. Data d => d -> u) -> IdentType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IdentType -> u
gmapQ :: (forall d. Data d => d -> u) -> IdentType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IdentType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IdentType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IdentType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IdentType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IdentType -> r
gmapT :: (forall b. Data b => b -> b) -> IdentType -> IdentType
$cgmapT :: (forall b. Data b => b -> b) -> IdentType -> IdentType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IdentType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IdentType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c IdentType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IdentType)
dataTypeOf :: IdentType -> DataType
$cdataTypeOf :: IdentType -> DataType
toConstr :: IdentType -> Constr
$ctoConstr :: IdentType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IdentType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IdentType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IdentType -> c IdentType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IdentType -> c IdentType
$cp1Data :: Typeable IdentType
Data, Typeable)