    module Network.TLS.Types (
        module Network.TLS.Types.Cipher,
        module Network.TLS.Types.Secret,
        module Network.TLS.Types.Session,
        module Network.TLS.Types.Version,
        HostName,
        Role (..),
        invertRole,
        Direction (..),
        BigNum (..),
        bigNumToInteger,
        bigNumFromInteger,
        defaultRecordSizeLimit,
    ) where

    import Network.Socket (HostName)

    import Network.TLS.Imports
    import Network.TLS.Types.Cipher
    import Network.TLS.Types.Secret
    import Network.TLS.Types.Session
    import Network.TLS.Types.Version
    import Network.TLS.Util.Serialization

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

    -- | Role
    data Role = ClientRole | ServerRole
        deriving (Int -> Role -> ShowS
    [Role] -> ShowS
    Role -> String
    (Int -> Role -> ShowS)
    -> (Role -> String) -> ([Role] -> ShowS) -> Show Role
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Role -> ShowS
    showsPrec :: Int -> Role -> ShowS
    $cshow :: Role -> String
    show :: Role -> String
    $cshowList :: [Role] -> ShowS
    showList :: [Role] -> ShowS
    Show, Role -> Role -> Bool
    (Role -> Role -> Bool) -> (Role -> Role -> Bool) -> Eq Role
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Role -> Role -> Bool
    == :: Role -> Role -> Bool
    $c/= :: Role -> Role -> Bool
    /= :: Role -> Role -> Bool
    Eq)

    invertRole :: Role -> Role
    invertRole :: Role -> Role
    invertRole Role
    ClientRole = Role
    ServerRole
    invertRole Role
    ServerRole = Role
    ClientRole

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

    -- | Direction
    data Direction = Tx | Rx
        deriving (Int -> Direction -> ShowS
    [Direction] -> ShowS
    Direction -> String
    (Int -> Direction -> ShowS)
    -> (Direction -> String)
    -> ([Direction] -> ShowS)
    -> Show Direction
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Direction -> ShowS
    showsPrec :: Int -> Direction -> ShowS
    $cshow :: Direction -> String
    show :: Direction -> String
    $cshowList :: [Direction] -> ShowS
    showList :: [Direction] -> ShowS
    Show, Direction -> Direction -> Bool
    (Direction -> Direction -> Bool)
    -> (Direction -> Direction -> Bool) -> Eq Direction
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Direction -> Direction -> Bool
    == :: Direction -> Direction -> Bool
    $c/= :: Direction -> Direction -> Bool
    /= :: Direction -> Direction -> Bool
    Eq)

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

    newtype BigNum = BigNum ByteString
        deriving (Int -> BigNum -> ShowS
    [BigNum] -> ShowS
    BigNum -> String
    (Int -> BigNum -> ShowS)
    -> (BigNum -> String) -> ([BigNum] -> ShowS) -> Show BigNum
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BigNum -> ShowS
    showsPrec :: Int -> BigNum -> ShowS
    $cshow :: BigNum -> String
    show :: BigNum -> String
    $cshowList :: [BigNum] -> ShowS
    showList :: [BigNum] -> ShowS
    Show, BigNum -> BigNum -> Bool
    (BigNum -> BigNum -> Bool)
    -> (BigNum -> BigNum -> Bool) -> Eq BigNum
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BigNum -> BigNum -> Bool
    == :: BigNum -> BigNum -> Bool
    $c/= :: BigNum -> BigNum -> Bool
    /= :: BigNum -> BigNum -> Bool
    Eq)

    bigNumToInteger :: BigNum -> Integer
    bigNumToInteger :: BigNum -> Integer
    bigNumToInteger (BigNum ByteString
    b) = ByteString -> Integer
    forall ba. ByteArrayAccess ba => ba -> Integer
    os2ip ByteString
    b

    bigNumFromInteger :: Integer -> BigNum
    bigNumFromInteger :: Integer -> BigNum
    bigNumFromInteger Integer
    i = ByteString -> BigNum
    BigNum (ByteString -> BigNum) -> ByteString -> BigNum
    forall a b. (a -> b) -> a -> b
    $ Integer -> ByteString
    forall ba. ByteArray ba => Integer -> ba
    i2osp Integer
    i

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

    -- For plaintext
    -- 2^14 for TLS 1.2
    -- 2^14 + 1 for TLS 1.3
    defaultRecordSizeLimit :: Int
    defaultRecordSizeLimit :: Int
    defaultRecordSizeLimit = Int
    16384