    {-# LANGUAGE OverloadedStrings #-}
    {-# LANGUAGE DeriveGeneric #-}
    {-# LANGUAGE DeriveDataTypeable #-}

    module AsciiDoc.AST
      ( Document(..)
      , Meta(..)
      , Author(..)
      , Revision(..)
      , Block(..)
      , BlockType(..)
      , BlockTitle(..)
      , Inline(..)
      , InlineType(..)
      , ListType(..)
      , ListItem(..)
      , CheckboxState(..)
      , ColumnSpec(..)
      , CellStyle(..)
      , TableRow(..)
      , TableCell(..)
      , HorizAlign(..)
      , VertAlign(..)
      , AdmonitionType(..)
      , Target(..)
      , LinkType(..)
      , MathType(..)
      , Attr(..)
      , attrNull
      , Level(..)
      , Language(..)
      , Attribution(..)
      , AltText(..)
      , Width(..)
      , Height(..)
      , FootnoteId(..)
      , AttributeName(..)
      , Callout(..)
      , IndexTerm(..)
      , SourceLine(..)
      , CounterType(..)
      ) where

    import Control.Monad
    import Data.Text (Text)
    import Data.Data (Data)
    import Data.Typeable (Typeable)
    import GHC.Generics (Generic)
    import qualified Data.Map.Strict as Map
    import Data.Map.Strict (Map)
    import Data.Aeson (ToJSON(..), FromJSON(..), genericToEncoding, defaultOptions)

    -- | A complete AsciiDoc document
    data Document = Document
      { Document -> Meta
    docMeta :: Meta
      , Document -> [Block]
    docBlocks :: [Block]
      } deriving (Int -> Document -> ShowS
    [Document] -> ShowS
    Document -> String
    (Int -> Document -> ShowS)
    -> (Document -> String) -> ([Document] -> ShowS) -> Show Document
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Document -> ShowS
    showsPrec :: Int -> Document -> ShowS
    $cshow :: Document -> String
    show :: Document -> String
    $cshowList :: [Document] -> ShowS
    showList :: [Document] -> ShowS
    Show, Document -> Document -> Bool
    (Document -> Document -> Bool)
    -> (Document -> Document -> Bool) -> Eq Document
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Document -> Document -> Bool
    == :: Document -> Document -> Bool
    $c/= :: Document -> Document -> Bool
    /= :: Document -> Document -> Bool
    Eq, (forall x. Document -> Rep Document x)
    -> (forall x. Rep Document x -> Document) -> Generic Document
    forall x. Rep Document x -> Document
    forall x. Document -> Rep Document x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Document -> Rep Document x
    from :: forall x. Document -> Rep Document x
    $cto :: forall x. Rep Document x -> Document
    to :: forall x. Rep Document x -> Document
    Generic, Typeable Document
    Typeable Document =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Document -> c Document)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Document)
    -> (Document -> Constr)
    -> (Document -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Document))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Document))
    -> ((forall b. Data b => b -> b) -> Document -> Document)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Document -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Document -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Document -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Document -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Document -> m Document)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Document -> m Document)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Document -> m Document)
    -> Data Document
    Document -> Constr
    Document -> DataType
    (forall b. Data b => b -> b) -> Document -> Document
    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) -> Document -> u
    forall u. (forall d. Data d => d -> u) -> Document -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Document -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Document -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Document -> m Document
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Document -> m Document
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Document
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Document -> c Document
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Document)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Document)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Document -> c Document
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Document -> c Document
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Document
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Document
    $ctoConstr :: Document -> Constr
    toConstr :: Document -> Constr
    $cdataTypeOf :: Document -> DataType
    dataTypeOf :: Document -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Document)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Document)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Document)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Document)
    $cgmapT :: (forall b. Data b => b -> b) -> Document -> Document
    gmapT :: (forall b. Data b => b -> b) -> Document -> Document
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Document -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Document -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Document -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Document -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Document -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Document -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Document -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Document -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Document -> m Document
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Document -> m Document
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Document -> m Document
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Document -> m Document
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Document -> m Document
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Document -> m Document
    Data, Typeable)

    instance Semigroup Document where
      Document
    d1 <> :: Document -> Document -> Document
    <> Document
    d2 = Document { docMeta :: Meta
    docMeta = Document -> Meta
    docMeta Document
    d1 Meta -> Meta -> Meta
    forall a. Semigroup a => a -> a -> a
    <> Document -> Meta
    docMeta Document
    d2
                          , docBlocks :: [Block]
    docBlocks = Document -> [Block]
    docBlocks Document
    d1 [Block] -> [Block] -> [Block]
    forall a. Semigroup a => a -> a -> a
    <> Document -> [Block]
    docBlocks Document
    d2
                          }

    instance Monoid Document where
      mappend :: Document -> Document -> Document
    mappend = Document -> Document -> Document
    forall a. Semigroup a => a -> a -> a
    (<>)
      mempty :: Document
    mempty = Meta -> [Block] -> Document
    Document Meta
    forall a. Monoid a => a
    mempty [Block]
    forall a. Monoid a => a
    mempty

    instance ToJSON Document where
        toEncoding :: Document -> Encoding
    toEncoding = Options -> Document -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON Document

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

    instance ToJSON Author where
        toEncoding :: Author -> Encoding
    toEncoding = Options -> Author -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON Author

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

    instance ToJSON Revision where
        toEncoding :: Revision -> Encoding
    toEncoding = Options -> Revision -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON Revision

    -- | Document metadata
    data Meta = Meta
      { Meta -> [Inline]
    docTitle :: [Inline]
      , Meta -> Maybe Attr
    docTitleAttributes :: Maybe Attr
      , Meta -> [Author]
    docAuthors :: [Author]
      , Meta -> Maybe Revision
    docRevision :: Maybe Revision
      , Meta -> Map Text Text
    docAttributes :: Map Text Text
      } deriving (Meta -> Meta -> Bool
    (Meta -> Meta -> Bool) -> (Meta -> Meta -> Bool) -> Eq Meta
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Meta -> Meta -> Bool
    == :: Meta -> Meta -> Bool
    $c/= :: Meta -> Meta -> Bool
    /= :: Meta -> Meta -> Bool
    Eq, (forall x. Meta -> Rep Meta x)
    -> (forall x. Rep Meta x -> Meta) -> Generic Meta
    forall x. Rep Meta x -> Meta
    forall x. Meta -> Rep Meta x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Meta -> Rep Meta x
    from :: forall x. Meta -> Rep Meta x
    $cto :: forall x. Rep Meta x -> Meta
    to :: forall x. Rep Meta x -> Meta
    Generic, Typeable Meta
    Typeable Meta =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Meta -> c Meta)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Meta)
    -> (Meta -> Constr)
    -> (Meta -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Meta))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Meta))
    -> ((forall b. Data b => b -> b) -> Meta -> Meta)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Meta -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Meta -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Meta -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Meta -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Meta -> m Meta)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Meta -> m Meta)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Meta -> m Meta)
    -> Data Meta
    Meta -> Constr
    Meta -> DataType
    (forall b. Data b => b -> b) -> Meta -> Meta
    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) -> Meta -> u
    forall u. (forall d. Data d => d -> u) -> Meta -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Meta -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Meta -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Meta -> m Meta
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Meta -> m Meta
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Meta
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Meta -> c Meta
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Meta)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Meta)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Meta -> c Meta
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Meta -> c Meta
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Meta
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Meta
    $ctoConstr :: Meta -> Constr
    toConstr :: Meta -> Constr
    $cdataTypeOf :: Meta -> DataType
    dataTypeOf :: Meta -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Meta)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Meta)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Meta)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Meta)
    $cgmapT :: (forall b. Data b => b -> b) -> Meta -> Meta
    gmapT :: (forall b. Data b => b -> b) -> Meta -> Meta
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Meta -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Meta -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Meta -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Meta -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Meta -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Meta -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Meta -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Meta -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Meta -> m Meta
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Meta -> m Meta
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Meta -> m Meta
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Meta -> m Meta
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Meta -> m Meta
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Meta -> m Meta
    Data, Typeable)

    instance Show Meta where
      show :: Meta -> String
    show Meta
    x | Meta
    x Meta -> Meta -> Bool
    forall a. Eq a => a -> a -> Bool
    == Meta
    forall a. Monoid a => a
    mempty = String
    "Meta mempty"
      show (Meta [Inline]
    title Maybe Attr
    titleAttr [Author]
    authors Maybe Revision
    revision Map Text Text
    attributes) =
        String
    "Meta{ docTitle = " String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> [Inline] -> String
    forall a. Show a => a -> String
    show [Inline]
    title String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <>
        String
    ", docTitleAttributes = " String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> Maybe Attr -> String
    forall a. Show a => a -> String
    show Maybe Attr
    titleAttr String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <>
        String
    ", docAuthors = " String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> [Author] -> String
    forall a. Show a => a -> String
    show [Author]
    authors String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <>
        String
    ", docRevision = " String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> Maybe Revision -> String
    forall a. Show a => a -> String
    show Maybe Revision
    revision String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <>
        String
    ", docAttributes = " String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> Map Text Text -> String
    forall a. Show a => a -> String
    show Map Text Text
    attributes
        String -> ShowS
    forall a. Semigroup a => a -> a -> a
    <> String
    "}"

    instance ToJSON Meta where
        toEncoding :: Meta -> Encoding
    toEncoding = Options -> Meta -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON Meta

    instance Semigroup Meta where  -- left-biased
      Meta
    m1 <> :: Meta -> Meta -> Meta
    <> Meta
    m2 = Meta { docTitle :: [Inline]
    docTitle = case Meta -> [Inline]
    docTitle Meta
    m1 of
                                     [] -> Meta -> [Inline]
    docTitle Meta
    m2
                                     [Inline]
    ils -> [Inline]
    ils
                      , docTitleAttributes :: Maybe Attr
    docTitleAttributes =
                                   case Meta -> [Inline]
    docTitle Meta
    m1 of
                                     [] -> Meta -> Maybe Attr
    docTitleAttributes Meta
    m2
                                     [Inline]
    _ -> Meta -> Maybe Attr
    docTitleAttributes Meta
    m2
                      , docAuthors :: [Author]
    docAuthors = Meta -> [Author]
    docAuthors Meta
    m1 [Author] -> [Author] -> [Author]
    forall a. Semigroup a => a -> a -> a
    <> Meta -> [Author]
    docAuthors Meta
    m2
                      , docRevision :: Maybe Revision
    docRevision = Meta -> Maybe Revision
    docRevision Meta
    m1 Maybe Revision -> Maybe Revision -> Maybe Revision
    forall a. Maybe a -> Maybe a -> Maybe a
    forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
    `mplus` Meta -> Maybe Revision
    docRevision Meta
    m2
                      , docAttributes :: Map Text Text
    docAttributes = Meta -> Map Text Text
    docAttributes Meta
    m1 Map Text Text -> Map Text Text -> Map Text Text
    forall a. Semigroup a => a -> a -> a
    <> Meta -> Map Text Text
    docAttributes Meta
    m2
                      }

    instance Monoid Meta where
      mappend :: Meta -> Meta -> Meta
    mappend = Meta -> Meta -> Meta
    forall a. Semigroup a => a -> a -> a
    (<>)
      mempty :: Meta
    mempty = [Inline]
    -> Maybe Attr
    -> [Author]
    -> Maybe Revision
    -> Map Text Text
    -> Meta
    Meta [] Maybe Attr
    forall a. Maybe a
    Nothing [] Maybe Revision
    forall a. Maybe a
    Nothing Map Text Text
    forall a. Monoid a => a
    mempty

    -- | Attributes attached to an element.
    -- The first parameter stores positional attributes in order.
    -- The second parameter stores named attributes (including special keys
    -- like id/role/options) in a map.
    data Attr = Attr [Text] (Map Text Text)
      deriving (Attr -> Attr -> Bool
    (Attr -> Attr -> Bool) -> (Attr -> Attr -> Bool) -> Eq Attr
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Attr -> Attr -> Bool
    == :: Attr -> Attr -> Bool
    $c/= :: Attr -> Attr -> Bool
    /= :: Attr -> Attr -> Bool
    Eq, (forall x. Attr -> Rep Attr x)
    -> (forall x. Rep Attr x -> Attr) -> Generic Attr
    forall x. Rep Attr x -> Attr
    forall x. Attr -> Rep Attr x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Attr -> Rep Attr x
    from :: forall x. Attr -> Rep Attr x
    $cto :: forall x. Rep Attr x -> Attr
    to :: forall x. Rep Attr x -> Attr
    Generic, Typeable Attr
    Typeable Attr =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Attr -> c Attr)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Attr)
    -> (Attr -> Constr)
    -> (Attr -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Attr))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attr))
    -> ((forall b. Data b => b -> b) -> Attr -> Attr)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Attr -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Attr -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Attr -> m Attr)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Attr -> m Attr)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Attr -> m Attr)
    -> Data Attr
    Attr -> Constr
    Attr -> DataType
    (forall b. Data b => b -> b) -> Attr -> Attr
    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) -> Attr -> u
    forall u. (forall d. Data d => d -> u) -> Attr -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Attr
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Attr -> c Attr
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Attr)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attr)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Attr -> c Attr
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Attr -> c Attr
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Attr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Attr
    $ctoConstr :: Attr -> Constr
    toConstr :: Attr -> Constr
    $cdataTypeOf :: Attr -> DataType
    dataTypeOf :: Attr -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Attr)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Attr)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attr)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attr)
    $cgmapT :: (forall b. Data b => b -> b) -> Attr -> Attr
    gmapT :: (forall b. Data b => b -> b) -> Attr -> Attr
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Attr -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Attr -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Attr -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Attr -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr
    Data, Typeable)

    instance Show Attr where
      show :: Attr -> String
    show (Attr [Text]
    pos Map Text Text
    m)
        | [Text] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [Text]
    pos Bool -> Bool -> Bool
    && Map Text Text -> Bool
    forall k a. Map k a -> Bool
    Map.null Map Text Text
    m = String
    "mempty"
        | Bool
    otherwise = String
    "Attr " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ ([Text], Map Text Text) -> String
    forall a. Show a => a -> String
    show ([Text]
    pos, Map Text Text
    m)

    instance Semigroup Attr where
      Attr [Text]
    p1 Map Text Text
    m1 <> :: Attr -> Attr -> Attr
    <> Attr [Text]
    p2 Map Text Text
    m2 =
        let m :: Map Text Text
    m = Map Text Text
    m2 Map Text Text -> Map Text Text -> Map Text Text
    forall a. Semigroup a => a -> a -> a
    <> Map Text Text
    m1 -- left-biased, favor m2
            m' :: Map Text Text
    m' = (case (Text -> Map Text Text -> Maybe Text
    forall k a. Ord k => k -> Map k a -> Maybe a
    Map.lookup Text
    "role" Map Text Text
    m1, Text -> Map Text Text -> Maybe Text
    forall k a. Ord k => k -> Map k a -> Maybe a
    Map.lookup Text
    "role" Map Text Text
    m2) of
                    (Just Text
    x1, Just Text
    x2) -> Text -> Text -> Map Text Text -> Map Text Text
    forall k a. Ord k => k -> a -> Map k a -> Map k a
    Map.insert Text
    "role" (Text
    x1 Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    " " Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    x2)
                    (Maybe Text, Maybe Text)
    _ -> Map Text Text -> Map Text Text
    forall a. a -> a
    id) (Map Text Text -> Map Text Text)
    -> (Map Text Text -> Map Text Text)
    -> Map Text Text
    -> Map Text Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .
                 (case (Text -> Map Text Text -> Maybe Text
    forall k a. Ord k => k -> Map k a -> Maybe a
    Map.lookup Text
    "options" Map Text Text
    m1, Text -> Map Text Text -> Maybe Text
    forall k a. Ord k => k -> Map k a -> Maybe a
    Map.lookup Text
    "options" Map Text Text
    m2) of
                    (Just Text
    x1, Just Text
    x2) -> Text -> Text -> Map Text Text -> Map Text Text
    forall k a. Ord k => k -> a -> Map k a -> Map k a
    Map.insert Text
    "options" (Text
    x1 Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    "," Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    x2)
                    (Maybe Text, Maybe Text)
    _ -> Map Text Text -> Map Text Text
    forall a. a -> a
    id) (Map Text Text -> Map Text Text) -> Map Text Text -> Map Text Text
    forall a b. (a -> b) -> a -> b
    $ Map Text Text
    m
        in  [Text] -> Map Text Text -> Attr
    Attr ([Text]
    p1 [Text] -> [Text] -> [Text]
    forall a. Semigroup a => a -> a -> a
    <> [Text]
    p2) Map Text Text
    m'

    instance Monoid Attr where
      mempty :: Attr
    mempty = [Text] -> Map Text Text -> Attr
    Attr [] Map Text Text
    forall k a. Map k a
    Map.empty
      mappend :: Attr -> Attr -> Attr
    mappend = Attr -> Attr -> Attr
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance ToJSON Attr where
        toEncoding :: Attr -> Encoding
    toEncoding = Options -> Attr -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON Attr

    attrNull :: Attr -> Bool
    attrNull :: Attr -> Bool
    attrNull (Attr [Text]
    pos Map Text Text
    m) = [Text] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [Text]
    pos Bool -> Bool -> Bool
    && Map Text Text -> Bool
    forall k a. Map k a -> Bool
    Map.null Map Text Text
    m

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

    instance ToJSON Level where
        toEncoding :: Level -> Encoding
    toEncoding = Options -> Level -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON Level

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

    instance ToJSON Language where
        toEncoding :: Language -> Encoding
    toEncoding = Options -> Language -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON Language

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

    instance ToJSON Attribution where
        toEncoding :: Attribution -> Encoding
    toEncoding = Options -> Attribution -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON Attribution

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

    instance ToJSON AltText where
        toEncoding :: AltText -> Encoding
    toEncoding = Options -> AltText -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON AltText

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

    instance ToJSON Width where
        toEncoding :: Width -> Encoding
    toEncoding = Options -> Width -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON Width

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

    instance ToJSON Height where
        toEncoding :: Height -> Encoding
    toEncoding = Options -> Height -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON Height

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

    instance ToJSON FootnoteId where
        toEncoding :: FootnoteId -> Encoding
    toEncoding = Options -> FootnoteId -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON FootnoteId

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

    instance ToJSON AttributeName where
        toEncoding :: AttributeName -> Encoding
    toEncoding = Options -> AttributeName -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON AttributeName

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

    instance ToJSON Callout where
        toEncoding :: Callout -> Encoding
    toEncoding = Options -> Callout -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON Callout

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

    instance ToJSON SourceLine where
        toEncoding :: SourceLine -> Encoding
    toEncoding = Options -> SourceLine -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON SourceLine

    -- | Block-level element with attributes
    data Block = Block Attr (Maybe BlockTitle) BlockType
      deriving (Int -> Block -> ShowS
    [Block] -> ShowS
    Block -> String
    (Int -> Block -> ShowS)
    -> (Block -> String) -> ([Block] -> ShowS) -> Show Block
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Block -> ShowS
    showsPrec :: Int -> Block -> ShowS
    $cshow :: Block -> String
    show :: Block -> String
    $cshowList :: [Block] -> ShowS
    showList :: [Block] -> ShowS
    Show, Block -> Block -> Bool
    (Block -> Block -> Bool) -> (Block -> Block -> Bool) -> Eq Block
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Block -> Block -> Bool
    == :: Block -> Block -> Bool
    $c/= :: Block -> Block -> Bool
    /= :: Block -> Block -> Bool
    Eq, (forall x. Block -> Rep Block x)
    -> (forall x. Rep Block x -> Block) -> Generic Block
    forall x. Rep Block x -> Block
    forall x. Block -> Rep Block x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Block -> Rep Block x
    from :: forall x. Block -> Rep Block x
    $cto :: forall x. Rep Block x -> Block
    to :: forall x. Rep Block x -> Block
    Generic, Typeable Block
    Typeable Block =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Block -> c Block)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Block)
    -> (Block -> Constr)
    -> (Block -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Block))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Block))
    -> ((forall b. Data b => b -> b) -> Block -> Block)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Block -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Block -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Block -> m Block)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Block -> m Block)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Block -> m Block)
    -> Data Block
    Block -> Constr
    Block -> DataType
    (forall b. Data b => b -> b) -> Block -> Block
    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) -> Block -> u
    forall u. (forall d. Data d => d -> u) -> Block -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Block -> m Block
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Block -> m Block
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Block
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Block -> c Block
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Block)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Block)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Block -> c Block
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Block -> c Block
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Block
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Block
    $ctoConstr :: Block -> Constr
    toConstr :: Block -> Constr
    $cdataTypeOf :: Block -> DataType
    dataTypeOf :: Block -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Block)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Block)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Block)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Block)
    $cgmapT :: (forall b. Data b => b -> b) -> Block -> Block
    gmapT :: (forall b. Data b => b -> b) -> Block -> Block
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Block -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Block -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Block -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Block -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Block -> m Block
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Block -> m Block
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Block -> m Block
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Block -> m Block
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Block -> m Block
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Block -> m Block
    Data, Typeable)

    instance ToJSON Block where
        toEncoding :: Block -> Encoding
    toEncoding = Options -> Block -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON Block

    -- | Block-level element types
    data BlockType
      = Section Level [Inline] [Block]
      | DiscreteHeading Level [Inline]
      | Paragraph [Inline]
      | Verse (Maybe Attribution) [Block]
      | LiteralBlock Text
      | Listing (Maybe Language) [SourceLine]
      | IncludeListing (Maybe Language) FilePath (Maybe [SourceLine])
      | ExampleBlock [Block]
      | QuoteBlock (Maybe Attribution) [Block]
      | Sidebar [Block]
      | OpenBlock [Block]
      | PassthroughBlock Text
      | MathBlock (Maybe MathType) Text
      | List ListType [ListItem]
      | DefinitionList [([Inline], [Block])]
      | Table [ColumnSpec] (Maybe [TableRow]) [TableRow] (Maybe [TableRow])
      | BlockImage Target (Maybe AltText) (Maybe Width) (Maybe Height)
      | BlockAudio Target
      | BlockVideo Target
      | TOC
      | Admonition AdmonitionType [Block]
      | PageBreak
      | ThematicBreak
      | Include FilePath (Maybe [Block])
      deriving (Int -> BlockType -> ShowS
    [BlockType] -> ShowS
    BlockType -> String
    (Int -> BlockType -> ShowS)
    -> (BlockType -> String)
    -> ([BlockType] -> ShowS)
    -> Show BlockType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BlockType -> ShowS
    showsPrec :: Int -> BlockType -> ShowS
    $cshow :: BlockType -> String
    show :: BlockType -> String
    $cshowList :: [BlockType] -> ShowS
    showList :: [BlockType] -> ShowS
    Show, BlockType -> BlockType -> Bool
    (BlockType -> BlockType -> Bool)
    -> (BlockType -> BlockType -> Bool) -> Eq BlockType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BlockType -> BlockType -> Bool
    == :: BlockType -> BlockType -> Bool
    $c/= :: BlockType -> BlockType -> Bool
    /= :: BlockType -> BlockType -> Bool
    Eq, (forall x. BlockType -> Rep BlockType x)
    -> (forall x. Rep BlockType x -> BlockType) -> Generic BlockType
    forall x. Rep BlockType x -> BlockType
    forall x. BlockType -> Rep BlockType x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. BlockType -> Rep BlockType x
    from :: forall x. BlockType -> Rep BlockType x
    $cto :: forall x. Rep BlockType x -> BlockType
    to :: forall x. Rep BlockType x -> BlockType
    Generic, Typeable BlockType
    Typeable BlockType =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> BlockType -> c BlockType)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c BlockType)
    -> (BlockType -> Constr)
    -> (BlockType -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c BlockType))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlockType))
    -> ((forall b. Data b => b -> b) -> BlockType -> BlockType)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> BlockType -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> BlockType -> r)
    -> (forall u. (forall d. Data d => d -> u) -> BlockType -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> BlockType -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> BlockType -> m BlockType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> BlockType -> m BlockType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> BlockType -> m BlockType)
    -> Data BlockType
    BlockType -> Constr
    BlockType -> DataType
    (forall b. Data b => b -> b) -> BlockType -> BlockType
    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) -> BlockType -> u
    forall u. (forall d. Data d => d -> u) -> BlockType -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BlockType -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BlockType -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BlockType -> m BlockType
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BlockType -> m BlockType
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BlockType
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BlockType -> c BlockType
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BlockType)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlockType)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BlockType -> c BlockType
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BlockType -> c BlockType
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BlockType
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BlockType
    $ctoConstr :: BlockType -> Constr
    toConstr :: BlockType -> Constr
    $cdataTypeOf :: BlockType -> DataType
    dataTypeOf :: BlockType -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BlockType)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BlockType)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlockType)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlockType)
    $cgmapT :: (forall b. Data b => b -> b) -> BlockType -> BlockType
    gmapT :: (forall b. Data b => b -> b) -> BlockType -> BlockType
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BlockType -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BlockType -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BlockType -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BlockType -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> BlockType -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> BlockType -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BlockType -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BlockType -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BlockType -> m BlockType
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BlockType -> m BlockType
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BlockType -> m BlockType
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BlockType -> m BlockType
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BlockType -> m BlockType
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BlockType -> m BlockType
    Data, Typeable)

    instance ToJSON BlockType where
        toEncoding :: BlockType -> Encoding
    toEncoding = Options -> BlockType -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON BlockType

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

    instance ToJSON BlockTitle where
        toEncoding :: BlockTitle -> Encoding
    toEncoding = Options -> BlockTitle -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON BlockTitle

    -- | Types of admonitions
    data AdmonitionType
      = Note
      | Tip
      | Important
      | Caution
      | Warning
      deriving (Int -> AdmonitionType -> ShowS
    [AdmonitionType] -> ShowS
    AdmonitionType -> String
    (Int -> AdmonitionType -> ShowS)
    -> (AdmonitionType -> String)
    -> ([AdmonitionType] -> ShowS)
    -> Show AdmonitionType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AdmonitionType -> ShowS
    showsPrec :: Int -> AdmonitionType -> ShowS
    $cshow :: AdmonitionType -> String
    show :: AdmonitionType -> String
    $cshowList :: [AdmonitionType] -> ShowS
    showList :: [AdmonitionType] -> ShowS
    Show, AdmonitionType -> AdmonitionType -> Bool
    (AdmonitionType -> AdmonitionType -> Bool)
    -> (AdmonitionType -> AdmonitionType -> Bool) -> Eq AdmonitionType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AdmonitionType -> AdmonitionType -> Bool
    == :: AdmonitionType -> AdmonitionType -> Bool
    $c/= :: AdmonitionType -> AdmonitionType -> Bool
    /= :: AdmonitionType -> AdmonitionType -> Bool
    Eq, (forall x. AdmonitionType -> Rep AdmonitionType x)
    -> (forall x. Rep AdmonitionType x -> AdmonitionType)
    -> Generic AdmonitionType
    forall x. Rep AdmonitionType x -> AdmonitionType
    forall x. AdmonitionType -> Rep AdmonitionType x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. AdmonitionType -> Rep AdmonitionType x
    from :: forall x. AdmonitionType -> Rep AdmonitionType x
    $cto :: forall x. Rep AdmonitionType x -> AdmonitionType
    to :: forall x. Rep AdmonitionType x -> AdmonitionType
    Generic, Typeable AdmonitionType
    Typeable AdmonitionType =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> AdmonitionType -> c AdmonitionType)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AdmonitionType)
    -> (AdmonitionType -> Constr)
    -> (AdmonitionType -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AdmonitionType))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c AdmonitionType))
    -> ((forall b. Data b => b -> b)
        -> AdmonitionType -> AdmonitionType)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AdmonitionType -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AdmonitionType -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> AdmonitionType -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AdmonitionType -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> AdmonitionType -> m AdmonitionType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> AdmonitionType -> m AdmonitionType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> AdmonitionType -> m AdmonitionType)
    -> Data AdmonitionType
    AdmonitionType -> Constr
    AdmonitionType -> DataType
    (forall b. Data b => b -> b) -> AdmonitionType -> AdmonitionType
    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) -> AdmonitionType -> u
    forall u. (forall d. Data d => d -> u) -> AdmonitionType -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AdmonitionType -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AdmonitionType -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AdmonitionType -> m AdmonitionType
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AdmonitionType -> m AdmonitionType
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AdmonitionType
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AdmonitionType -> c AdmonitionType
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AdmonitionType)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AdmonitionType)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AdmonitionType -> c AdmonitionType
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AdmonitionType -> c AdmonitionType
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AdmonitionType
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AdmonitionType
    $ctoConstr :: AdmonitionType -> Constr
    toConstr :: AdmonitionType -> Constr
    $cdataTypeOf :: AdmonitionType -> DataType
    dataTypeOf :: AdmonitionType -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AdmonitionType)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AdmonitionType)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AdmonitionType)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AdmonitionType)
    $cgmapT :: (forall b. Data b => b -> b) -> AdmonitionType -> AdmonitionType
    gmapT :: (forall b. Data b => b -> b) -> AdmonitionType -> AdmonitionType
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AdmonitionType -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AdmonitionType -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AdmonitionType -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AdmonitionType -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AdmonitionType -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AdmonitionType -> [u]
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> AdmonitionType -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> AdmonitionType -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AdmonitionType -> m AdmonitionType
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AdmonitionType -> m AdmonitionType
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AdmonitionType -> m AdmonitionType
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AdmonitionType -> m AdmonitionType
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AdmonitionType -> m AdmonitionType
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AdmonitionType -> m AdmonitionType
    Data, Typeable)

    instance ToJSON AdmonitionType where
        toEncoding :: AdmonitionType -> Encoding
    toEncoding = Options -> AdmonitionType -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON AdmonitionType

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

    instance ToJSON IndexTerm where
        toEncoding :: IndexTerm -> Encoding
    toEncoding = Options -> IndexTerm -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON IndexTerm

    -- | List types
    data ListType
      = BulletList Level
      | OrderedList Level (Maybe Int)
      | CheckList
      | CalloutList
      deriving (Int -> ListType -> ShowS
    [ListType] -> ShowS
    ListType -> String
    (Int -> ListType -> ShowS)
    -> (ListType -> String) -> ([ListType] -> ShowS) -> Show ListType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ListType -> ShowS
    showsPrec :: Int -> ListType -> ShowS
    $cshow :: ListType -> String
    show :: ListType -> String
    $cshowList :: [ListType] -> ShowS
    showList :: [ListType] -> ShowS
    Show, ListType -> ListType -> Bool
    (ListType -> ListType -> Bool)
    -> (ListType -> ListType -> Bool) -> Eq ListType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ListType -> ListType -> Bool
    == :: ListType -> ListType -> Bool
    $c/= :: ListType -> ListType -> Bool
    /= :: ListType -> ListType -> Bool
    Eq, (forall x. ListType -> Rep ListType x)
    -> (forall x. Rep ListType x -> ListType) -> Generic ListType
    forall x. Rep ListType x -> ListType
    forall x. ListType -> Rep ListType x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. ListType -> Rep ListType x
    from :: forall x. ListType -> Rep ListType x
    $cto :: forall x. Rep ListType x -> ListType
    to :: forall x. Rep ListType x -> ListType
    Generic, Typeable ListType
    Typeable ListType =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ListType -> c ListType)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ListType)
    -> (ListType -> Constr)
    -> (ListType -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ListType))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ListType))
    -> ((forall b. Data b => b -> b) -> ListType -> ListType)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ListType -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ListType -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ListType -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> ListType -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ListType -> m ListType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ListType -> m ListType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ListType -> m ListType)
    -> Data ListType
    ListType -> Constr
    ListType -> DataType
    (forall b. Data b => b -> b) -> ListType -> ListType
    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) -> ListType -> u
    forall u. (forall d. Data d => d -> u) -> ListType -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ListType -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ListType -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ListType -> m ListType
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ListType -> m ListType
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ListType
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ListType -> c ListType
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ListType)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ListType)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ListType -> c ListType
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ListType -> c ListType
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ListType
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ListType
    $ctoConstr :: ListType -> Constr
    toConstr :: ListType -> Constr
    $cdataTypeOf :: ListType -> DataType
    dataTypeOf :: ListType -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ListType)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ListType)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ListType)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ListType)
    $cgmapT :: (forall b. Data b => b -> b) -> ListType -> ListType
    gmapT :: (forall b. Data b => b -> b) -> ListType -> ListType
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ListType -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ListType -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ListType -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ListType -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ListType -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ListType -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ListType -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ListType -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ListType -> m ListType
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ListType -> m ListType
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ListType -> m ListType
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ListType -> m ListType
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ListType -> m ListType
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ListType -> m ListType
    Data, Typeable)

    instance ToJSON ListType where
        toEncoding :: ListType -> Encoding
    toEncoding = Options -> ListType -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON ListType

    -- | A list item
    data ListItem = ListItem (Maybe CheckboxState) [Block]
      deriving (Int -> ListItem -> ShowS
    [ListItem] -> ShowS
    ListItem -> String
    (Int -> ListItem -> ShowS)
    -> (ListItem -> String) -> ([ListItem] -> ShowS) -> Show ListItem
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ListItem -> ShowS
    showsPrec :: Int -> ListItem -> ShowS
    $cshow :: ListItem -> String
    show :: ListItem -> String
    $cshowList :: [ListItem] -> ShowS
    showList :: [ListItem] -> ShowS
    Show, ListItem -> ListItem -> Bool
    (ListItem -> ListItem -> Bool)
    -> (ListItem -> ListItem -> Bool) -> Eq ListItem
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ListItem -> ListItem -> Bool
    == :: ListItem -> ListItem -> Bool
    $c/= :: ListItem -> ListItem -> Bool
    /= :: ListItem -> ListItem -> Bool
    Eq, (forall x. ListItem -> Rep ListItem x)
    -> (forall x. Rep ListItem x -> ListItem) -> Generic ListItem
    forall x. Rep ListItem x -> ListItem
    forall x. ListItem -> Rep ListItem x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. ListItem -> Rep ListItem x
    from :: forall x. ListItem -> Rep ListItem x
    $cto :: forall x. Rep ListItem x -> ListItem
    to :: forall x. Rep ListItem x -> ListItem
    Generic, Typeable ListItem
    Typeable ListItem =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ListItem -> c ListItem)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ListItem)
    -> (ListItem -> Constr)
    -> (ListItem -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ListItem))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ListItem))
    -> ((forall b. Data b => b -> b) -> ListItem -> ListItem)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ListItem -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ListItem -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ListItem -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> ListItem -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ListItem -> m ListItem)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ListItem -> m ListItem)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ListItem -> m ListItem)
    -> Data ListItem
    ListItem -> Constr
    ListItem -> DataType
    (forall b. Data b => b -> b) -> ListItem -> ListItem
    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) -> ListItem -> u
    forall u. (forall d. Data d => d -> u) -> ListItem -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ListItem -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ListItem -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ListItem -> m ListItem
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ListItem -> m ListItem
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ListItem
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ListItem -> c ListItem
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ListItem)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ListItem)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ListItem -> c ListItem
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ListItem -> c ListItem
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ListItem
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ListItem
    $ctoConstr :: ListItem -> Constr
    toConstr :: ListItem -> Constr
    $cdataTypeOf :: ListItem -> DataType
    dataTypeOf :: ListItem -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ListItem)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ListItem)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ListItem)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ListItem)
    $cgmapT :: (forall b. Data b => b -> b) -> ListItem -> ListItem
    gmapT :: (forall b. Data b => b -> b) -> ListItem -> ListItem
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ListItem -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ListItem -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ListItem -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ListItem -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ListItem -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ListItem -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ListItem -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ListItem -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ListItem -> m ListItem
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ListItem -> m ListItem
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ListItem -> m ListItem
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ListItem -> m ListItem
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ListItem -> m ListItem
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ListItem -> m ListItem
    Data, Typeable)

    instance ToJSON ListItem where
        toEncoding :: ListItem -> Encoding
    toEncoding = Options -> ListItem -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON ListItem

    -- | Checkbox state for checklists
    data CheckboxState
      = Checked
      | Unchecked
      deriving (Int -> CheckboxState -> ShowS
    [CheckboxState] -> ShowS
    CheckboxState -> String
    (Int -> CheckboxState -> ShowS)
    -> (CheckboxState -> String)
    -> ([CheckboxState] -> ShowS)
    -> Show CheckboxState
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CheckboxState -> ShowS
    showsPrec :: Int -> CheckboxState -> ShowS
    $cshow :: CheckboxState -> String
    show :: CheckboxState -> String
    $cshowList :: [CheckboxState] -> ShowS
    showList :: [CheckboxState] -> ShowS
    Show, CheckboxState -> CheckboxState -> Bool
    (CheckboxState -> CheckboxState -> Bool)
    -> (CheckboxState -> CheckboxState -> Bool) -> Eq CheckboxState
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CheckboxState -> CheckboxState -> Bool
    == :: CheckboxState -> CheckboxState -> Bool
    $c/= :: CheckboxState -> CheckboxState -> Bool
    /= :: CheckboxState -> CheckboxState -> Bool
    Eq, (forall x. CheckboxState -> Rep CheckboxState x)
    -> (forall x. Rep CheckboxState x -> CheckboxState)
    -> Generic CheckboxState
    forall x. Rep CheckboxState x -> CheckboxState
    forall x. CheckboxState -> Rep CheckboxState x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. CheckboxState -> Rep CheckboxState x
    from :: forall x. CheckboxState -> Rep CheckboxState x
    $cto :: forall x. Rep CheckboxState x -> CheckboxState
    to :: forall x. Rep CheckboxState x -> CheckboxState
    Generic, Typeable CheckboxState
    Typeable CheckboxState =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> CheckboxState -> c CheckboxState)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c CheckboxState)
    -> (CheckboxState -> Constr)
    -> (CheckboxState -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c CheckboxState))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c CheckboxState))
    -> ((forall b. Data b => b -> b) -> CheckboxState -> CheckboxState)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> CheckboxState -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> CheckboxState -> r)
    -> (forall u. (forall d. Data d => d -> u) -> CheckboxState -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> CheckboxState -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> CheckboxState -> m CheckboxState)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CheckboxState -> m CheckboxState)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CheckboxState -> m CheckboxState)
    -> Data CheckboxState
    CheckboxState -> Constr
    CheckboxState -> DataType
    (forall b. Data b => b -> b) -> CheckboxState -> CheckboxState
    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) -> CheckboxState -> u
    forall u. (forall d. Data d => d -> u) -> CheckboxState -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CheckboxState -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CheckboxState -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CheckboxState -> m CheckboxState
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CheckboxState -> m CheckboxState
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CheckboxState
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CheckboxState -> c CheckboxState
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CheckboxState)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CheckboxState)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CheckboxState -> c CheckboxState
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CheckboxState -> c CheckboxState
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CheckboxState
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CheckboxState
    $ctoConstr :: CheckboxState -> Constr
    toConstr :: CheckboxState -> Constr
    $cdataTypeOf :: CheckboxState -> DataType
    dataTypeOf :: CheckboxState -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CheckboxState)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CheckboxState)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CheckboxState)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CheckboxState)
    $cgmapT :: (forall b. Data b => b -> b) -> CheckboxState -> CheckboxState
    gmapT :: (forall b. Data b => b -> b) -> CheckboxState -> CheckboxState
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CheckboxState -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CheckboxState -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CheckboxState -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CheckboxState -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> CheckboxState -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> CheckboxState -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CheckboxState -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CheckboxState -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CheckboxState -> m CheckboxState
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CheckboxState -> m CheckboxState
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CheckboxState -> m CheckboxState
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CheckboxState -> m CheckboxState
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CheckboxState -> m CheckboxState
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CheckboxState -> m CheckboxState
    Data, Typeable)

    instance ToJSON CheckboxState where
        toEncoding :: CheckboxState -> Encoding
    toEncoding = Options -> CheckboxState -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON CheckboxState

    -- | Column specification
    data ColumnSpec = ColumnSpec
      { ColumnSpec -> Maybe HorizAlign
    colHorizAlign :: Maybe HorizAlign
      , ColumnSpec -> Maybe VertAlign
    colVertAlign :: Maybe VertAlign
      , ColumnSpec -> Maybe Int
    colWidth :: Maybe Int
      , ColumnSpec -> Maybe CellStyle
    colStyle :: Maybe CellStyle
      } deriving (Int -> ColumnSpec -> ShowS
    [ColumnSpec] -> ShowS
    ColumnSpec -> String
    (Int -> ColumnSpec -> ShowS)
    -> (ColumnSpec -> String)
    -> ([ColumnSpec] -> ShowS)
    -> Show ColumnSpec
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ColumnSpec -> ShowS
    showsPrec :: Int -> ColumnSpec -> ShowS
    $cshow :: ColumnSpec -> String
    show :: ColumnSpec -> String
    $cshowList :: [ColumnSpec] -> ShowS
    showList :: [ColumnSpec] -> ShowS
    Show, ColumnSpec -> ColumnSpec -> Bool
    (ColumnSpec -> ColumnSpec -> Bool)
    -> (ColumnSpec -> ColumnSpec -> Bool) -> Eq ColumnSpec
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ColumnSpec -> ColumnSpec -> Bool
    == :: ColumnSpec -> ColumnSpec -> Bool
    $c/= :: ColumnSpec -> ColumnSpec -> Bool
    /= :: ColumnSpec -> ColumnSpec -> Bool
    Eq, (forall x. ColumnSpec -> Rep ColumnSpec x)
    -> (forall x. Rep ColumnSpec x -> ColumnSpec) -> Generic ColumnSpec
    forall x. Rep ColumnSpec x -> ColumnSpec
    forall x. ColumnSpec -> Rep ColumnSpec x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. ColumnSpec -> Rep ColumnSpec x
    from :: forall x. ColumnSpec -> Rep ColumnSpec x
    $cto :: forall x. Rep ColumnSpec x -> ColumnSpec
    to :: forall x. Rep ColumnSpec x -> ColumnSpec
    Generic, Typeable ColumnSpec
    Typeable ColumnSpec =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ColumnSpec -> c ColumnSpec)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ColumnSpec)
    -> (ColumnSpec -> Constr)
    -> (ColumnSpec -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ColumnSpec))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c ColumnSpec))
    -> ((forall b. Data b => b -> b) -> ColumnSpec -> ColumnSpec)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ColumnSpec -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ColumnSpec -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ColumnSpec -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ColumnSpec -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ColumnSpec -> m ColumnSpec)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ColumnSpec -> m ColumnSpec)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ColumnSpec -> m ColumnSpec)
    -> Data ColumnSpec
    ColumnSpec -> Constr
    ColumnSpec -> DataType
    (forall b. Data b => b -> b) -> ColumnSpec -> ColumnSpec
    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) -> ColumnSpec -> u
    forall u. (forall d. Data d => d -> u) -> ColumnSpec -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ColumnSpec -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ColumnSpec -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ColumnSpec -> m ColumnSpec
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColumnSpec -> m ColumnSpec
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ColumnSpec
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ColumnSpec -> c ColumnSpec
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ColumnSpec)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColumnSpec)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ColumnSpec -> c ColumnSpec
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ColumnSpec -> c ColumnSpec
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ColumnSpec
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ColumnSpec
    $ctoConstr :: ColumnSpec -> Constr
    toConstr :: ColumnSpec -> Constr
    $cdataTypeOf :: ColumnSpec -> DataType
    dataTypeOf :: ColumnSpec -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ColumnSpec)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ColumnSpec)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColumnSpec)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColumnSpec)
    $cgmapT :: (forall b. Data b => b -> b) -> ColumnSpec -> ColumnSpec
    gmapT :: (forall b. Data b => b -> b) -> ColumnSpec -> ColumnSpec
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ColumnSpec -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ColumnSpec -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ColumnSpec -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ColumnSpec -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ColumnSpec -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ColumnSpec -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ColumnSpec -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ColumnSpec -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ColumnSpec -> m ColumnSpec
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ColumnSpec -> m ColumnSpec
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColumnSpec -> m ColumnSpec
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColumnSpec -> m ColumnSpec
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColumnSpec -> m ColumnSpec
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColumnSpec -> m ColumnSpec
    Data, Typeable)

    instance ToJSON ColumnSpec where
        toEncoding :: ColumnSpec -> Encoding
    toEncoding = Options -> ColumnSpec -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON ColumnSpec

    -- | Defines how cell contents are parsed
    data CellStyle =
        AsciiDocStyle
      | DefaultStyle
      | EmphasisStyle
      | LiteralStyle
      | HeaderStyle
      | MonospaceStyle
      | StrongStyle
      deriving (Int -> CellStyle -> ShowS
    [CellStyle] -> ShowS
    CellStyle -> String
    (Int -> CellStyle -> ShowS)
    -> (CellStyle -> String)
    -> ([CellStyle] -> ShowS)
    -> Show CellStyle
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CellStyle -> ShowS
    showsPrec :: Int -> CellStyle -> ShowS
    $cshow :: CellStyle -> String
    show :: CellStyle -> String
    $cshowList :: [CellStyle] -> ShowS
    showList :: [CellStyle] -> ShowS
    Show, CellStyle -> CellStyle -> Bool
    (CellStyle -> CellStyle -> Bool)
    -> (CellStyle -> CellStyle -> Bool) -> Eq CellStyle
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CellStyle -> CellStyle -> Bool
    == :: CellStyle -> CellStyle -> Bool
    $c/= :: CellStyle -> CellStyle -> Bool
    /= :: CellStyle -> CellStyle -> Bool
    Eq, (forall x. CellStyle -> Rep CellStyle x)
    -> (forall x. Rep CellStyle x -> CellStyle) -> Generic CellStyle
    forall x. Rep CellStyle x -> CellStyle
    forall x. CellStyle -> Rep CellStyle x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. CellStyle -> Rep CellStyle x
    from :: forall x. CellStyle -> Rep CellStyle x
    $cto :: forall x. Rep CellStyle x -> CellStyle
    to :: forall x. Rep CellStyle x -> CellStyle
    Generic, Typeable CellStyle
    Typeable CellStyle =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> CellStyle -> c CellStyle)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c CellStyle)
    -> (CellStyle -> Constr)
    -> (CellStyle -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c CellStyle))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CellStyle))
    -> ((forall b. Data b => b -> b) -> CellStyle -> CellStyle)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> CellStyle -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> CellStyle -> r)
    -> (forall u. (forall d. Data d => d -> u) -> CellStyle -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> CellStyle -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> CellStyle -> m CellStyle)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CellStyle -> m CellStyle)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CellStyle -> m CellStyle)
    -> Data CellStyle
    CellStyle -> Constr
    CellStyle -> DataType
    (forall b. Data b => b -> b) -> CellStyle -> CellStyle
    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) -> CellStyle -> u
    forall u. (forall d. Data d => d -> u) -> CellStyle -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CellStyle -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CellStyle -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CellStyle -> m CellStyle
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CellStyle -> m CellStyle
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CellStyle
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CellStyle -> c CellStyle
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CellStyle)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CellStyle)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CellStyle -> c CellStyle
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CellStyle -> c CellStyle
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CellStyle
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CellStyle
    $ctoConstr :: CellStyle -> Constr
    toConstr :: CellStyle -> Constr
    $cdataTypeOf :: CellStyle -> DataType
    dataTypeOf :: CellStyle -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CellStyle)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CellStyle)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CellStyle)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CellStyle)
    $cgmapT :: (forall b. Data b => b -> b) -> CellStyle -> CellStyle
    gmapT :: (forall b. Data b => b -> b) -> CellStyle -> CellStyle
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CellStyle -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CellStyle -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CellStyle -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CellStyle -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> CellStyle -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> CellStyle -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CellStyle -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CellStyle -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CellStyle -> m CellStyle
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CellStyle -> m CellStyle
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CellStyle -> m CellStyle
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CellStyle -> m CellStyle
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CellStyle -> m CellStyle
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CellStyle -> m CellStyle
    Data, Typeable)

    instance ToJSON CellStyle where
        toEncoding :: CellStyle -> Encoding
    toEncoding = Options -> CellStyle -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON CellStyle

    -- | Table row
    newtype TableRow = TableRow [TableCell]
      deriving (Int -> TableRow -> ShowS
    [TableRow] -> ShowS
    TableRow -> String
    (Int -> TableRow -> ShowS)
    -> (TableRow -> String) -> ([TableRow] -> ShowS) -> Show TableRow
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TableRow -> ShowS
    showsPrec :: Int -> TableRow -> ShowS
    $cshow :: TableRow -> String
    show :: TableRow -> String
    $cshowList :: [TableRow] -> ShowS
    showList :: [TableRow] -> ShowS
    Show, TableRow -> TableRow -> Bool
    (TableRow -> TableRow -> Bool)
    -> (TableRow -> TableRow -> Bool) -> Eq TableRow
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TableRow -> TableRow -> Bool
    == :: TableRow -> TableRow -> Bool
    $c/= :: TableRow -> TableRow -> Bool
    /= :: TableRow -> TableRow -> Bool
    Eq, (forall x. TableRow -> Rep TableRow x)
    -> (forall x. Rep TableRow x -> TableRow) -> Generic TableRow
    forall x. Rep TableRow x -> TableRow
    forall x. TableRow -> Rep TableRow x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. TableRow -> Rep TableRow x
    from :: forall x. TableRow -> Rep TableRow x
    $cto :: forall x. Rep TableRow x -> TableRow
    to :: forall x. Rep TableRow x -> TableRow
    Generic, Typeable TableRow
    Typeable TableRow =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> TableRow -> c TableRow)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c TableRow)
    -> (TableRow -> Constr)
    -> (TableRow -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c TableRow))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableRow))
    -> ((forall b. Data b => b -> b) -> TableRow -> TableRow)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> TableRow -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> TableRow -> r)
    -> (forall u. (forall d. Data d => d -> u) -> TableRow -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> TableRow -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> TableRow -> m TableRow)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TableRow -> m TableRow)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TableRow -> m TableRow)
    -> Data TableRow
    TableRow -> Constr
    TableRow -> DataType
    (forall b. Data b => b -> b) -> TableRow -> TableRow
    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) -> TableRow -> u
    forall u. (forall d. Data d => d -> u) -> TableRow -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableRow -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableRow -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TableRow -> m TableRow
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableRow -> m TableRow
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableRow
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TableRow -> c TableRow
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableRow)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableRow)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TableRow -> c TableRow
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TableRow -> c TableRow
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableRow
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableRow
    $ctoConstr :: TableRow -> Constr
    toConstr :: TableRow -> Constr
    $cdataTypeOf :: TableRow -> DataType
    dataTypeOf :: TableRow -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableRow)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableRow)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableRow)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableRow)
    $cgmapT :: (forall b. Data b => b -> b) -> TableRow -> TableRow
    gmapT :: (forall b. Data b => b -> b) -> TableRow -> TableRow
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableRow -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableRow -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableRow -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableRow -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> TableRow -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> TableRow -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TableRow -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TableRow -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TableRow -> m TableRow
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TableRow -> m TableRow
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableRow -> m TableRow
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableRow -> m TableRow
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableRow -> m TableRow
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableRow -> m TableRow
    Data, Typeable)

    instance ToJSON TableRow where
        toEncoding :: TableRow -> Encoding
    toEncoding = Options -> TableRow -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON TableRow

    -- | Table cell
    data TableCell = TableCell
      { TableCell -> [Block]
    cellContent :: [Block]
      , TableCell -> Maybe HorizAlign
    cellHorizAlign :: Maybe HorizAlign
      , TableCell -> Maybe VertAlign
    cellVertAlign :: Maybe VertAlign
      , TableCell -> Int
    cellColspan :: Int
      , TableCell -> Int
    cellRowspan :: Int
      } deriving (Int -> TableCell -> ShowS
    [TableCell] -> ShowS
    TableCell -> String
    (Int -> TableCell -> ShowS)
    -> (TableCell -> String)
    -> ([TableCell] -> ShowS)
    -> Show TableCell
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TableCell -> ShowS
    showsPrec :: Int -> TableCell -> ShowS
    $cshow :: TableCell -> String
    show :: TableCell -> String
    $cshowList :: [TableCell] -> ShowS
    showList :: [TableCell] -> ShowS
    Show, TableCell -> TableCell -> Bool
    (TableCell -> TableCell -> Bool)
    -> (TableCell -> TableCell -> Bool) -> Eq TableCell
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TableCell -> TableCell -> Bool
    == :: TableCell -> TableCell -> Bool
    $c/= :: TableCell -> TableCell -> Bool
    /= :: TableCell -> TableCell -> Bool
    Eq, (forall x. TableCell -> Rep TableCell x)
    -> (forall x. Rep TableCell x -> TableCell) -> Generic TableCell
    forall x. Rep TableCell x -> TableCell
    forall x. TableCell -> Rep TableCell x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. TableCell -> Rep TableCell x
    from :: forall x. TableCell -> Rep TableCell x
    $cto :: forall x. Rep TableCell x -> TableCell
    to :: forall x. Rep TableCell x -> TableCell
    Generic, Typeable TableCell
    Typeable TableCell =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> TableCell -> c TableCell)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c TableCell)
    -> (TableCell -> Constr)
    -> (TableCell -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c TableCell))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableCell))
    -> ((forall b. Data b => b -> b) -> TableCell -> TableCell)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> TableCell -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> TableCell -> r)
    -> (forall u. (forall d. Data d => d -> u) -> TableCell -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> TableCell -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> TableCell -> m TableCell)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TableCell -> m TableCell)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TableCell -> m TableCell)
    -> Data TableCell
    TableCell -> Constr
    TableCell -> DataType
    (forall b. Data b => b -> b) -> TableCell -> TableCell
    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) -> TableCell -> u
    forall u. (forall d. Data d => d -> u) -> TableCell -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableCell -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableCell -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TableCell -> m TableCell
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableCell -> m TableCell
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableCell
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TableCell -> c TableCell
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableCell)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableCell)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TableCell -> c TableCell
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TableCell -> c TableCell
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableCell
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableCell
    $ctoConstr :: TableCell -> Constr
    toConstr :: TableCell -> Constr
    $cdataTypeOf :: TableCell -> DataType
    dataTypeOf :: TableCell -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableCell)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableCell)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableCell)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableCell)
    $cgmapT :: (forall b. Data b => b -> b) -> TableCell -> TableCell
    gmapT :: (forall b. Data b => b -> b) -> TableCell -> TableCell
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableCell -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableCell -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableCell -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableCell -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> TableCell -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> TableCell -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TableCell -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TableCell -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TableCell -> m TableCell
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TableCell -> m TableCell
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableCell -> m TableCell
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableCell -> m TableCell
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableCell -> m TableCell
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableCell -> m TableCell
    Data, Typeable)

    instance ToJSON TableCell where
        toEncoding :: TableCell -> Encoding
    toEncoding = Options -> TableCell -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON TableCell

    -- | Cell alignment
    data HorizAlign
      = AlignLeft
      | AlignCenter
      | AlignRight
      deriving (Int -> HorizAlign -> ShowS
    [HorizAlign] -> ShowS
    HorizAlign -> String
    (Int -> HorizAlign -> ShowS)
    -> (HorizAlign -> String)
    -> ([HorizAlign] -> ShowS)
    -> Show HorizAlign
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HorizAlign -> ShowS
    showsPrec :: Int -> HorizAlign -> ShowS
    $cshow :: HorizAlign -> String
    show :: HorizAlign -> String
    $cshowList :: [HorizAlign] -> ShowS
    showList :: [HorizAlign] -> ShowS
    Show, HorizAlign -> HorizAlign -> Bool
    (HorizAlign -> HorizAlign -> Bool)
    -> (HorizAlign -> HorizAlign -> Bool) -> Eq HorizAlign
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HorizAlign -> HorizAlign -> Bool
    == :: HorizAlign -> HorizAlign -> Bool
    $c/= :: HorizAlign -> HorizAlign -> Bool
    /= :: HorizAlign -> HorizAlign -> Bool
    Eq, (forall x. HorizAlign -> Rep HorizAlign x)
    -> (forall x. Rep HorizAlign x -> HorizAlign) -> Generic HorizAlign
    forall x. Rep HorizAlign x -> HorizAlign
    forall x. HorizAlign -> Rep HorizAlign x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. HorizAlign -> Rep HorizAlign x
    from :: forall x. HorizAlign -> Rep HorizAlign x
    $cto :: forall x. Rep HorizAlign x -> HorizAlign
    to :: forall x. Rep HorizAlign x -> HorizAlign
    Generic, Typeable HorizAlign
    Typeable HorizAlign =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HorizAlign -> c HorizAlign)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HorizAlign)
    -> (HorizAlign -> Constr)
    -> (HorizAlign -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HorizAlign))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c HorizAlign))
    -> ((forall b. Data b => b -> b) -> HorizAlign -> HorizAlign)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HorizAlign -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HorizAlign -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HorizAlign -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> HorizAlign -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HorizAlign -> m HorizAlign)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HorizAlign -> m HorizAlign)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HorizAlign -> m HorizAlign)
    -> Data HorizAlign
    HorizAlign -> Constr
    HorizAlign -> DataType
    (forall b. Data b => b -> b) -> HorizAlign -> HorizAlign
    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) -> HorizAlign -> u
    forall u. (forall d. Data d => d -> u) -> HorizAlign -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HorizAlign -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HorizAlign -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HorizAlign -> m HorizAlign
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HorizAlign -> m HorizAlign
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HorizAlign
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HorizAlign -> c HorizAlign
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HorizAlign)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HorizAlign)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HorizAlign -> c HorizAlign
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HorizAlign -> c HorizAlign
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HorizAlign
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HorizAlign
    $ctoConstr :: HorizAlign -> Constr
    toConstr :: HorizAlign -> Constr
    $cdataTypeOf :: HorizAlign -> DataType
    dataTypeOf :: HorizAlign -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HorizAlign)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HorizAlign)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HorizAlign)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HorizAlign)
    $cgmapT :: (forall b. Data b => b -> b) -> HorizAlign -> HorizAlign
    gmapT :: (forall b. Data b => b -> b) -> HorizAlign -> HorizAlign
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HorizAlign -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HorizAlign -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HorizAlign -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HorizAlign -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HorizAlign -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HorizAlign -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HorizAlign -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HorizAlign -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HorizAlign -> m HorizAlign
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HorizAlign -> m HorizAlign
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HorizAlign -> m HorizAlign
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HorizAlign -> m HorizAlign
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HorizAlign -> m HorizAlign
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HorizAlign -> m HorizAlign
    Data, Typeable)

    instance ToJSON HorizAlign where
        toEncoding :: HorizAlign -> Encoding
    toEncoding = Options -> HorizAlign -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON HorizAlign

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

    instance ToJSON VertAlign where
        toEncoding :: VertAlign -> Encoding
    toEncoding = Options -> VertAlign -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON VertAlign

    -- | Inline element with attributes
    data Inline = Inline Attr InlineType
      deriving (Int -> Inline -> ShowS
    [Inline] -> ShowS
    Inline -> String
    (Int -> Inline -> ShowS)
    -> (Inline -> String) -> ([Inline] -> ShowS) -> Show Inline
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Inline -> ShowS
    showsPrec :: Int -> Inline -> ShowS
    $cshow :: Inline -> String
    show :: Inline -> String
    $cshowList :: [Inline] -> ShowS
    showList :: [Inline] -> ShowS
    Show, Inline -> Inline -> Bool
    (Inline -> Inline -> Bool)
    -> (Inline -> Inline -> Bool) -> Eq Inline
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Inline -> Inline -> Bool
    == :: Inline -> Inline -> Bool
    $c/= :: Inline -> Inline -> Bool
    /= :: Inline -> Inline -> Bool
    Eq, (forall x. Inline -> Rep Inline x)
    -> (forall x. Rep Inline x -> Inline) -> Generic Inline
    forall x. Rep Inline x -> Inline
    forall x. Inline -> Rep Inline x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Inline -> Rep Inline x
    from :: forall x. Inline -> Rep Inline x
    $cto :: forall x. Rep Inline x -> Inline
    to :: forall x. Rep Inline x -> Inline
    Generic, Typeable Inline
    Typeable Inline =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Inline -> c Inline)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Inline)
    -> (Inline -> Constr)
    -> (Inline -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Inline))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline))
    -> ((forall b. Data b => b -> b) -> Inline -> Inline)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Inline -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Inline -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Inline -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Inline -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Inline -> m Inline)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Inline -> m Inline)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Inline -> m Inline)
    -> Data Inline
    Inline -> Constr
    Inline -> DataType
    (forall b. Data b => b -> b) -> Inline -> Inline
    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) -> Inline -> u
    forall u. (forall d. Data d => d -> u) -> Inline -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Inline
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Inline -> c Inline
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Inline)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Inline -> c Inline
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Inline -> c Inline
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Inline
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Inline
    $ctoConstr :: Inline -> Constr
    toConstr :: Inline -> Constr
    $cdataTypeOf :: Inline -> DataType
    dataTypeOf :: Inline -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Inline)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Inline)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline)
    $cgmapT :: (forall b. Data b => b -> b) -> Inline -> Inline
    gmapT :: (forall b. Data b => b -> b) -> Inline -> Inline
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Inline -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Inline -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Inline -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Inline -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inline -> m Inline
    Data, Typeable)

    instance ToJSON Inline where
        toEncoding :: Inline -> Encoding
    toEncoding = Options -> Inline -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON Inline

    -- | Inline element types
    data InlineType
      = Str Text
      | HardBreak
      | Bold [Inline]
      | Italic [Inline]
      | Monospace [Inline]
      | Superscript [Inline]
      | Subscript [Inline]
      | Highlight [Inline]
      | Strikethrough [Inline]
      | DoubleQuoted [Inline]
      | SingleQuoted [Inline]
      | Math (Maybe MathType) Text
      | Icon Text
      | Button Text
      | Kbd [Text]
      | Menu [Text]
      | Link LinkType Target [Inline]
      | InlineImage Target (Maybe AltText) (Maybe Width) (Maybe Height)
      | Footnote (Maybe FootnoteId) [Inline]
      | InlineAnchor Text [Inline]
      | BibliographyAnchor Text [Inline]
      | CrossReference Text (Maybe [Inline])
      | AttributeReference AttributeName
      | Span [Inline]
      | IndexEntry IndexTerm
      | Counter Text CounterType Int
      | Passthrough Text
      deriving (Int -> InlineType -> ShowS
    [InlineType] -> ShowS
    InlineType -> String
    (Int -> InlineType -> ShowS)
    -> (InlineType -> String)
    -> ([InlineType] -> ShowS)
    -> Show InlineType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> InlineType -> ShowS
    showsPrec :: Int -> InlineType -> ShowS
    $cshow :: InlineType -> String
    show :: InlineType -> String
    $cshowList :: [InlineType] -> ShowS
    showList :: [InlineType] -> ShowS
    Show, InlineType -> InlineType -> Bool
    (InlineType -> InlineType -> Bool)
    -> (InlineType -> InlineType -> Bool) -> Eq InlineType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: InlineType -> InlineType -> Bool
    == :: InlineType -> InlineType -> Bool
    $c/= :: InlineType -> InlineType -> Bool
    /= :: InlineType -> InlineType -> Bool
    Eq, (forall x. InlineType -> Rep InlineType x)
    -> (forall x. Rep InlineType x -> InlineType) -> Generic InlineType
    forall x. Rep InlineType x -> InlineType
    forall x. InlineType -> Rep InlineType x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. InlineType -> Rep InlineType x
    from :: forall x. InlineType -> Rep InlineType x
    $cto :: forall x. Rep InlineType x -> InlineType
    to :: forall x. Rep InlineType x -> InlineType
    Generic, Typeable InlineType
    Typeable InlineType =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> InlineType -> c InlineType)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c InlineType)
    -> (InlineType -> Constr)
    -> (InlineType -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c InlineType))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c InlineType))
    -> ((forall b. Data b => b -> b) -> InlineType -> InlineType)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> InlineType -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> InlineType -> r)
    -> (forall u. (forall d. Data d => d -> u) -> InlineType -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> InlineType -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> InlineType -> m InlineType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> InlineType -> m InlineType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> InlineType -> m InlineType)
    -> Data InlineType
    InlineType -> Constr
    InlineType -> DataType
    (forall b. Data b => b -> b) -> InlineType -> InlineType
    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) -> InlineType -> u
    forall u. (forall d. Data d => d -> u) -> InlineType -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InlineType -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InlineType -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> InlineType -> m InlineType
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InlineType -> m InlineType
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c InlineType
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InlineType -> c InlineType
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c InlineType)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InlineType)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InlineType -> c InlineType
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> InlineType -> c InlineType
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c InlineType
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c InlineType
    $ctoConstr :: InlineType -> Constr
    toConstr :: InlineType -> Constr
    $cdataTypeOf :: InlineType -> DataType
    dataTypeOf :: InlineType -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c InlineType)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c InlineType)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InlineType)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InlineType)
    $cgmapT :: (forall b. Data b => b -> b) -> InlineType -> InlineType
    gmapT :: (forall b. Data b => b -> b) -> InlineType -> InlineType
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InlineType -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InlineType -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InlineType -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InlineType -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> InlineType -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> InlineType -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InlineType -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InlineType -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> InlineType -> m InlineType
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> InlineType -> m InlineType
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InlineType -> m InlineType
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InlineType -> m InlineType
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InlineType -> m InlineType
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InlineType -> m InlineType
    Data, Typeable)

    instance ToJSON InlineType where
        toEncoding :: InlineType -> Encoding
    toEncoding = Options -> InlineType -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON InlineType

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

    instance ToJSON MathType where
        toEncoding :: MathType -> Encoding
    toEncoding = Options -> MathType -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON MathType

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

    instance ToJSON LinkType where
        toEncoding :: LinkType -> Encoding
    toEncoding = Options -> LinkType -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON LinkType

    -- | Link or image target
    newtype Target = Target Text
      deriving (Int -> Target -> ShowS
    [Target] -> ShowS
    Target -> String
    (Int -> Target -> ShowS)
    -> (Target -> String) -> ([Target] -> ShowS) -> Show Target
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Target -> ShowS
    showsPrec :: Int -> Target -> ShowS
    $cshow :: Target -> String
    show :: Target -> String
    $cshowList :: [Target] -> ShowS
    showList :: [Target] -> ShowS
    Show, Target -> Target -> Bool
    (Target -> Target -> Bool)
    -> (Target -> Target -> Bool) -> Eq Target
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Target -> Target -> Bool
    == :: Target -> Target -> Bool
    $c/= :: Target -> Target -> Bool
    /= :: Target -> Target -> Bool
    Eq, (forall x. Target -> Rep Target x)
    -> (forall x. Rep Target x -> Target) -> Generic Target
    forall x. Rep Target x -> Target
    forall x. Target -> Rep Target x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Target -> Rep Target x
    from :: forall x. Target -> Rep Target x
    $cto :: forall x. Rep Target x -> Target
    to :: forall x. Rep Target x -> Target
    Generic, Typeable Target
    Typeable Target =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Target -> c Target)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Target)
    -> (Target -> Constr)
    -> (Target -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Target))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Target))
    -> ((forall b. Data b => b -> b) -> Target -> Target)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Target -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Target -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Target -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Target -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Target -> m Target)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Target -> m Target)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Target -> m Target)
    -> Data Target
    Target -> Constr
    Target -> DataType
    (forall b. Data b => b -> b) -> Target -> Target
    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) -> Target -> u
    forall u. (forall d. Data d => d -> u) -> Target -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Target -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Target -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Target -> m Target
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Target -> m Target
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Target
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Target -> c Target
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Target)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Target)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Target -> c Target
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Target -> c Target
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Target
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Target
    $ctoConstr :: Target -> Constr
    toConstr :: Target -> Constr
    $cdataTypeOf :: Target -> DataType
    dataTypeOf :: Target -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Target)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Target)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Target)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Target)
    $cgmapT :: (forall b. Data b => b -> b) -> Target -> Target
    gmapT :: (forall b. Data b => b -> b) -> Target -> Target
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Target -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Target -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Target -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Target -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Target -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Target -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Target -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Target -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Target -> m Target
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Target -> m Target
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Target -> m Target
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Target -> m Target
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Target -> m Target
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Target -> m Target
    Data, Typeable)

    instance ToJSON Target where
        toEncoding :: Target -> Encoding
    toEncoding = Options -> Target -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON Target

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

    instance ToJSON CounterType where
        toEncoding :: CounterType -> Encoding
    toEncoding = Options -> CounterType -> Encoding
    forall a.
    (Generic a, GToJSON' Encoding Zero (Rep a)) =>
    Options -> a -> Encoding
    genericToEncoding Options
    defaultOptions
    instance FromJSON CounterType