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

    module Dhall.Syntax.Import
        ( Directory(..)
        , File(..)
        , FilePrefix(..)
        , Import(..)
        , ImportHashed(..)
        , ImportMode(..)
        , ImportType(..)
        , URL(..)
        , Scheme(..)
        ) where

    import Data.Data                      (Data)
    import Data.Text                      (Text)
    import Dhall.Src                      (Src (..))
    import Dhall.Syntax.Expr              (Expr (..))
    import Dhall.Syntax.Instances.Data    ()
    import Dhall.Syntax.Instances.Functor ()
    import GHC.Generics                   (Generic)

    import qualified Dhall.Crypto

    {-| Internal representation of a directory that stores the path components in
        reverse order

        In other words, the directory @\/foo\/bar\/baz@ is encoded as
        @Directory { components = [ "baz", "bar", "foo" ] }@
    -}
    newtype Directory = Directory { Directory -> [Text]
    components :: [Text] }
        deriving (Typeable Directory
    Typeable Directory =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Directory -> c Directory)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Directory)
    -> (Directory -> Constr)
    -> (Directory -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Directory))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Directory))
    -> ((forall b. Data b => b -> b) -> Directory -> Directory)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Directory -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Directory -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Directory -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Directory -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Directory -> m Directory)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Directory -> m Directory)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Directory -> m Directory)
    -> Data Directory
    Directory -> Constr
    Directory -> DataType
    (forall b. Data b => b -> b) -> Directory -> Directory
    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) -> Directory -> u
    forall u. (forall d. Data d => d -> u) -> Directory -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Directory -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Directory -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Directory -> m Directory
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Directory -> m Directory
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Directory
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Directory -> c Directory
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Directory)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Directory)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Directory -> c Directory
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Directory -> c Directory
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Directory
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Directory
    $ctoConstr :: Directory -> Constr
    toConstr :: Directory -> Constr
    $cdataTypeOf :: Directory -> DataType
    dataTypeOf :: Directory -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Directory)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Directory)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Directory)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Directory)
    $cgmapT :: (forall b. Data b => b -> b) -> Directory -> Directory
    gmapT :: (forall b. Data b => b -> b) -> Directory -> Directory
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Directory -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Directory -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Directory -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Directory -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Directory -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Directory -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Directory -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Directory -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Directory -> m Directory
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Directory -> m Directory
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Directory -> m Directory
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Directory -> m Directory
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Directory -> m Directory
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Directory -> m Directory
    Data, (forall x. Directory -> Rep Directory x)
    -> (forall x. Rep Directory x -> Directory) -> Generic Directory
    forall x. Rep Directory x -> Directory
    forall x. Directory -> Rep Directory x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Directory -> Rep Directory x
    from :: forall x. Directory -> Rep Directory x
    $cto :: forall x. Rep Directory x -> Directory
    to :: forall x. Rep Directory x -> Directory
    Generic)

    {-| A `File` is a `directory` followed by one additional path component
        representing the `file` name
    -}
    data File = File
        { File -> Directory
    directory :: Directory
        , File -> Text
    file      :: Text
        } deriving (Typeable File
    Typeable File =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> File -> c File)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c File)
    -> (File -> Constr)
    -> (File -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c File))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c File))
    -> ((forall b. Data b => b -> b) -> File -> File)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> File -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> File -> r)
    -> (forall u. (forall d. Data d => d -> u) -> File -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> File -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> File -> m File)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> File -> m File)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> File -> m File)
    -> Data File
    File -> Constr
    File -> DataType
    (forall b. Data b => b -> b) -> File -> File
    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) -> File -> u
    forall u. (forall d. Data d => d -> u) -> File -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> File -> m File
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> File -> m File
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c File
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> File -> c File
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c File)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c File)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> File -> c File
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> File -> c File
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c File
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c File
    $ctoConstr :: File -> Constr
    toConstr :: File -> Constr
    $cdataTypeOf :: File -> DataType
    dataTypeOf :: File -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c File)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c File)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c File)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c File)
    $cgmapT :: (forall b. Data b => b -> b) -> File -> File
    gmapT :: (forall b. Data b => b -> b) -> File -> File
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> File -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> File -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> File -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> File -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> File -> m File
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> File -> m File
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> File -> m File
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> File -> m File
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> File -> m File
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> File -> m File
    Data, (forall x. File -> Rep File x)
    -> (forall x. Rep File x -> File) -> Generic File
    forall x. Rep File x -> File
    forall x. File -> Rep File x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. File -> Rep File x
    from :: forall x. File -> Rep File x
    $cto :: forall x. Rep File x -> File
    to :: forall x. Rep File x -> File
    Generic)

    -- | The beginning of a file path which anchors subsequent path components
    data FilePrefix
        = Absolute
        -- ^ Absolute path
        | Here
        -- ^ Path relative to @.@
        | Parent
        -- ^ Path relative to @..@
        | Home
        -- ^ Path relative to @~@
        deriving (Typeable FilePrefix
    Typeable FilePrefix =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> FilePrefix -> c FilePrefix)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c FilePrefix)
    -> (FilePrefix -> Constr)
    -> (FilePrefix -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c FilePrefix))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c FilePrefix))
    -> ((forall b. Data b => b -> b) -> FilePrefix -> FilePrefix)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> FilePrefix -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> FilePrefix -> r)
    -> (forall u. (forall d. Data d => d -> u) -> FilePrefix -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> FilePrefix -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> FilePrefix -> m FilePrefix)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> FilePrefix -> m FilePrefix)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> FilePrefix -> m FilePrefix)
    -> Data FilePrefix
    FilePrefix -> Constr
    FilePrefix -> DataType
    (forall b. Data b => b -> b) -> FilePrefix -> FilePrefix
    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) -> FilePrefix -> u
    forall u. (forall d. Data d => d -> u) -> FilePrefix -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FilePrefix -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FilePrefix -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FilePrefix -> m FilePrefix
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FilePrefix -> m FilePrefix
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FilePrefix
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FilePrefix -> c FilePrefix
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FilePrefix)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FilePrefix)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FilePrefix -> c FilePrefix
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FilePrefix -> c FilePrefix
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FilePrefix
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FilePrefix
    $ctoConstr :: FilePrefix -> Constr
    toConstr :: FilePrefix -> Constr
    $cdataTypeOf :: FilePrefix -> DataType
    dataTypeOf :: FilePrefix -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FilePrefix)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FilePrefix)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FilePrefix)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FilePrefix)
    $cgmapT :: (forall b. Data b => b -> b) -> FilePrefix -> FilePrefix
    gmapT :: (forall b. Data b => b -> b) -> FilePrefix -> FilePrefix
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FilePrefix -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FilePrefix -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FilePrefix -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FilePrefix -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> FilePrefix -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> FilePrefix -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FilePrefix -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FilePrefix -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FilePrefix -> m FilePrefix
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FilePrefix -> m FilePrefix
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FilePrefix -> m FilePrefix
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FilePrefix -> m FilePrefix
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FilePrefix -> m FilePrefix
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FilePrefix -> m FilePrefix
    Data, (forall x. FilePrefix -> Rep FilePrefix x)
    -> (forall x. Rep FilePrefix x -> FilePrefix) -> Generic FilePrefix
    forall x. Rep FilePrefix x -> FilePrefix
    forall x. FilePrefix -> Rep FilePrefix x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. FilePrefix -> Rep FilePrefix x
    from :: forall x. FilePrefix -> Rep FilePrefix x
    $cto :: forall x. Rep FilePrefix x -> FilePrefix
    to :: forall x. Rep FilePrefix x -> FilePrefix
    Generic)

    -- | The URI scheme
    data Scheme = HTTP | HTTPS
        deriving (Typeable Scheme
    Typeable Scheme =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Scheme -> c Scheme)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Scheme)
    -> (Scheme -> Constr)
    -> (Scheme -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Scheme))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scheme))
    -> ((forall b. Data b => b -> b) -> Scheme -> Scheme)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Scheme -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Scheme -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Scheme -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Scheme -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Scheme -> m Scheme)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Scheme -> m Scheme)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Scheme -> m Scheme)
    -> Data Scheme
    Scheme -> Constr
    Scheme -> DataType
    (forall b. Data b => b -> b) -> Scheme -> Scheme
    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) -> Scheme -> u
    forall u. (forall d. Data d => d -> u) -> Scheme -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Scheme -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Scheme -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Scheme -> m Scheme
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Scheme -> m Scheme
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Scheme
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Scheme -> c Scheme
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Scheme)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scheme)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Scheme -> c Scheme
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Scheme -> c Scheme
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Scheme
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Scheme
    $ctoConstr :: Scheme -> Constr
    toConstr :: Scheme -> Constr
    $cdataTypeOf :: Scheme -> DataType
    dataTypeOf :: Scheme -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Scheme)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Scheme)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scheme)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scheme)
    $cgmapT :: (forall b. Data b => b -> b) -> Scheme -> Scheme
    gmapT :: (forall b. Data b => b -> b) -> Scheme -> Scheme
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Scheme -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Scheme -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Scheme -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Scheme -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Scheme -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Scheme -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Scheme -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Scheme -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Scheme -> m Scheme
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Scheme -> m Scheme
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Scheme -> m Scheme
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Scheme -> m Scheme
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Scheme -> m Scheme
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Scheme -> m Scheme
    Data, (forall x. Scheme -> Rep Scheme x)
    -> (forall x. Rep Scheme x -> Scheme) -> Generic Scheme
    forall x. Rep Scheme x -> Scheme
    forall x. Scheme -> Rep Scheme x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Scheme -> Rep Scheme x
    from :: forall x. Scheme -> Rep Scheme x
    $cto :: forall x. Rep Scheme x -> Scheme
    to :: forall x. Rep Scheme x -> Scheme
    Generic)

    -- | This type stores all of the components of a remote import
    data URL = URL
        { URL -> Scheme
    scheme    :: Scheme
        , URL -> Text
    authority :: Text
        , URL -> File
    path      :: File
        , URL -> Maybe Text
    query     :: Maybe Text
        , URL -> Maybe (Expr Src Import)
    headers   :: Maybe (Expr Src Import)
        } deriving (Typeable URL
    Typeable URL =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> URL -> c URL)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c URL)
    -> (URL -> Constr)
    -> (URL -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c URL))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c URL))
    -> ((forall b. Data b => b -> b) -> URL -> URL)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r)
    -> (forall u. (forall d. Data d => d -> u) -> URL -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> URL -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> URL -> m URL)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> URL -> m URL)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> URL -> m URL)
    -> Data URL
    URL -> Constr
    URL -> DataType
    (forall b. Data b => b -> b) -> URL -> URL
    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) -> URL -> u
    forall u. (forall d. Data d => d -> u) -> URL -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> URL -> m URL
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> URL -> m URL
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c URL
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> URL -> c URL
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c URL)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c URL)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> URL -> c URL
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> URL -> c URL
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c URL
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c URL
    $ctoConstr :: URL -> Constr
    toConstr :: URL -> Constr
    $cdataTypeOf :: URL -> DataType
    dataTypeOf :: URL -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c URL)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c URL)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c URL)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c URL)
    $cgmapT :: (forall b. Data b => b -> b) -> URL -> URL
    gmapT :: (forall b. Data b => b -> b) -> URL -> URL
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> URL -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> URL -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> URL -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> URL -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> URL -> m URL
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> URL -> m URL
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> URL -> m URL
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> URL -> m URL
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> URL -> m URL
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> URL -> m URL
    Data, (forall x. URL -> Rep URL x)
    -> (forall x. Rep URL x -> URL) -> Generic URL
    forall x. Rep URL x -> URL
    forall x. URL -> Rep URL x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. URL -> Rep URL x
    from :: forall x. URL -> Rep URL x
    $cto :: forall x. Rep URL x -> URL
    to :: forall x. Rep URL x -> URL
    Generic)

    -- | The type of import (i.e. local vs. remote vs. environment)
    data ImportType
        = Local FilePrefix File
        -- ^ Local path
        | Remote URL
        -- ^ URL of remote resource and optional headers stored in an import
        | Env  Text
        -- ^ Environment variable
        | Missing
        deriving (Typeable ImportType
    Typeable ImportType =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ImportType -> c ImportType)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ImportType)
    -> (ImportType -> Constr)
    -> (ImportType -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ImportType))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c ImportType))
    -> ((forall b. Data b => b -> b) -> ImportType -> ImportType)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ImportType -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ImportType -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ImportType -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ImportType -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ImportType -> m ImportType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ImportType -> m ImportType)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ImportType -> m ImportType)
    -> Data ImportType
    ImportType -> Constr
    ImportType -> DataType
    (forall b. Data b => b -> b) -> ImportType -> ImportType
    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) -> ImportType -> u
    forall u. (forall d. Data d => d -> u) -> ImportType -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportType -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportType -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImportType -> m ImportType
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportType -> m ImportType
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ImportType
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportType -> c ImportType
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ImportType)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportType)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportType -> c ImportType
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportType -> c ImportType
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ImportType
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ImportType
    $ctoConstr :: ImportType -> Constr
    toConstr :: ImportType -> Constr
    $cdataTypeOf :: ImportType -> DataType
    dataTypeOf :: ImportType -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ImportType)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ImportType)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportType)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportType)
    $cgmapT :: (forall b. Data b => b -> b) -> ImportType -> ImportType
    gmapT :: (forall b. Data b => b -> b) -> ImportType -> ImportType
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportType -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportType -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportType -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportType -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ImportType -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ImportType -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImportType -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImportType -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImportType -> m ImportType
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImportType -> m ImportType
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportType -> m ImportType
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportType -> m ImportType
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportType -> m ImportType
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportType -> m ImportType
    Data, (forall x. ImportType -> Rep ImportType x)
    -> (forall x. Rep ImportType x -> ImportType) -> Generic ImportType
    forall x. Rep ImportType x -> ImportType
    forall x. ImportType -> Rep ImportType x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. ImportType -> Rep ImportType x
    from :: forall x. ImportType -> Rep ImportType x
    $cto :: forall x. Rep ImportType x -> ImportType
    to :: forall x. Rep ImportType x -> ImportType
    Generic)

    -- | How to interpret the import's contents (i.e. as Dhall code or raw text)
    data ImportMode = Code | RawText | Location | RawBytes
      deriving (Typeable ImportMode
    Typeable ImportMode =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ImportMode -> c ImportMode)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ImportMode)
    -> (ImportMode -> Constr)
    -> (ImportMode -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ImportMode))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c ImportMode))
    -> ((forall b. Data b => b -> b) -> ImportMode -> ImportMode)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ImportMode -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ImportMode -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ImportMode -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ImportMode -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ImportMode -> m ImportMode)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ImportMode -> m ImportMode)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ImportMode -> m ImportMode)
    -> Data ImportMode
    ImportMode -> Constr
    ImportMode -> DataType
    (forall b. Data b => b -> b) -> ImportMode -> ImportMode
    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) -> ImportMode -> u
    forall u. (forall d. Data d => d -> u) -> ImportMode -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportMode -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportMode -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImportMode -> m ImportMode
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportMode -> m ImportMode
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ImportMode
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportMode -> c ImportMode
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ImportMode)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportMode)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportMode -> c ImportMode
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportMode -> c ImportMode
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ImportMode
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ImportMode
    $ctoConstr :: ImportMode -> Constr
    toConstr :: ImportMode -> Constr
    $cdataTypeOf :: ImportMode -> DataType
    dataTypeOf :: ImportMode -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ImportMode)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ImportMode)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportMode)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportMode)
    $cgmapT :: (forall b. Data b => b -> b) -> ImportMode -> ImportMode
    gmapT :: (forall b. Data b => b -> b) -> ImportMode -> ImportMode
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportMode -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportMode -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportMode -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportMode -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ImportMode -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ImportMode -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImportMode -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImportMode -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImportMode -> m ImportMode
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImportMode -> m ImportMode
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportMode -> m ImportMode
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportMode -> m ImportMode
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportMode -> m ImportMode
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportMode -> m ImportMode
    Data, (forall x. ImportMode -> Rep ImportMode x)
    -> (forall x. Rep ImportMode x -> ImportMode) -> Generic ImportMode
    forall x. Rep ImportMode x -> ImportMode
    forall x. ImportMode -> Rep ImportMode x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. ImportMode -> Rep ImportMode x
    from :: forall x. ImportMode -> Rep ImportMode x
    $cto :: forall x. Rep ImportMode x -> ImportMode
    to :: forall x. Rep ImportMode x -> ImportMode
    Generic)

    -- | A `ImportType` extended with an optional hash for semantic integrity checks
    data ImportHashed = ImportHashed
        { ImportHashed -> Maybe SHA256Digest
    hash       :: Maybe Dhall.Crypto.SHA256Digest
        , ImportHashed -> ImportType
    importType :: ImportType
        } deriving (Typeable ImportHashed
    Typeable ImportHashed =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ImportHashed -> c ImportHashed)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ImportHashed)
    -> (ImportHashed -> Constr)
    -> (ImportHashed -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ImportHashed))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c ImportHashed))
    -> ((forall b. Data b => b -> b) -> ImportHashed -> ImportHashed)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ImportHashed -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ImportHashed -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ImportHashed -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ImportHashed -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ImportHashed -> m ImportHashed)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ImportHashed -> m ImportHashed)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ImportHashed -> m ImportHashed)
    -> Data ImportHashed
    ImportHashed -> Constr
    ImportHashed -> DataType
    (forall b. Data b => b -> b) -> ImportHashed -> ImportHashed
    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) -> ImportHashed -> u
    forall u. (forall d. Data d => d -> u) -> ImportHashed -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportHashed -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportHashed -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImportHashed -> m ImportHashed
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportHashed -> m ImportHashed
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ImportHashed
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportHashed -> c ImportHashed
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ImportHashed)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ImportHashed)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportHashed -> c ImportHashed
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ImportHashed -> c ImportHashed
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ImportHashed
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ImportHashed
    $ctoConstr :: ImportHashed -> Constr
    toConstr :: ImportHashed -> Constr
    $cdataTypeOf :: ImportHashed -> DataType
    dataTypeOf :: ImportHashed -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ImportHashed)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ImportHashed)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ImportHashed)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ImportHashed)
    $cgmapT :: (forall b. Data b => b -> b) -> ImportHashed -> ImportHashed
    gmapT :: (forall b. Data b => b -> b) -> ImportHashed -> ImportHashed
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportHashed -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportHashed -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportHashed -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportHashed -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ImportHashed -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ImportHashed -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImportHashed -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImportHashed -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImportHashed -> m ImportHashed
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImportHashed -> m ImportHashed
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportHashed -> m ImportHashed
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportHashed -> m ImportHashed
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportHashed -> m ImportHashed
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportHashed -> m ImportHashed
    Data, (forall x. ImportHashed -> Rep ImportHashed x)
    -> (forall x. Rep ImportHashed x -> ImportHashed)
    -> Generic ImportHashed
    forall x. Rep ImportHashed x -> ImportHashed
    forall x. ImportHashed -> Rep ImportHashed x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. ImportHashed -> Rep ImportHashed x
    from :: forall x. ImportHashed -> Rep ImportHashed x
    $cto :: forall x. Rep ImportHashed x -> ImportHashed
    to :: forall x. Rep ImportHashed x -> ImportHashed
    Generic)

    -- | Reference to an external resource
    data Import = Import
        { Import -> ImportHashed
    importHashed :: ImportHashed
        , Import -> ImportMode
    importMode   :: ImportMode
        } deriving (Typeable Import
    Typeable Import =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Import -> c Import)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Import)
    -> (Import -> Constr)
    -> (Import -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Import))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Import))
    -> ((forall b. Data b => b -> b) -> Import -> Import)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Import -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Import -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Import -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Import -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Import -> m Import)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Import -> m Import)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Import -> m Import)
    -> Data Import
    Import -> Constr
    Import -> DataType
    (forall b. Data b => b -> b) -> Import -> Import
    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) -> Import -> u
    forall u. (forall d. Data d => d -> u) -> Import -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Import -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Import -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Import -> m Import
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Import -> m Import
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Import
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Import -> c Import
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Import)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Import)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Import -> c Import
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Import -> c Import
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Import
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Import
    $ctoConstr :: Import -> Constr
    toConstr :: Import -> Constr
    $cdataTypeOf :: Import -> DataType
    dataTypeOf :: Import -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Import)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Import)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Import)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Import)
    $cgmapT :: (forall b. Data b => b -> b) -> Import -> Import
    gmapT :: (forall b. Data b => b -> b) -> Import -> Import
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Import -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Import -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Import -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Import -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Import -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Import -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Import -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Import -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Import -> m Import
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Import -> m Import
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Import -> m Import
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Import -> m Import
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Import -> m Import
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Import -> m Import
    Data, (forall x. Import -> Rep Import x)
    -> (forall x. Rep Import x -> Import) -> Generic Import
    forall x. Rep Import x -> Import
    forall x. Import -> Rep Import x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Import -> Rep Import x
    from :: forall x. Import -> Rep Import x
    $cto :: forall x. Rep Import x -> Import
    to :: forall x. Rep Import x -> Import
    Generic)

    instance Semigroup Directory where
        Directory [Text]
    components0 <> :: Directory -> Directory -> Directory
    <> Directory [Text]
    components1 =
            [Text] -> Directory
    Directory ([Text]
    components1 [Text] -> [Text] -> [Text]
    forall a. Semigroup a => a -> a -> a
    <> [Text]
    components0)

    instance Semigroup File where
        File Directory
    directory0 Text
    _ <> :: File -> File -> File
    <> File Directory
    directory1 Text
    file =
            Directory -> Text -> File
    File (Directory
    directory0 Directory -> Directory -> Directory
    forall a. Semigroup a => a -> a -> a
    <> Directory
    directory1) Text
    file

    instance Semigroup ImportType where
        Local FilePrefix
    prefix File
    file0 <> :: ImportType -> ImportType -> ImportType
    <> Local FilePrefix
    Here File
    file1 = FilePrefix -> File -> ImportType
    Local FilePrefix
    prefix (File
    file0 File -> File -> File
    forall a. Semigroup a => a -> a -> a
    <> File
    file1)

        Remote (URL { path :: URL -> File
    path = File
    path0, Maybe Text
    Maybe (Expr Src Import)
    Text
    Scheme
    scheme :: URL -> Scheme
    authority :: URL -> Text
    query :: URL -> Maybe Text
    headers :: URL -> Maybe (Expr Src Import)
    scheme :: Scheme
    authority :: Text
    query :: Maybe Text
    headers :: Maybe (Expr Src Import)
    ..}) <> Local FilePrefix
    Here File
    path1 =
            URL -> ImportType
    Remote (URL { path :: File
    path = File
    path0 File -> File -> File
    forall a. Semigroup a => a -> a -> a
    <> File
    path1, Maybe Text
    Maybe (Expr Src Import)
    Text
    Scheme
    scheme :: Scheme
    authority :: Text
    query :: Maybe Text
    headers :: Maybe (Expr Src Import)
    scheme :: Scheme
    authority :: Text
    query :: Maybe Text
    headers :: Maybe (Expr Src Import)
    ..})

        Local FilePrefix
    prefix File
    file0 <> Local FilePrefix
    Parent File
    file1 =
            FilePrefix -> File -> ImportType
    Local FilePrefix
    prefix (File
    file0 File -> File -> File
    forall a. Semigroup a => a -> a -> a
    <> File
    parent File -> File -> File
    forall a. Semigroup a => a -> a -> a
    <> File
    file1)

        Remote (URL { path :: URL -> File
    path = File
    path0, Maybe Text
    Maybe (Expr Src Import)
    Text
    Scheme
    scheme :: URL -> Scheme
    authority :: URL -> Text
    query :: URL -> Maybe Text
    headers :: URL -> Maybe (Expr Src Import)
    scheme :: Scheme
    authority :: Text
    query :: Maybe Text
    headers :: Maybe (Expr Src Import)
    .. }) <> Local FilePrefix
    Parent File
    path1 =
            URL -> ImportType
    Remote (URL { path :: File
    path = File
    path0 File -> File -> File
    forall a. Semigroup a => a -> a -> a
    <> File
    parent File -> File -> File
    forall a. Semigroup a => a -> a -> a
    <> File
    path1, Maybe Text
    Maybe (Expr Src Import)
    Text
    Scheme
    scheme :: Scheme
    authority :: Text
    query :: Maybe Text
    headers :: Maybe (Expr Src Import)
    scheme :: Scheme
    authority :: Text
    query :: Maybe Text
    headers :: Maybe (Expr Src Import)
    .. })

        ImportType
    import0 <> Remote (URL { headers :: URL -> Maybe (Expr Src Import)
    headers = Maybe (Expr Src Import)
    headers0, Maybe Text
    Text
    Scheme
    File
    scheme :: URL -> Scheme
    authority :: URL -> Text
    path :: URL -> File
    query :: URL -> Maybe Text
    scheme :: Scheme
    authority :: Text
    path :: File
    query :: Maybe Text
    .. }) =
            URL -> ImportType
    Remote (URL { headers :: Maybe (Expr Src Import)
    headers = Maybe (Expr Src Import)
    headers1, Maybe Text
    Text
    Scheme
    File
    scheme :: Scheme
    authority :: Text
    path :: File
    query :: Maybe Text
    scheme :: Scheme
    authority :: Text
    path :: File
    query :: Maybe Text
    .. })
          where
            importHashed0 :: Import
    importHashed0 = ImportHashed -> ImportMode -> Import
    Import (Maybe SHA256Digest -> ImportType -> ImportHashed
    ImportHashed Maybe SHA256Digest
    forall a. Maybe a
    Nothing ImportType
    import0) ImportMode
    Code

            headers1 :: Maybe (Expr Src Import)
    headers1 = (Expr Src Import -> Expr Src Import)
    -> Maybe (Expr Src Import) -> Maybe (Expr Src Import)
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((Import -> Import) -> Expr Src Import -> Expr Src Import
    forall a b. (a -> b) -> Expr Src a -> Expr Src b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (Import
    importHashed0 Import -> Import -> Import
    forall a. Semigroup a => a -> a -> a
    <>)) Maybe (Expr Src Import)
    headers0

        ImportType
    _ <> ImportType
    import1 =
            ImportType
    import1

    instance Semigroup ImportHashed where
        ImportHashed Maybe SHA256Digest
    _ ImportType
    importType0 <> :: ImportHashed -> ImportHashed -> ImportHashed
    <> ImportHashed Maybe SHA256Digest
    hash ImportType
    importType1 =
            Maybe SHA256Digest -> ImportType -> ImportHashed
    ImportHashed Maybe SHA256Digest
    hash (ImportType
    importType0 ImportType -> ImportType -> ImportType
    forall a. Semigroup a => a -> a -> a
    <> ImportType
    importType1)

    instance Semigroup Import where
        Import ImportHashed
    importHashed0 ImportMode
    _ <> :: Import -> Import -> Import
    <> Import ImportHashed
    importHashed1 ImportMode
    code =
            ImportHashed -> ImportMode -> Import
    Import (ImportHashed
    importHashed0 ImportHashed -> ImportHashed -> ImportHashed
    forall a. Semigroup a => a -> a -> a
    <> ImportHashed
    importHashed1) ImportMode
    code

    parent :: File
    parent :: File
    parent = File { directory :: Directory
    directory = Directory { components :: [Text]
    components = [ Text
    ".." ] }, file :: Text
    file = Text
    "" }