    {-# LANGUAGE CPP #-}
    -- | Unlifted "System.Directory".
    --
    -- @since 0.2.6.0

    module UnliftIO.Directory (
        -- * Actions on directories
        createDirectory
      , createDirectoryIfMissing
      , removeDirectory
      , removeDirectoryRecursive
    #if MIN_VERSION_directory(1,2,7)
      , removePathForcibly
    #endif
      , renameDirectory
    #if MIN_VERSION_directory(1,2,5)
      , listDirectory
    #endif
      , getDirectoryContents

      -- ** Current working directory
      , getCurrentDirectory
      , setCurrentDirectory
    #if MIN_VERSION_directory(1,2,3)
      , withCurrentDirectory
    #endif

      -- * Pre-defined directories
      , getHomeDirectory
    #if MIN_VERSION_directory(1,2,3)
      , XdgDirectory(..)
      , getXdgDirectory
    #endif
      , getAppUserDataDirectory
      , getUserDocumentsDirectory
      , getTemporaryDirectory

      -- * Actions on files
      , removeFile
      , renameFile
    #if MIN_VERSION_directory(1,2,7)
      , renamePath
    #endif
      , copyFile
    #if MIN_VERSION_directory(1,2,6)
      , copyFileWithMetadata
    #endif
      , canonicalizePath
    #if MIN_VERSION_directory(1,2,2)
      , makeAbsolute
    #endif
      , makeRelativeToCurrentDirectory
      , findExecutable
    #if MIN_VERSION_directory(1,2,2)
      , findExecutables
    #endif
    #if MIN_VERSION_directory(1,2,4)
      , findExecutablesInDirectories
    #endif
      , findFile
    #if MIN_VERSION_directory(1,2,1)
      , findFiles
    #endif
    #if MIN_VERSION_directory(1,2,6)
      , findFileWith
    #endif
    #if MIN_VERSION_directory(1,2,1)
      , findFilesWith
    #endif
    #if MIN_VERSION_directory(1,2,4)
      , exeExtension
    #endif
    #if MIN_VERSION_directory(1,2,7)
      , getFileSize
    #endif

      -- * Existence tests
    #if MIN_VERSION_directory(1,2,7)
      , doesPathExist
    #endif
      , doesFileExist
      , doesDirectoryExist

    #if MIN_VERSION_directory(1,3,0)
      -- * Symbolic links
      , pathIsSymbolicLink
    #endif

      -- * Permissions
      , Permissions
      , emptyPermissions
      , readable
      , writable
      , executable
      , searchable
      , setOwnerReadable
      , setOwnerWritable
      , setOwnerExecutable
      , setOwnerSearchable
      , getPermissions
      , setPermissions
      , copyPermissions

      -- * Timestamps
    #if MIN_VERSION_directory(1,2,3)
      , getAccessTime
    #endif
      , getModificationTime
    #if MIN_VERSION_directory(1,2,3)
      , setAccessTime
      , setModificationTime
    #endif
      ) where

    import Control.Monad.IO.Unlift
    import Data.Time.Clock
    import qualified System.Directory as D
    import System.Directory
      ( Permissions
    #if MIN_VERSION_directory(1,2,3)
      , XdgDirectory(..)
    #endif
      , emptyPermissions
    #if MIN_VERSION_directory(1,2,4)
      , exeExtension
    #endif
      , executable
      , readable
      , searchable
      , setOwnerExecutable
      , setOwnerReadable
      , setOwnerSearchable
      , setOwnerWritable
      , writable
      )

    -- | Lifted 'D.createDirectory'.
    --
    -- @since 0.2.6.0
    {-# INLINE createDirectory #-}
    createDirectory :: MonadIO m => FilePath -> m ()
    createDirectory :: FilePath -> m ()
    createDirectory = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> (FilePath -> IO ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO ()
    D.createDirectory

    -- | Lifted 'D.createDirectoryIfMissing'.
    --
    -- @since 0.2.6.0
    {-# INLINE createDirectoryIfMissing #-}
    createDirectoryIfMissing :: MonadIO m => Bool -> FilePath -> m ()
    createDirectoryIfMissing :: Bool -> FilePath -> m ()
    createDirectoryIfMissing create_parents :: Bool
    create_parents path0 :: FilePath
    path0 =
      IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (Bool -> FilePath -> IO ()
    D.createDirectoryIfMissing Bool
    create_parents FilePath
    path0)

    -- | Lifted 'D.removeDirectory'.
    --
    -- @since 0.2.6.0
    {-# INLINE removeDirectory #-}
    removeDirectory :: MonadIO m => FilePath -> m ()
    removeDirectory :: FilePath -> m ()
    removeDirectory = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> (FilePath -> IO ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO ()
    D.removeDirectory

    -- | Lifted 'D.removeDirectoryRecursive'.
    --
    -- @since 0.2.6.0
    {-# INLINE removeDirectoryRecursive #-}
    removeDirectoryRecursive :: MonadIO m => FilePath -> m ()
    removeDirectoryRecursive :: FilePath -> m ()
    removeDirectoryRecursive = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> (FilePath -> IO ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO ()
    D.removeDirectoryRecursive

    #if MIN_VERSION_directory(1,2,7)
    -- | Lifted 'D.removePathForcibly'.
    --
    -- @since 0.2.6.0
    {-# INLINE removePathForcibly #-}
    removePathForcibly :: MonadIO m => FilePath -> m ()
    removePathForcibly :: FilePath -> m ()
    removePathForcibly = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> (FilePath -> IO ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO ()
    D.removePathForcibly
    #endif

    -- | Lifted 'D.renameDirectory'.
    --
    -- @since 0.2.6.0
    {-# INLINE renameDirectory #-}
    renameDirectory :: MonadIO m => FilePath -> FilePath -> m ()
    renameDirectory :: FilePath -> FilePath -> m ()
    renameDirectory opath :: FilePath
    opath npath :: FilePath
    npath = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (FilePath -> FilePath -> IO ()
    D.renameDirectory FilePath
    opath FilePath
    npath)

    #if MIN_VERSION_directory(1,2,5)
    -- | Lifted 'D.listDirectory'.
    --
    -- @since 0.2.6.0
    {-# INLINE listDirectory #-}
    listDirectory :: MonadIO m => FilePath -> m [FilePath]
    listDirectory :: FilePath -> m [FilePath]
    listDirectory = IO [FilePath] -> m [FilePath]
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [FilePath] -> m [FilePath])
    -> (FilePath -> IO [FilePath]) -> FilePath -> m [FilePath]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO [FilePath]
    D.listDirectory
    #endif

    -- | Lifted 'D.getDirectoryContents'.
    --
    -- @since 0.2.6.0
    {-# INLINE getDirectoryContents #-}
    getDirectoryContents :: MonadIO m => FilePath -> m [FilePath]
    getDirectoryContents :: FilePath -> m [FilePath]
    getDirectoryContents = IO [FilePath] -> m [FilePath]
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [FilePath] -> m [FilePath])
    -> (FilePath -> IO [FilePath]) -> FilePath -> m [FilePath]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO [FilePath]
    D.getDirectoryContents

    -- | Lifted 'D.getCurrentDirectory'.
    --
    -- @since 0.2.6.0
    {-# INLINE getCurrentDirectory #-}
    getCurrentDirectory :: MonadIO m => m FilePath
    getCurrentDirectory :: m FilePath
    getCurrentDirectory = IO FilePath -> m FilePath
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO IO FilePath
    D.getCurrentDirectory

    -- | Lifted 'D.setCurrentDirectory'.
    --
    -- @since 0.2.6.0
    {-# INLINE setCurrentDirectory #-}
    setCurrentDirectory :: MonadIO m => FilePath -> m ()
    setCurrentDirectory :: FilePath -> m ()
    setCurrentDirectory = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> (FilePath -> IO ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO ()
    D.setCurrentDirectory

    #if MIN_VERSION_directory(1,2,3)
    -- | Unlifted 'D.withCurrentDirectory'.
    --
    -- @since 0.2.6.0
    {-# INLINE withCurrentDirectory #-}
    withCurrentDirectory :: MonadUnliftIO m => FilePath -> m a -> m a
    withCurrentDirectory :: FilePath -> m a -> m a
    withCurrentDirectory dir :: FilePath
    dir action :: m a
    action =
      ((forall a. m a -> IO a) -> IO a) -> m a
    forall (m :: * -> *) b.
    MonadUnliftIO m =>
    ((forall a. m a -> IO a) -> IO b) -> m b
    withRunInIO (\u :: forall a. m a -> IO a
    u -> FilePath -> IO a -> IO a
    forall a. FilePath -> IO a -> IO a
    D.withCurrentDirectory FilePath
    dir (m a -> IO a
    forall a. m a -> IO a
    u m a
    action))
    #endif

    -- | Lifted 'D.getHomeDirectory'.
    --
    -- @since 0.2.6.0
    {-# INLINE getHomeDirectory #-}
    getHomeDirectory :: MonadIO m => m FilePath
    getHomeDirectory :: m FilePath
    getHomeDirectory = IO FilePath -> m FilePath
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO IO FilePath
    D.getHomeDirectory

    #if MIN_VERSION_directory(1,2,3)
    -- | Lifted 'D.getXdgDirectory'.
    --
    -- @since 0.2.6.0
    {-# INLINE getXdgDirectory #-}
    getXdgDirectory :: MonadIO m => XdgDirectory -> FilePath -> m FilePath
    getXdgDirectory :: XdgDirectory -> FilePath -> m FilePath
    getXdgDirectory xdgDir :: XdgDirectory
    xdgDir suffix :: FilePath
    suffix = IO FilePath -> m FilePath
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (XdgDirectory -> FilePath -> IO FilePath
    D.getXdgDirectory XdgDirectory
    xdgDir FilePath
    suffix)
    #endif

    -- | Lifted 'D.getAppUserDataDirectory'.
    --
    -- @since 0.2.6.0
    {-# INLINE getAppUserDataDirectory #-}
    getAppUserDataDirectory :: MonadIO m => FilePath -> m FilePath
    getAppUserDataDirectory :: FilePath -> m FilePath
    getAppUserDataDirectory = IO FilePath -> m FilePath
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO FilePath -> m FilePath)
    -> (FilePath -> IO FilePath) -> FilePath -> m FilePath
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO FilePath
    D.getAppUserDataDirectory

    -- | Lifted 'D.getUserDocumentsDirectory'.
    --
    -- @since 0.2.6.0
    {-# INLINE getUserDocumentsDirectory #-}
    getUserDocumentsDirectory :: MonadIO m => m FilePath
    getUserDocumentsDirectory :: m FilePath
    getUserDocumentsDirectory = IO FilePath -> m FilePath
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO IO FilePath
    D.getUserDocumentsDirectory

    -- | Lifted 'D.getTemporaryDirectory'.
    --
    -- @since 0.2.6.0
    {-# INLINE getTemporaryDirectory #-}
    getTemporaryDirectory :: MonadIO m => m FilePath
    getTemporaryDirectory :: m FilePath
    getTemporaryDirectory = IO FilePath -> m FilePath
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO IO FilePath
    D.getTemporaryDirectory

    -- | Lifted 'D.removeFile'.
    --
    -- @since 0.2.6.0
    {-# INLINE removeFile #-}
    removeFile :: MonadIO m => FilePath -> m ()
    removeFile :: FilePath -> m ()
    removeFile = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> (FilePath -> IO ()) -> FilePath -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO ()
    D.removeFile

    -- | Lifted 'D.renameFile'.
    --
    -- @since 0.2.6.0
    {-# INLINE renameFile #-}
    renameFile :: MonadIO m => FilePath -> FilePath -> m ()
    renameFile :: FilePath -> FilePath -> m ()
    renameFile opath :: FilePath
    opath npath :: FilePath
    npath = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (FilePath -> FilePath -> IO ()
    D.renameFile FilePath
    opath FilePath
    npath)

    #if MIN_VERSION_directory(1,2,7)
    -- | Lifted 'D.renamePath'.
    --
    -- @since 0.2.6.0
    {-# INLINE renamePath #-}
    renamePath :: MonadIO m => FilePath -> FilePath -> m ()
    renamePath :: FilePath -> FilePath -> m ()
    renamePath opath :: FilePath
    opath npath :: FilePath
    npath = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (FilePath -> FilePath -> IO ()
    D.renamePath FilePath
    opath FilePath
    npath)
    #endif

    -- | Lifted 'D.copyFile'.
    --
    -- @since 0.2.6.0
    {-# INLINE copyFile #-}
    copyFile :: MonadIO m => FilePath -> FilePath -> m ()
    copyFile :: FilePath -> FilePath -> m ()
    copyFile fromFPath :: FilePath
    fromFPath toFPath :: FilePath
    toFPath = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (FilePath -> FilePath -> IO ()
    D.copyFile FilePath
    fromFPath FilePath
    toFPath)

    #if MIN_VERSION_directory(1,2,6)
    -- | Lifted 'D.copyFileWithMetadata'.
    --
    -- @since 0.2.6.0
    {-# INLINE copyFileWithMetadata #-}
    copyFileWithMetadata :: MonadIO m => FilePath -> FilePath -> m ()
    copyFileWithMetadata :: FilePath -> FilePath -> m ()
    copyFileWithMetadata src :: FilePath
    src dst :: FilePath
    dst = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (FilePath -> FilePath -> IO ()
    D.copyFileWithMetadata FilePath
    src FilePath
    dst)
    #endif

    -- | Lifted 'D.canonicalizePath'.
    --
    -- @since 0.2.6.0
    {-# INLINE canonicalizePath #-}
    canonicalizePath :: MonadIO m => FilePath -> m FilePath
    canonicalizePath :: FilePath -> m FilePath
    canonicalizePath = IO FilePath -> m FilePath
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO FilePath -> m FilePath)
    -> (FilePath -> IO FilePath) -> FilePath -> m FilePath
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO FilePath
    D.canonicalizePath

    #if MIN_VERSION_directory(1,2,2)
    -- | Lifted 'D.makeAbsolute'.
    --
    -- @since 0.2.6.0
    {-# INLINE makeAbsolute #-}
    makeAbsolute :: MonadIO m => FilePath -> m FilePath
    makeAbsolute :: FilePath -> m FilePath
    makeAbsolute = IO FilePath -> m FilePath
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO FilePath -> m FilePath)
    -> (FilePath -> IO FilePath) -> FilePath -> m FilePath
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO FilePath
    D.makeAbsolute
    #endif

    -- | Lifted 'D.makeRelativeToCurrentDirectory'.
    --
    -- @since 0.2.6.0
    {-# INLINE makeRelativeToCurrentDirectory #-}
    makeRelativeToCurrentDirectory :: MonadIO m => FilePath -> m FilePath
    makeRelativeToCurrentDirectory :: FilePath -> m FilePath
    makeRelativeToCurrentDirectory = IO FilePath -> m FilePath
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO FilePath -> m FilePath)
    -> (FilePath -> IO FilePath) -> FilePath -> m FilePath
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO FilePath
    D.makeRelativeToCurrentDirectory

    -- | Lifted 'D.findExecutable'.
    --
    -- @since 0.2.6.0
    {-# INLINE findExecutable #-}
    findExecutable :: MonadIO m => String -> m (Maybe FilePath)
    findExecutable :: FilePath -> m (Maybe FilePath)
    findExecutable = IO (Maybe FilePath) -> m (Maybe FilePath)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe FilePath) -> m (Maybe FilePath))
    -> (FilePath -> IO (Maybe FilePath))
    -> FilePath
    -> m (Maybe FilePath)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO (Maybe FilePath)
    D.findExecutable

    #if MIN_VERSION_directory(1,2,2)
    -- | Lifted 'D.findExecutables'.
    --
    -- @since 0.2.6.0
    {-# INLINE findExecutables #-}
    findExecutables :: MonadIO m => String -> m [FilePath]
    findExecutables :: FilePath -> m [FilePath]
    findExecutables = IO [FilePath] -> m [FilePath]
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [FilePath] -> m [FilePath])
    -> (FilePath -> IO [FilePath]) -> FilePath -> m [FilePath]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO [FilePath]
    D.findExecutables
    #endif

    #if MIN_VERSION_directory(1,2,4)
    -- | Lifted 'D.findExecutablesInDirectories'.
    --
    -- @since 0.2.6.0
    {-# INLINE findExecutablesInDirectories #-}
    findExecutablesInDirectories ::
         MonadIO m => [FilePath] -> String -> m [FilePath]
    findExecutablesInDirectories :: [FilePath] -> FilePath -> m [FilePath]
    findExecutablesInDirectories path :: [FilePath]
    path binary :: FilePath
    binary =
      IO [FilePath] -> m [FilePath]
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO ([FilePath] -> FilePath -> IO [FilePath]
    D.findExecutablesInDirectories [FilePath]
    path FilePath
    binary)
    #endif

    -- | Lifted 'D.findFile'.
    --
    -- @since 0.2.6.0
    {-# INLINE findFile #-}
    findFile :: MonadIO m => [FilePath] -> String -> m (Maybe FilePath)
    findFile :: [FilePath] -> FilePath -> m (Maybe FilePath)
    findFile ds :: [FilePath]
    ds name :: FilePath
    name = IO (Maybe FilePath) -> m (Maybe FilePath)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO ([FilePath] -> FilePath -> IO (Maybe FilePath)
    D.findFile [FilePath]
    ds FilePath
    name)

    #if MIN_VERSION_directory(1,2,1)
    -- | Lifted 'D.findFiles'.
    --
    -- @since 0.2.6.0
    {-# INLINE findFiles #-}
    findFiles :: MonadIO m => [FilePath] -> String -> m [FilePath]
    findFiles :: [FilePath] -> FilePath -> m [FilePath]
    findFiles ds :: [FilePath]
    ds name :: FilePath
    name = IO [FilePath] -> m [FilePath]
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO ([FilePath] -> FilePath -> IO [FilePath]
    D.findFiles [FilePath]
    ds FilePath
    name)
    #endif

    #if MIN_VERSION_directory(1,2,6)
    -- | Unlifted 'D.findFileWith'.
    --
    -- @since 0.2.6.0
    {-# INLINE findFileWith #-}
    findFileWith ::
         MonadUnliftIO m
      => (FilePath -> m Bool)
      -> [FilePath]
      -> String
      -> m (Maybe FilePath)
    findFileWith :: (FilePath -> m Bool)
    -> [FilePath] -> FilePath -> m (Maybe FilePath)
    findFileWith f :: FilePath -> m Bool
    f ds :: [FilePath]
    ds name :: FilePath
    name = ((forall a. m a -> IO a) -> IO (Maybe FilePath))
    -> m (Maybe FilePath)
    forall (m :: * -> *) b.
    MonadUnliftIO m =>
    ((forall a. m a -> IO a) -> IO b) -> m b
    withRunInIO (\u :: forall a. m a -> IO a
    u -> (FilePath -> IO Bool)
    -> [FilePath] -> FilePath -> IO (Maybe FilePath)
    D.findFileWith (m Bool -> IO Bool
    forall a. m a -> IO a
    u (m Bool -> IO Bool) -> (FilePath -> m Bool) -> FilePath -> IO Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> m Bool
    f) [FilePath]
    ds FilePath
    name)
    #endif

    #if MIN_VERSION_directory(1,2,1)
    -- | Unlifted 'D.findFilesWith'.
    --
    -- @since 0.2.6.0
    {-# INLINE findFilesWith #-}
    findFilesWith ::
         MonadUnliftIO m
      => (FilePath -> m Bool)
      -> [FilePath]
      -> String
      -> m [FilePath]
    findFilesWith :: (FilePath -> m Bool) -> [FilePath] -> FilePath -> m [FilePath]
    findFilesWith f :: FilePath -> m Bool
    f ds :: [FilePath]
    ds name :: FilePath
    name = ((forall a. m a -> IO a) -> IO [FilePath]) -> m [FilePath]
    forall (m :: * -> *) b.
    MonadUnliftIO m =>
    ((forall a. m a -> IO a) -> IO b) -> m b
    withRunInIO (\u :: forall a. m a -> IO a
    u -> (FilePath -> IO Bool) -> [FilePath] -> FilePath -> IO [FilePath]
    D.findFilesWith (m Bool -> IO Bool
    forall a. m a -> IO a
    u (m Bool -> IO Bool) -> (FilePath -> m Bool) -> FilePath -> IO Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> m Bool
    f) [FilePath]
    ds FilePath
    name)
    #endif

    #if MIN_VERSION_directory(1,2,7)
    -- | Lifted 'D.getFileSize'.
    --
    -- @since 0.2.6.0
    {-# INLINE getFileSize #-}
    getFileSize :: MonadIO m => FilePath -> m Integer
    getFileSize :: FilePath -> m Integer
    getFileSize = IO Integer -> m Integer
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Integer -> m Integer)
    -> (FilePath -> IO Integer) -> FilePath -> m Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO Integer
    D.getFileSize
    #endif

    #if MIN_VERSION_directory(1,2,7)
    -- | Lifted 'D.doesPathExist'.
    --
    -- @since 0.2.6.0
    {-# INLINE doesPathExist #-}
    doesPathExist :: MonadIO m => FilePath -> m Bool
    doesPathExist :: FilePath -> m Bool
    doesPathExist = IO Bool -> m Bool
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> (FilePath -> IO Bool) -> FilePath -> m Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO Bool
    D.doesPathExist
    #endif

    -- | Lifted 'D.doesFileExist'.
    --
    -- @since 0.2.6.0
    {-# INLINE doesFileExist #-}
    doesFileExist :: MonadIO m => FilePath -> m Bool
    doesFileExist :: FilePath -> m Bool
    doesFileExist = IO Bool -> m Bool
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> (FilePath -> IO Bool) -> FilePath -> m Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO Bool
    D.doesFileExist

    -- | Lifted 'D.doesDirectoryExist'.
    --
    -- @since 0.2.6.0
    {-# INLINE doesDirectoryExist #-}
    doesDirectoryExist :: MonadIO m => FilePath -> m Bool
    doesDirectoryExist :: FilePath -> m Bool
    doesDirectoryExist = IO Bool -> m Bool
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> (FilePath -> IO Bool) -> FilePath -> m Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO Bool
    D.doesDirectoryExist

    #if MIN_VERSION_directory(1,3,0)
    -- | Lifted 'D.pathIsSymbolicLink'.
    --
    -- @since 0.2.6.0
    {-# INLINE pathIsSymbolicLink #-}
    pathIsSymbolicLink :: MonadIO m => FilePath -> m Bool
    pathIsSymbolicLink :: FilePath -> m Bool
    pathIsSymbolicLink = IO Bool -> m Bool
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> (FilePath -> IO Bool) -> FilePath -> m Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO Bool
    D.pathIsSymbolicLink
    #endif

    -- | Lifted 'D.getPermissions'.
    --
    -- @since 0.2.6.0
    {-# INLINE getPermissions #-}
    getPermissions :: MonadIO m => FilePath -> m Permissions
    getPermissions :: FilePath -> m Permissions
    getPermissions = IO Permissions -> m Permissions
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Permissions -> m Permissions)
    -> (FilePath -> IO Permissions) -> FilePath -> m Permissions
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO Permissions
    D.getPermissions

    -- | Lifted 'D.setPermissions'.
    --
    -- @since 0.2.6.0
    {-# INLINE setPermissions #-}
    setPermissions :: MonadIO m => FilePath -> Permissions -> m ()
    setPermissions :: FilePath -> Permissions -> m ()
    setPermissions name :: FilePath
    name p :: Permissions
    p = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (FilePath -> Permissions -> IO ()
    D.setPermissions FilePath
    name Permissions
    p)

    -- | Lifted 'D.copyPermissions'.
    --
    -- @since 0.2.6.0
    {-# INLINE copyPermissions #-}
    copyPermissions :: MonadIO m => FilePath -> FilePath -> m ()
    copyPermissions :: FilePath -> FilePath -> m ()
    copyPermissions source :: FilePath
    source dest :: FilePath
    dest = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (FilePath -> FilePath -> IO ()
    D.copyPermissions FilePath
    source FilePath
    dest)

    #if MIN_VERSION_directory(1,2,3)
    -- | Lifted 'D.getAccessTime'.
    --
    -- @since 0.2.6.0
    {-# INLINE getAccessTime #-}
    getAccessTime :: MonadIO m => FilePath -> m UTCTime
    getAccessTime :: FilePath -> m UTCTime
    getAccessTime = IO UTCTime -> m UTCTime
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO UTCTime -> m UTCTime)
    -> (FilePath -> IO UTCTime) -> FilePath -> m UTCTime
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO UTCTime
    D.getAccessTime
    #endif

    -- | Lifted 'D.getModificationTime'.
    --
    -- @since 0.2.6.0
    {-# INLINE getModificationTime #-}
    getModificationTime :: MonadIO m => FilePath -> m UTCTime
    getModificationTime :: FilePath -> m UTCTime
    getModificationTime = IO UTCTime -> m UTCTime
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO UTCTime -> m UTCTime)
    -> (FilePath -> IO UTCTime) -> FilePath -> m UTCTime
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FilePath -> IO UTCTime
    D.getModificationTime

    #if MIN_VERSION_directory(1,2,3)
    -- | Lifted 'D.setAccessTime'.
    --
    -- @since 0.2.6.0
    {-# INLINE setAccessTime #-}
    setAccessTime :: MonadIO m => FilePath -> UTCTime -> m ()
    setAccessTime :: FilePath -> UTCTime -> m ()
    setAccessTime path :: FilePath
    path atime :: UTCTime
    atime = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (FilePath -> UTCTime -> IO ()
    D.setAccessTime FilePath
    path UTCTime
    atime)

    -- | Lifted 'D.setModificationTime'.
    --
    -- @since 0.2.6.0
    setModificationTime :: MonadIO m => FilePath -> UTCTime -> m ()
    setModificationTime :: FilePath -> UTCTime -> m ()
    setModificationTime path :: FilePath
    path mtime :: UTCTime
    mtime = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (FilePath -> UTCTime -> IO ()
    D.setModificationTime FilePath
    path UTCTime
    mtime)
    #endif