-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | ns-internal
--   
--   A thread-safe DNS library for both clients and servers written in pure
--   Haskell.
@package dns:dns-internal
@version 4.2.0

module Network.DNS.Imports
data ByteString
data Int64
data NonEmpty a
(:|) :: a -> [a] -> NonEmpty a
optional :: Alternative f => f a -> f (Maybe a)
(<**>) :: Applicative f => f a -> f (a -> b) -> f b
liftA :: Applicative f => (a -> b) -> f a -> f b
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
asum :: (Foldable t, Alternative f) => t (f a) -> f a
(<$>) :: Functor f => (a -> b) -> f a -> f b
newtype WrappedArrow (a :: Type -> Type -> Type) b c
WrapArrow :: a b c -> WrappedArrow (a :: Type -> Type -> Type) b c
[unwrapArrow] :: WrappedArrow (a :: Type -> Type -> Type) b c -> a b c
newtype WrappedMonad (m :: Type -> Type) a
WrapMonad :: m a -> WrappedMonad (m :: Type -> Type) a
[unwrapMonad] :: WrappedMonad (m :: Type -> Type) a -> m a
class Applicative f => Alternative (f :: Type -> Type)
empty :: Alternative f => f a
(<|>) :: Alternative f => f a -> f a -> f a
some :: Alternative f => f a -> f [a]
many :: Alternative f => f a -> f [a]
class Functor f => Applicative (f :: Type -> Type)
pure :: Applicative f => a -> f a
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
(*>) :: Applicative f => f a -> f b -> f b
(<*) :: Applicative f => f a -> f b -> f a
(<$) :: Functor f => a -> f b -> f a
newtype Const a (b :: k)
Const :: a -> Const a (b :: k)
[getConst] :: Const a (b :: k) -> a
newtype ZipList a
ZipList :: [a] -> ZipList a
[getZipList] :: ZipList a -> [a]
(=<<) :: Monad m => (a -> m b) -> m a -> m b
ap :: Monad m => m (a -> b) -> m a -> m b
join :: Monad m => m (m a) -> m a
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
when :: Applicative f => Bool -> f () -> f ()
(<$!>) :: Monad m => (a -> b) -> m a -> m b
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
forever :: Applicative f => f a -> f b
guard :: Alternative f => Bool -> f ()
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
replicateM :: Applicative m => Int -> m a -> m [a]
replicateM_ :: Applicative m => Int -> m a -> m ()
unless :: Applicative f => Bool -> f () -> f ()
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
void :: Functor f => f a -> f ()
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
class Functor (f :: Type -> Type)
fmap :: Functor f => (a -> b) -> f a -> f b
(<$) :: Functor f => a -> f b -> f a
class Applicative m => Monad (m :: Type -> Type)
(>>=) :: Monad m => m a -> (a -> m b) -> m b
(>>) :: Monad m => m a -> m b -> m b
return :: Monad m => a -> m a
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
mzero :: MonadPlus m => m a
mplus :: MonadPlus m => m a -> m a -> m a
class Monad m => MonadFail (m :: Type -> Type)
fail :: MonadFail m => String -> m a
mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
bitDefault :: (Bits a, Num a) => Int -> a
popCountDefault :: (Bits a, Num a) => a -> Int
testBitDefault :: (Bits a, Num a) => a -> Int -> Bool
toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b
(!<<.) :: Bits a => a -> Int -> a
(!>>.) :: Bits a => a -> Int -> a
(.<<.) :: Bits a => a -> Int -> a
(.>>.) :: Bits a => a -> Int -> a
(.^.) :: Bits a => a -> a -> a
oneBits :: FiniteBits a => a
class Eq a => Bits a
(.&.) :: Bits a => a -> a -> a
(.|.) :: Bits a => a -> a -> a
xor :: Bits a => a -> a -> a
complement :: Bits a => a -> a
shift :: Bits a => a -> Int -> a
rotate :: Bits a => a -> Int -> a
zeroBits :: Bits a => a
bit :: Bits a => Int -> a
setBit :: Bits a => a -> Int -> a
clearBit :: Bits a => a -> Int -> a
complementBit :: Bits a => a -> Int -> a
testBit :: Bits a => a -> Int -> Bool
bitSizeMaybe :: Bits a => a -> Maybe Int
bitSize :: Bits a => a -> Int
isSigned :: Bits a => a -> Bool
shiftL :: Bits a => a -> Int -> a
unsafeShiftL :: Bits a => a -> Int -> a
shiftR :: Bits a => a -> Int -> a
unsafeShiftR :: Bits a => a -> Int -> a
rotateL :: Bits a => a -> Int -> a
rotateR :: Bits a => a -> Int -> a
popCount :: Bits a => a -> Int
class Bits b => FiniteBits b
finiteBitSize :: FiniteBits b => b -> Int
countLeadingZeros :: FiniteBits b => b -> Int
countTrailingZeros :: FiniteBits b => b -> Int
newtype And a
And :: a -> And a
[getAnd] :: And a -> a
newtype Iff a
Iff :: a -> Iff a
[getIff] :: Iff a -> a
newtype Ior a
Ior :: a -> Ior a
[getIor] :: Ior a -> a
newtype Xor a
Xor :: a -> Xor a
[getXor] :: Xor a -> a
($) :: (a -> b) -> a -> b
(.) :: (b -> c) -> (a -> b) -> a -> c
const :: a -> b -> a
flip :: (a -> b -> c) -> b -> a -> c
id :: a -> a
(&) :: a -> (a -> b) -> b
applyWhen :: Bool -> (a -> a) -> a -> a
fix :: (a -> a) -> a
on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
compareLength :: [a] -> Int -> Ordering
inits1 :: [a] -> [NonEmpty a]
tails1 :: [a] -> [NonEmpty a]
(++) :: [a] -> [a] -> [a]
map :: (a -> b) -> [a] -> [b]
all :: Foldable t => (a -> Bool) -> t a -> Bool
and :: Foldable t => t Bool -> Bool
any :: Foldable t => (a -> Bool) -> t a -> Bool
concat :: Foldable t => t [a] -> [a]
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
find :: Foldable t => (a -> Bool) -> t a -> Maybe a
maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
notElem :: (Foldable t, Eq a) => a -> t a -> Bool
or :: Foldable t => t Bool -> Bool
isSubsequenceOf :: Eq a => [a] -> [a] -> Bool
(\\) :: Eq a => [a] -> [a] -> [a]
delete :: Eq a => a -> [a] -> [a]
deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
dropWhileEnd :: (a -> Bool) -> [a] -> [a]
elemIndex :: Eq a => a -> [a] -> Maybe Int
elemIndices :: Eq a => a -> [a] -> [Int]
findIndex :: (a -> Bool) -> [a] -> Maybe Int
findIndices :: (a -> Bool) -> [a] -> [Int]
genericDrop :: Integral i => i -> [a] -> [a]
genericIndex :: Integral i => [a] -> i -> a
genericLength :: Num i => [a] -> i
genericReplicate :: Integral i => i -> a -> [a]
genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
genericTake :: Integral i => i -> [a] -> [a]
group :: Eq a => [a] -> [[a]]
groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
inits :: [a] -> [[a]]
insert :: Ord a => a -> [a] -> [a]
insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
intercalate :: [a] -> [[a]] -> [a]
intersect :: Eq a => [a] -> [a] -> [a]
intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
intersperse :: a -> [a] -> [a]
isInfixOf :: Eq a => [a] -> [a] -> Bool
isPrefixOf :: Eq a => [a] -> [a] -> Bool
isSuffixOf :: Eq a => [a] -> [a] -> Bool
lines :: String -> [String]
nub :: Eq a => [a] -> [a]
nubBy :: (a -> a -> Bool) -> [a] -> [a]
partition :: (a -> Bool) -> [a] -> ([a], [a])
permutations :: [a] -> [[a]]
singleton :: a -> [a]
sort :: Ord a => [a] -> [a]
sortBy :: (a -> a -> Ordering) -> [a] -> [a]
sortOn :: Ord b => (a -> b) -> [a] -> [a]
stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]
subsequences :: [a] -> [[a]]
tails :: [a] -> [[a]]
transpose :: [[a]] -> [[a]]
unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
union :: Eq a => [a] -> [a] -> [a]
unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
unlines :: [String] -> String
unwords :: [String] -> String
unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d])
unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
words :: String -> [String]
zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
mapAccumL :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
mapAccumR :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
(!!) :: HasCallStack => [a] -> Int -> a
(!?) :: [a] -> Int -> Maybe a
break :: (a -> Bool) -> [a] -> ([a], [a])
cycle :: HasCallStack => [a] -> [a]
drop :: Int -> [a] -> [a]
dropWhile :: (a -> Bool) -> [a] -> [a]
filter :: (a -> Bool) -> [a] -> [a]
foldl1' :: HasCallStack => (a -> a -> a) -> [a] -> a
head :: HasCallStack => [a] -> a
init :: HasCallStack => [a] -> [a]
iterate :: (a -> a) -> a -> [a]
iterate' :: (a -> a) -> a -> [a]
last :: HasCallStack => [a] -> a
lookup :: Eq a => a -> [(a, b)] -> Maybe b
repeat :: a -> [a]
replicate :: Int -> a -> [a]
reverse :: [a] -> [a]
scanl :: (b -> a -> b) -> b -> [a] -> [b]
scanl' :: (b -> a -> b) -> b -> [a] -> [b]
scanl1 :: (a -> a -> a) -> [a] -> [a]
scanr :: (a -> b -> b) -> b -> [a] -> [b]
scanr1 :: (a -> a -> a) -> [a] -> [a]
span :: (a -> Bool) -> [a] -> ([a], [a])
splitAt :: Int -> [a] -> ([a], [a])
tail :: HasCallStack => [a] -> [a]
take :: Int -> [a] -> [a]
takeWhile :: (a -> Bool) -> [a] -> [a]
uncons :: [a] -> Maybe (a, [a])
unsnoc :: [a] -> Maybe ([a], a)
unzip :: [(a, b)] -> ([a], [b])
unzip3 :: [(a, b, c)] -> ([a], [b], [c])
zip :: [a] -> [b] -> [(a, b)]
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
elem :: (Foldable t, Eq a) => a -> t a -> Bool
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
foldl1 :: Foldable t => (a -> a -> a) -> t a -> a
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
foldr1 :: Foldable t => (a -> a -> a) -> t a -> a
length :: Foldable t => t a -> Int
maximum :: (Foldable t, Ord a) => t a -> a
minimum :: (Foldable t, Ord a) => t a -> a
null :: Foldable t => t a -> Bool
product :: (Foldable t, Num a) => t a -> a
sum :: (Foldable t, Num a) => t a -> a
data [] a
catMaybes :: [Maybe a] -> [a]
fromJust :: HasCallStack => Maybe a -> a
fromMaybe :: a -> Maybe a -> a
isJust :: Maybe a -> Bool
isNothing :: Maybe a -> Bool
listToMaybe :: [a] -> Maybe a
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
maybe :: b -> (a -> b) -> Maybe a -> b
maybeToList :: Maybe a -> [a]
data Maybe a
Nothing :: Maybe a
Just :: a -> Maybe a
class Semigroup a => Monoid a
mempty :: Monoid a => a
mappend :: Monoid a => a -> a -> a
mconcat :: Monoid a => [a] -> a
(<>) :: Semigroup a => a -> a -> a
newtype Ap (f :: k -> Type) (a :: k)
Ap :: f a -> Ap (f :: k -> Type) (a :: k)
[getAp] :: Ap (f :: k -> Type) (a :: k) -> f a
newtype First a
First :: Maybe a -> First a
[getFirst] :: First a -> Maybe a
newtype Last a
Last :: Maybe a -> Last a
[getLast] :: Last a -> Maybe a
newtype All
All :: Bool -> All
[getAll] :: All -> Bool
newtype Alt (f :: k -> Type) (a :: k)
Alt :: f a -> Alt (f :: k -> Type) (a :: k)
[getAlt] :: Alt (f :: k -> Type) (a :: k) -> f a
newtype Any
Any :: Bool -> Any
[getAny] :: Any -> Bool
newtype Dual a
Dual :: a -> Dual a
[getDual] :: Dual a -> a
newtype Endo a
Endo :: (a -> a) -> Endo a
[appEndo] :: Endo a -> a -> a
newtype Product a
Product :: a -> Product a
[getProduct] :: Product a -> a
newtype Sum a
Sum :: a -> Sum a
[getSum] :: Sum a -> a
clamp :: Ord a => (a, a) -> a -> a
comparing :: Ord a => (b -> a) -> b -> b -> Ordering
newtype Down a
Down :: a -> Down a
[getDown] :: Down a -> a
class Eq a => Ord a
compare :: Ord a => a -> a -> Ordering
(<) :: Ord a => a -> a -> Bool
(<=) :: Ord a => a -> a -> Bool
(>) :: Ord a => a -> a -> Bool
(>=) :: Ord a => a -> a -> Bool
max :: Ord a => a -> a -> a
min :: Ord a => a -> a -> a
data Ordering
LT :: Ordering
EQ :: Ordering
GT :: Ordering
cast :: (Typeable a, Typeable b) => a -> Maybe b
decT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => Either ((a :~: b) -> Void) (a :~: b)
eqT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => Maybe (a :~: b)
funResultTy :: TypeRep -> TypeRep -> Maybe TypeRep
gcast :: forall {k} (a :: k) (b :: k) c. (Typeable a, Typeable b) => c a -> Maybe (c b)
gcast1 :: forall {k1} {k2} c (t :: k2 -> k1) (t' :: k2 -> k1) (a :: k2). (Typeable t, Typeable t') => c (t a) -> Maybe (c (t' a))
gcast2 :: forall {k1} {k2} {k3} c (t :: k2 -> k3 -> k1) (t' :: k2 -> k3 -> k1) (a :: k2) (b :: k3). (Typeable t, Typeable t') => c (t a b) -> Maybe (c (t' a b))
hdecT :: forall {k1} {k2} (a :: k1) (b :: k2). (Typeable a, Typeable b) => Either ((a :~~: b) -> Void) (a :~~: b)
heqT :: forall {k1} {k2} (a :: k1) (b :: k2). (Typeable a, Typeable b) => Maybe (a :~~: b)
mkFunTy :: TypeRep -> TypeRep -> TypeRep
rnfTypeRep :: TypeRep -> ()
showsTypeRep :: TypeRep -> ShowS
splitTyConApp :: TypeRep -> (TyCon, [TypeRep])
typeOf :: Typeable a => a -> TypeRep
typeOf1 :: Typeable t => t a -> TypeRep
typeOf2 :: Typeable t => t a b -> TypeRep
typeOf3 :: Typeable t => t a b c -> TypeRep
typeOf4 :: Typeable t => t a b c d -> TypeRep
typeOf5 :: Typeable t => t a b c d e -> TypeRep
typeOf6 :: Typeable t => t a b c d e f -> TypeRep
typeOf7 :: Typeable t => t a b c d e f g -> TypeRep
typeRep :: forall {k} proxy (a :: k). Typeable a => proxy a -> TypeRep
typeRepArgs :: TypeRep -> [TypeRep]
typeRepFingerprint :: TypeRep -> Fingerprint
typeRepTyCon :: TypeRep -> TyCon
rnfTyCon :: TyCon -> ()
trLiftedRep :: TypeRep LiftedRep
tyConFingerprint :: TyCon -> Fingerprint
tyConModule :: TyCon -> String
tyConName :: TyCon -> String
tyConPackage :: TyCon -> String
data Proxy (t :: k)
Proxy :: Proxy (t :: k)
data (a :: k) :~: (b :: k)
[Refl] :: forall {k} (a :: k). a :~: a
data (a :: k1) :~~: (b :: k2)
[HRefl] :: forall {k1} (a :: k1). a :~~: a
type TypeRep = SomeTypeRep
class Typeable (a :: k)
data TyCon
bitReverse16 :: Word16 -> Word16
bitReverse32 :: Word32 -> Word32
bitReverse64 :: Word64 -> Word64
bitReverse8 :: Word8 -> Word8
byteSwap16 :: Word16 -> Word16
byteSwap32 :: Word32 -> Word32
byteSwap64 :: Word64 -> Word64
data Word16
data Word32
data Word64
data Word8
data Word
floatToDigits :: RealFloat a => Integer -> a -> ([Int], Int)
fromRat :: RealFloat a => Rational -> a
showFloat :: RealFloat a => a -> ShowS
readBin :: (Eq a, Num a) => ReadS a
readDec :: (Eq a, Num a) => ReadS a
readFloat :: RealFrac a => ReadS a
readHex :: (Eq a, Num a) => ReadS a
readInt :: Num a => a -> (Char -> Bool) -> (Char -> Int) -> ReadS a
readOct :: (Eq a, Num a) => ReadS a
readSigned :: Real a => ReadS a -> ReadS a
showBin :: Integral a => a -> ShowS
showEFloat :: RealFloat a => Maybe Int -> a -> ShowS
showFFloat :: RealFloat a => Maybe Int -> a -> ShowS
showFFloatAlt :: RealFloat a => Maybe Int -> a -> ShowS
showGFloat :: RealFloat a => Maybe Int -> a -> ShowS
showGFloatAlt :: RealFloat a => Maybe Int -> a -> ShowS
showHFloat :: RealFloat a => a -> ShowS
showHex :: Integral a => a -> ShowS
showInt :: Integral a => a -> ShowS
showIntAtBase :: Integral a => a -> (Int -> Char) -> a -> ShowS
showOct :: Integral a => a -> ShowS
lexDigits :: ReadS String
showSigned :: Real a => (a -> ShowS) -> Int -> a -> ShowS
class Fractional a => Floating a
pi :: Floating a => a
exp :: Floating a => a -> a
log :: Floating a => a -> a
sqrt :: Floating a => a -> a
(**) :: Floating a => a -> a -> a
logBase :: Floating a => a -> a -> a
sin :: Floating a => a -> a
cos :: Floating a => a -> a
tan :: Floating a => a -> a
asin :: Floating a => a -> a
acos :: Floating a => a -> a
atan :: Floating a => a -> a
sinh :: Floating a => a -> a
cosh :: Floating a => a -> a
tanh :: Floating a => a -> a
asinh :: Floating a => a -> a
acosh :: Floating a => a -> a
atanh :: Floating a => a -> a
log1p :: Floating a => a -> a
expm1 :: Floating a => a -> a
log1pexp :: Floating a => a -> a
log1mexp :: Floating a => a -> a

module Network.DNS.Base32Hex

-- | Encode ByteString using the <a>RFC4648 base32hex</a> encoding with no
--   padding as specified for the <a>RFC5155 Next Hashed Owner Name</a>
--   field.
encode :: ByteString -> ByteString

module Network.DNS.Resolver.Internal
getDefaultDnsServers :: FilePath -> IO [String]

module Network.DNS.StateBinary
data PState
PState :: IntMap Domain -> Int -> ByteString -> Int64 -> PState
[psDomain] :: PState -> IntMap Domain
[psPosition] :: PState -> Int
[psInput] :: PState -> ByteString
[psAtTime] :: PState -> Int64
initialState :: Int64 -> ByteString -> PState
type SPut = State WState Builder
runSPut :: SPut -> ByteString
put8 :: Word8 -> SPut
put16 :: Word16 -> SPut
put32 :: Word32 -> SPut
putInt8 :: Int -> SPut
putInt16 :: Int -> SPut
putInt32 :: Int -> SPut
putByteString :: ByteString -> SPut
putReplicate :: Int -> Word8 -> SPut
type SGet = StateT PState Parser ByteString
failSGet :: String -> SGet a
fitSGet :: Int -> SGet a -> SGet a
runSGet :: SGet a -> ByteString -> Either DNSError (a, PState)
runSGetAt :: Int64 -> SGet a -> ByteString -> Either DNSError (a, PState)
runSGetWithLeftovers :: SGet a -> ByteString -> Either DNSError ((a, PState), ByteString)
runSGetWithLeftoversAt :: Int64 -> SGet a -> ByteString -> Either DNSError ((a, PState), ByteString)
get8 :: SGet Word8
get16 :: SGet Word16
get32 :: SGet Word32
getInt8 :: SGet Int
getInt16 :: SGet Int
getInt32 :: SGet Int
getNByteString :: Int -> SGet ByteString

-- | Parse a list of elements that takes up exactly a given number of
--   bytes. In order to avoid infinite loops, if an element parser succeeds
--   without moving the buffer offset forward, an error will be returned.
sGetMany :: String -> Int -> SGet a -> SGet [a]
getPosition :: SGet Int
getInput :: SGet ByteString
getAtTime :: SGet Int64
wsPop :: Domain -> State WState (Maybe Int)
wsPush :: Domain -> Int -> State WState ()
wsPosition :: WState -> Int
addPositionW :: Int -> State WState ()
push :: Int -> Domain -> SGet ()
pop :: Int -> SGet (Maybe Domain)
getNBytes :: Int -> SGet [Int]
getNoctets :: Int -> SGet [Word8]
skipNBytes :: Int -> SGet ()

-- | Decode a domain name in A-label form to a leading label and a tail
--   with the remaining labels, unescaping backlashed chars and decimal
--   triples along the way. Any U-label conversion belongs at the layer
--   above this code.
parseLabel :: Word8 -> ByteString -> Either DNSError (ByteString, ByteString)

-- | Convert a wire-form label to presentation-form by escaping the
--   separator, special and non-printing characters. For simple labels with
--   no bytes that require escaping we get back the input bytestring asis
--   with no copying or re-construction.
--   
--   Note: the separator is required to be either '.' or '@', but this
--   constraint is the caller's responsibility and is not checked here.
unparseLabel :: Word8 -> ByteString -> ByteString
instance GHC.Internal.Base.Monoid Network.DNS.StateBinary.SPut
instance GHC.Internal.Base.Semigroup Network.DNS.StateBinary.SPut

module Network.DNS.Memo
data Section
Answer :: Section
Authority :: Section
type Key = (ByteString, TYPE)
type Prio = Elapsed
type Entry = Either DNSError [RData]
type DB = OrdPSQ Key Prio Entry
type Cache = Reaper DB (Key, Prio, Entry)
newCache :: Int -> IO Cache
lookupCache :: Key -> Cache -> IO (Maybe (Prio, Entry))
insertCache :: Key -> Prio -> Entry -> Cache -> IO ()
prune :: DB -> IO (DB -> DB)
copy :: RData -> RData
copyOData :: OData -> OData
instance GHC.Classes.Eq Network.DNS.Memo.Section
instance GHC.Classes.Ord Network.DNS.Memo.Section
instance GHC.Internal.Show.Show Network.DNS.Memo.Section


-- | DNS Message builder.
module Network.DNS.Encode.Builders
putDNSMessage :: DNSMessage -> SPut
putDNSFlags :: DNSFlags -> SPut
putHeader :: DNSHeader -> SPut
putDomain :: Domain -> SPut
putMailbox :: Mailbox -> SPut
putResourceRecord :: ResourceRecord -> SPut

module Network.DNS.Decode.Parsers
getResponse :: SGet DNSMessage
getDNSFlags :: SGet DNSFlags
getHeader :: SGet DNSHeader
getResourceRecord :: SGet ResourceRecord
getResourceRecords :: Int -> SGet [ResourceRecord]

-- | Pointers MUST point back into the packet per RFC1035 Section 4.1.4.
--   This is further interpreted by the DNS community (from a discussion on
--   the IETF DNSOP mailing list) to mean that they don't point back into
--   the same domain. Therefore, when starting to parse a domain, the
--   current offset is also a strict upper bound on the targets of any
--   pointers that arise while processing the domain. When following a
--   pointer, the target again becomes a stict upper bound for any
--   subsequent pointers. This results in a simple loop-prevention
--   algorithm, each sequence of valid pointer values is necessarily
--   strictly decreasing! The third argument to <a>getDomain'</a> is a
--   strict pointer upper bound, and is set here to the position at the
--   start of parsing the domain or mailbox.
--   
--   Note: the separator passed to <a>getDomain'</a> is required to be
--   either '.' or '@', or else <a>unparseLabel</a> needs to be modified to
--   handle the new value.
getDomain :: SGet Domain
getMailbox :: SGet Mailbox

module Network.DNS.Types.Resolver

-- | The type to specify a cache server.
data FileOrNumericHost

-- | A path for "resolv.conf" where one or more IP addresses of DNS servers
--   should be found on Unix. Default DNS servers are automatically
--   detected on Windows regardless of the value of the file name.
RCFilePath :: FilePath -> FileOrNumericHost

-- | A numeric IP address. <i>Warning</i>: host names are invalid.
RCHostName :: HostName -> FileOrNumericHost

-- | Numeric IP addresses. <i>Warning</i>: host names are invalid.
RCHostNames :: [HostName] -> FileOrNumericHost

-- | A numeric IP address and port number. <i>Warning</i>: host names are
--   invalid.
RCHostPort :: HostName -> PortNumber -> FileOrNumericHost

-- | Cache configuration for responses.
data CacheConf
CacheConf :: TTL -> Int -> CacheConf

-- | If RR's TTL is higher than this value, this value is used instead.
[maximumTTL] :: CacheConf -> TTL

-- | Cache pruning interval in seconds.
[pruningDelay] :: CacheConf -> Int

-- | Default cache configuration.
--   
--   <pre>
--   &gt;&gt;&gt; defaultCacheConf
--   CacheConf {maximumTTL = 300, pruningDelay = 10}
--   </pre>
defaultCacheConf :: CacheConf

-- | Type for resolver configuration. Use <a>defaultResolvConf</a> to
--   create a new value.
--   
--   An example to use Google's public DNS cache instead of resolv.conf:
--   
--   <pre>
--   &gt;&gt;&gt; let conf = defaultResolvConf { resolvInfo = RCHostName "8.8.8.8" }
--   </pre>
--   
--   An example to use multiple Google's public DNS cache concurrently:
--   
--   <pre>
--   &gt;&gt;&gt; let conf = defaultResolvConf { resolvInfo = RCHostNames ["8.8.8.8","8.8.4.4"], resolvConcurrent = True }
--   </pre>
--   
--   An example to disable EDNS:
--   
--   <pre>
--   &gt;&gt;&gt; let conf = defaultResolvConf { resolvQueryControls = ednsEnabled FlagClear }
--   </pre>
--   
--   An example to enable query result caching:
--   
--   <pre>
--   &gt;&gt;&gt; let conf = defaultResolvConf { resolvCache = Just defaultCacheConf }
--   </pre>
--   
--   An example to disable requesting recursive service.
--   
--   <pre>
--   &gt;&gt;&gt; let conf = defaultResolvConf { resolvQueryControls = rdFlag FlagClear }
--   </pre>
--   
--   An example to set the AD bit in all queries by default.
--   
--   <pre>
--   &gt;&gt;&gt; let conf = defaultResolvConf { resolvQueryControls = adFlag FlagSet }
--   </pre>
--   
--   An example to set the both the AD and CD bits in all queries by
--   default.
--   
--   <pre>
--   &gt;&gt;&gt; let conf = defaultResolvConf { resolvQueryControls = adFlag FlagSet &lt;&gt; cdFlag FlagSet }
--   </pre>
--   
--   An example with an EDNS buffer size of 1216 bytes, which is more
--   robust with IPv6, and the DO bit set to request DNSSEC responses.
--   
--   <pre>
--   &gt;&gt;&gt; let conf = defaultResolvConf { resolvQueryControls = ednsSetUdpSize (Just 1216) &lt;&gt; doFlag FlagSet }
--   </pre>
data ResolvConf
ResolvConf :: FileOrNumericHost -> Int -> Int -> Bool -> Maybe CacheConf -> QueryControls -> ResolvConf

-- | Server information.
[resolvInfo] :: ResolvConf -> FileOrNumericHost

-- | Timeout in micro seconds.
[resolvTimeout] :: ResolvConf -> Int

-- | The number of retries including the first try.
[resolvRetry] :: ResolvConf -> Int

-- | Concurrent queries if multiple DNS servers are specified.
[resolvConcurrent] :: ResolvConf -> Bool

-- | Cache configuration.
[resolvCache] :: ResolvConf -> Maybe CacheConf

-- | Overrides for the default flags used for queries via resolvers that
--   use this configuration.
[resolvQueryControls] :: ResolvConf -> QueryControls

-- | Return a default <a>ResolvConf</a>:
--   
--   <ul>
--   <li><a>resolvInfo</a> is <a>RCFilePath</a> "/etc/resolv.conf".</li>
--   <li><a>resolvTimeout</a> is 3,000,000 micro seconds.</li>
--   <li><a>resolvRetry</a> is 3.</li>
--   <li><a>resolvConcurrent</a> is False.</li>
--   <li><a>resolvCache</a> is Nothing.</li>
--   <li><a>resolvQueryControls</a> is an empty set of overrides.</li>
--   </ul>
defaultResolvConf :: ResolvConf

-- | Intermediate abstract data type for resolvers. IP address information
--   of DNS servers is generated according to <a>resolvInfo</a> internally.
--   This value can be safely reused for <tt>withResolver</tt>.
--   
--   The naming is confusing for historical reasons.
data ResolvSeed
ResolvSeed :: ResolvConf -> NonEmpty AddrInfo -> ResolvSeed
[resolvconf] :: ResolvSeed -> ResolvConf
[nameservers] :: ResolvSeed -> NonEmpty AddrInfo

-- | Abstract data type of DNS Resolver. This includes newly seeded
--   identifier generators for all specified DNS servers and a cache
--   database.
data Resolver
Resolver :: ResolvSeed -> NonEmpty (IO Word16) -> Maybe Cache -> Resolver
[resolvseed] :: Resolver -> ResolvSeed
[genIds] :: Resolver -> NonEmpty (IO Word16)
[cache] :: Resolver -> Maybe Cache
instance GHC.Internal.Show.Show Network.DNS.Types.Resolver.CacheConf
instance GHC.Internal.Show.Show Network.DNS.Types.Resolver.FileOrNumericHost
instance GHC.Internal.Show.Show Network.DNS.Types.Resolver.ResolvConf
