    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Acts as a lightweight registry for possible valid file attributes.
    -- The registry stores Key-Value pair formats as @/GFileAttributeInfos/@.

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gio.Structs.FileAttributeInfoList
        (

    -- * Exported types
        FileAttributeInfoList(..)               ,
        newZeroFileAttributeInfoList            ,

     -- * Methods
    -- ** Overloaded methods #method:Overloaded methods#

    #if defined(ENABLE_OVERLOADING)
        ResolveFileAttributeInfoListMethod      ,
    #endif

    -- ** add #method:add#

    #if defined(ENABLE_OVERLOADING)
        FileAttributeInfoListAddMethodInfo      ,
    #endif
        fileAttributeInfoListAdd                ,

    -- ** dup #method:dup#

    #if defined(ENABLE_OVERLOADING)
        FileAttributeInfoListDupMethodInfo      ,
    #endif
        fileAttributeInfoListDup                ,

    -- ** lookup #method:lookup#

    #if defined(ENABLE_OVERLOADING)
        FileAttributeInfoListLookupMethodInfo   ,
    #endif
        fileAttributeInfoListLookup             ,

    -- ** new #method:new#

        fileAttributeInfoListNew                ,

    -- ** ref #method:ref#

    #if defined(ENABLE_OVERLOADING)
        FileAttributeInfoListRefMethodInfo      ,
    #endif
        fileAttributeInfoListRef                ,

    -- ** unref #method:unref#

    #if defined(ENABLE_OVERLOADING)
        FileAttributeInfoListUnrefMethodInfo    ,
    #endif
        fileAttributeInfoListUnref              ,

     -- * Properties
    -- ** infos #attr:infos#
    -- | an array of @/GFileAttributeInfos/@.

        clearFileAttributeInfoListInfos         ,
    #if defined(ENABLE_OVERLOADING)
        fileAttributeInfoList_infos             ,
    #endif
        getFileAttributeInfoListInfos           ,
        setFileAttributeInfoListInfos           ,

    -- ** nInfos #attr:nInfos#
    -- | the number of values in the array.

    #if defined(ENABLE_OVERLOADING)
        fileAttributeInfoList_nInfos            ,
    #endif
        getFileAttributeInfoListNInfos          ,
        setFileAttributeInfoListNInfos          ,

        ) where

    import Data.GI.Base.ShortPrelude
    import qualified Data.GI.Base.ShortPrelude as SP
    import qualified Data.GI.Base.Overloading as O
    import qualified Prelude as P

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL

    import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
    import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags
    import {-# SOURCE #-} qualified GI.Gio.Structs.FileAttributeInfo as Gio.FileAttributeInfo

    -- | Memory-managed wrapper type.
    newtype FileAttributeInfoList = FileAttributeInfoList (SP.ManagedPtr FileAttributeInfoList)
        deriving (FileAttributeInfoList -> FileAttributeInfoList -> Bool
    (FileAttributeInfoList -> FileAttributeInfoList -> Bool)
    -> (FileAttributeInfoList -> FileAttributeInfoList -> Bool)
    -> Eq FileAttributeInfoList
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: FileAttributeInfoList -> FileAttributeInfoList -> Bool
    $c/= :: FileAttributeInfoList -> FileAttributeInfoList -> Bool
    == :: FileAttributeInfoList -> FileAttributeInfoList -> Bool
    $c== :: FileAttributeInfoList -> FileAttributeInfoList -> Bool
    Eq)

    instance SP.ManagedPtrNewtype FileAttributeInfoList where
        toManagedPtr :: FileAttributeInfoList -> ManagedPtr FileAttributeInfoList
    toManagedPtr (FileAttributeInfoList p :: ManagedPtr FileAttributeInfoList
    p) = ManagedPtr FileAttributeInfoList
    p

    foreign import ccall "g_file_attribute_info_list_get_type" c_g_file_attribute_info_list_get_type ::
        IO GType

    type instance O.ParentTypes FileAttributeInfoList = '[]
    instance O.HasParentTypes FileAttributeInfoList

    instance B.Types.TypedObject FileAttributeInfoList where
        glibType :: IO GType
    glibType = IO GType
    c_g_file_attribute_info_list_get_type

    instance B.Types.GBoxed FileAttributeInfoList

    -- | Convert 'FileAttributeInfoList' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue FileAttributeInfoList where
        toGValue :: FileAttributeInfoList -> IO GValue
    toGValue o :: FileAttributeInfoList
    o = do
            GType
    gtype <- IO GType
    c_g_file_attribute_info_list_get_type
            FileAttributeInfoList
    -> (Ptr FileAttributeInfoList -> IO GValue) -> IO GValue
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr FileAttributeInfoList
    o (GType
    -> (GValue -> Ptr FileAttributeInfoList -> IO ())
    -> Ptr FileAttributeInfoList
    -> IO GValue
    forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
    B.GValue.buildGValue GType
    gtype GValue -> Ptr FileAttributeInfoList -> IO ()
    forall a. GValue -> Ptr a -> IO ()
    B.GValue.set_boxed)

        fromGValue :: GValue -> IO FileAttributeInfoList
    fromGValue gv :: GValue
    gv = do
            Ptr FileAttributeInfoList
    ptr <- GValue -> IO (Ptr FileAttributeInfoList)
    forall b. GValue -> IO (Ptr b)
    B.GValue.get_boxed GValue
    gv :: IO (Ptr FileAttributeInfoList)
            (ManagedPtr FileAttributeInfoList -> FileAttributeInfoList)
    -> Ptr FileAttributeInfoList -> IO FileAttributeInfoList
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    B.ManagedPtr.newBoxed ManagedPtr FileAttributeInfoList -> FileAttributeInfoList
    FileAttributeInfoList Ptr FileAttributeInfoList
    ptr

    -- | Construct a `FileAttributeInfoList` struct initialized to zero.
    newZeroFileAttributeInfoList :: MonadIO m => m FileAttributeInfoList
    newZeroFileAttributeInfoList :: m FileAttributeInfoList
    newZeroFileAttributeInfoList = IO FileAttributeInfoList -> m FileAttributeInfoList
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO FileAttributeInfoList -> m FileAttributeInfoList)
    -> IO FileAttributeInfoList -> m FileAttributeInfoList
    forall a b. (a -> b) -> a -> b
    $ Int -> IO (Ptr FileAttributeInfoList)
    forall a. GBoxed a => Int -> IO (Ptr a)
    callocBoxedBytes 16 IO (Ptr FileAttributeInfoList)
    -> (Ptr FileAttributeInfoList -> IO FileAttributeInfoList)
    -> IO FileAttributeInfoList
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (ManagedPtr FileAttributeInfoList -> FileAttributeInfoList)
    -> Ptr FileAttributeInfoList -> IO FileAttributeInfoList
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr FileAttributeInfoList -> FileAttributeInfoList
    FileAttributeInfoList

    instance tag ~ 'AttrSet => Constructible FileAttributeInfoList tag where
        new :: (ManagedPtr FileAttributeInfoList -> FileAttributeInfoList)
    -> [AttrOp FileAttributeInfoList tag] -> m FileAttributeInfoList
    new _ attrs :: [AttrOp FileAttributeInfoList tag]
    attrs = do
            FileAttributeInfoList
    o <- m FileAttributeInfoList
    forall (m :: * -> *). MonadIO m => m FileAttributeInfoList
    newZeroFileAttributeInfoList
            FileAttributeInfoList
    -> [AttrOp FileAttributeInfoList 'AttrSet] -> m ()
    forall o (m :: * -> *).
    MonadIO m =>
    o -> [AttrOp o 'AttrSet] -> m ()
    GI.Attributes.set FileAttributeInfoList
    o [AttrOp FileAttributeInfoList tag]
    [AttrOp FileAttributeInfoList 'AttrSet]
    attrs
            FileAttributeInfoList -> m FileAttributeInfoList
    forall (m :: * -> *) a. Monad m => a -> m a
    return FileAttributeInfoList
    o

    -- | Get the value of the “@infos@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' fileAttributeInfoList #infos
    -- @
    getFileAttributeInfoListInfos :: MonadIO m => FileAttributeInfoList -> m (Maybe Gio.FileAttributeInfo.FileAttributeInfo)
    getFileAttributeInfoListInfos :: FileAttributeInfoList -> m (Maybe FileAttributeInfo)
    getFileAttributeInfoListInfos s :: FileAttributeInfoList
    s = IO (Maybe FileAttributeInfo) -> m (Maybe FileAttributeInfo)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe FileAttributeInfo) -> m (Maybe FileAttributeInfo))
    -> IO (Maybe FileAttributeInfo) -> m (Maybe FileAttributeInfo)
    forall a b. (a -> b) -> a -> b
    $ FileAttributeInfoList
    -> (Ptr FileAttributeInfoList -> IO (Maybe FileAttributeInfo))
    -> IO (Maybe FileAttributeInfo)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr FileAttributeInfoList
    s ((Ptr FileAttributeInfoList -> IO (Maybe FileAttributeInfo))
     -> IO (Maybe FileAttributeInfo))
    -> (Ptr FileAttributeInfoList -> IO (Maybe FileAttributeInfo))
    -> IO (Maybe FileAttributeInfo)
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr FileAttributeInfoList
    ptr -> do
        Ptr FileAttributeInfo
    val <- Ptr (Ptr FileAttributeInfo) -> IO (Ptr FileAttributeInfo)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr FileAttributeInfoList
    ptr Ptr FileAttributeInfoList -> Int -> Ptr (Ptr FileAttributeInfo)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) :: IO (Ptr Gio.FileAttributeInfo.FileAttributeInfo)
        Maybe FileAttributeInfo
    result <- Ptr FileAttributeInfo
    -> (Ptr FileAttributeInfo -> IO FileAttributeInfo)
    -> IO (Maybe FileAttributeInfo)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    SP.convertIfNonNull Ptr FileAttributeInfo
    val ((Ptr FileAttributeInfo -> IO FileAttributeInfo)
     -> IO (Maybe FileAttributeInfo))
    -> (Ptr FileAttributeInfo -> IO FileAttributeInfo)
    -> IO (Maybe FileAttributeInfo)
    forall a b. (a -> b) -> a -> b
    $ \val' :: Ptr FileAttributeInfo
    val' -> do
            FileAttributeInfo
    val'' <- ((ManagedPtr FileAttributeInfo -> FileAttributeInfo)
    -> Ptr FileAttributeInfo -> IO FileAttributeInfo
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr FileAttributeInfo -> FileAttributeInfo
    Gio.FileAttributeInfo.FileAttributeInfo) Ptr FileAttributeInfo
    val'
            FileAttributeInfo -> IO FileAttributeInfo
    forall (m :: * -> *) a. Monad m => a -> m a
    return FileAttributeInfo
    val''
        Maybe FileAttributeInfo -> IO (Maybe FileAttributeInfo)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe FileAttributeInfo
    result

    -- | Set the value of the “@infos@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' fileAttributeInfoList [ #infos 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setFileAttributeInfoListInfos :: MonadIO m => FileAttributeInfoList -> Ptr Gio.FileAttributeInfo.FileAttributeInfo -> m ()
    setFileAttributeInfoListInfos :: FileAttributeInfoList -> Ptr FileAttributeInfo -> m ()
    setFileAttributeInfoListInfos s :: FileAttributeInfoList
    s val :: Ptr FileAttributeInfo
    val = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FileAttributeInfoList
    -> (Ptr FileAttributeInfoList -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr FileAttributeInfoList
    s ((Ptr FileAttributeInfoList -> IO ()) -> IO ())
    -> (Ptr FileAttributeInfoList -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr FileAttributeInfoList
    ptr -> do
        Ptr (Ptr FileAttributeInfo) -> Ptr FileAttributeInfo -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr FileAttributeInfoList
    ptr Ptr FileAttributeInfoList -> Int -> Ptr (Ptr FileAttributeInfo)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) (Ptr FileAttributeInfo
    val :: Ptr Gio.FileAttributeInfo.FileAttributeInfo)

    -- | Set the value of the “@infos@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #infos
    -- @
    clearFileAttributeInfoListInfos :: MonadIO m => FileAttributeInfoList -> m ()
    clearFileAttributeInfoListInfos :: FileAttributeInfoList -> m ()
    clearFileAttributeInfoListInfos s :: FileAttributeInfoList
    s = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FileAttributeInfoList
    -> (Ptr FileAttributeInfoList -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr FileAttributeInfoList
    s ((Ptr FileAttributeInfoList -> IO ()) -> IO ())
    -> (Ptr FileAttributeInfoList -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr FileAttributeInfoList
    ptr -> do
        Ptr (Ptr FileAttributeInfo) -> Ptr FileAttributeInfo -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr FileAttributeInfoList
    ptr Ptr FileAttributeInfoList -> Int -> Ptr (Ptr FileAttributeInfo)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) (Ptr FileAttributeInfo
    forall a. Ptr a
    FP.nullPtr :: Ptr Gio.FileAttributeInfo.FileAttributeInfo)

    #if defined(ENABLE_OVERLOADING)
    data FileAttributeInfoListInfosFieldInfo
    instance AttrInfo FileAttributeInfoListInfosFieldInfo where
        type AttrBaseTypeConstraint FileAttributeInfoListInfosFieldInfo = (~) FileAttributeInfoList
        type AttrAllowedOps FileAttributeInfoListInfosFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint FileAttributeInfoListInfosFieldInfo = (~) (Ptr Gio.FileAttributeInfo.FileAttributeInfo)
        type AttrTransferTypeConstraint FileAttributeInfoListInfosFieldInfo = (~)(Ptr Gio.FileAttributeInfo.FileAttributeInfo)
        type AttrTransferType FileAttributeInfoListInfosFieldInfo = (Ptr Gio.FileAttributeInfo.FileAttributeInfo)
        type AttrGetType FileAttributeInfoListInfosFieldInfo = Maybe Gio.FileAttributeInfo.FileAttributeInfo
        type AttrLabel FileAttributeInfoListInfosFieldInfo = "infos"
        type AttrOrigin FileAttributeInfoListInfosFieldInfo = FileAttributeInfoList
        attrGet = getFileAttributeInfoListInfos
        attrSet = setFileAttributeInfoListInfos
        attrConstruct = undefined
        attrClear = clearFileAttributeInfoListInfos
        attrTransfer _ v = do
            return v

    fileAttributeInfoList_infos :: AttrLabelProxy "infos"
    fileAttributeInfoList_infos = AttrLabelProxy

    #endif

    -- | Get the value of the “@n_infos@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' fileAttributeInfoList #nInfos
    -- @
    getFileAttributeInfoListNInfos :: MonadIO m => FileAttributeInfoList -> m Int32
    getFileAttributeInfoListNInfos :: FileAttributeInfoList -> m Int32
    getFileAttributeInfoListNInfos s :: FileAttributeInfoList
    s = IO Int32 -> m Int32
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ FileAttributeInfoList
    -> (Ptr FileAttributeInfoList -> IO Int32) -> IO Int32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr FileAttributeInfoList
    s ((Ptr FileAttributeInfoList -> IO Int32) -> IO Int32)
    -> (Ptr FileAttributeInfoList -> IO Int32) -> IO Int32
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr FileAttributeInfoList
    ptr -> do
        Int32
    val <- Ptr Int32 -> IO Int32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr FileAttributeInfoList
    ptr Ptr FileAttributeInfoList -> Int -> Ptr Int32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 8) :: IO Int32
        Int32 -> IO Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int32
    val

    -- | Set the value of the “@n_infos@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' fileAttributeInfoList [ #nInfos 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setFileAttributeInfoListNInfos :: MonadIO m => FileAttributeInfoList -> Int32 -> m ()
    setFileAttributeInfoListNInfos :: FileAttributeInfoList -> Int32 -> m ()
    setFileAttributeInfoListNInfos s :: FileAttributeInfoList
    s val :: Int32
    val = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FileAttributeInfoList
    -> (Ptr FileAttributeInfoList -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr FileAttributeInfoList
    s ((Ptr FileAttributeInfoList -> IO ()) -> IO ())
    -> (Ptr FileAttributeInfoList -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr FileAttributeInfoList
    ptr -> do
        Ptr Int32 -> Int32 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr FileAttributeInfoList
    ptr Ptr FileAttributeInfoList -> Int -> Ptr Int32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 8) (Int32
    val :: Int32)

    #if defined(ENABLE_OVERLOADING)
    data FileAttributeInfoListNInfosFieldInfo
    instance AttrInfo FileAttributeInfoListNInfosFieldInfo where
        type AttrBaseTypeConstraint FileAttributeInfoListNInfosFieldInfo = (~) FileAttributeInfoList
        type AttrAllowedOps FileAttributeInfoListNInfosFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint FileAttributeInfoListNInfosFieldInfo = (~) Int32
        type AttrTransferTypeConstraint FileAttributeInfoListNInfosFieldInfo = (~)Int32
        type AttrTransferType FileAttributeInfoListNInfosFieldInfo = Int32
        type AttrGetType FileAttributeInfoListNInfosFieldInfo = Int32
        type AttrLabel FileAttributeInfoListNInfosFieldInfo = "n_infos"
        type AttrOrigin FileAttributeInfoListNInfosFieldInfo = FileAttributeInfoList
        attrGet = getFileAttributeInfoListNInfos
        attrSet = setFileAttributeInfoListNInfos
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v

    fileAttributeInfoList_nInfos :: AttrLabelProxy "nInfos"
    fileAttributeInfoList_nInfos = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList FileAttributeInfoList
    type instance O.AttributeList FileAttributeInfoList = FileAttributeInfoListAttributeList
    type FileAttributeInfoListAttributeList = ('[ '("infos", FileAttributeInfoListInfosFieldInfo), '("nInfos", FileAttributeInfoListNInfosFieldInfo)] :: [(Symbol, *)])
    #endif

    -- method FileAttributeInfoList::new
    -- method type : Constructor
    -- Args: []
    -- Lengths: []
    -- returnType: Just
    --               (TInterface
    --                  Name { namespace = "Gio" , name = "FileAttributeInfoList" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_file_attribute_info_list_new" g_file_attribute_info_list_new ::
        IO (Ptr FileAttributeInfoList)

    -- | Creates a new file attribute info list.
    fileAttributeInfoListNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m FileAttributeInfoList
        -- ^ __Returns:__ a t'GI.Gio.Structs.FileAttributeInfoList.FileAttributeInfoList'.
    fileAttributeInfoListNew :: m FileAttributeInfoList
    fileAttributeInfoListNew  = IO FileAttributeInfoList -> m FileAttributeInfoList
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO FileAttributeInfoList -> m FileAttributeInfoList)
    -> IO FileAttributeInfoList -> m FileAttributeInfoList
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr FileAttributeInfoList
    result <- IO (Ptr FileAttributeInfoList)
    g_file_attribute_info_list_new
        Text -> Ptr FileAttributeInfoList -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "fileAttributeInfoListNew" Ptr FileAttributeInfoList
    result
        FileAttributeInfoList
    result' <- ((ManagedPtr FileAttributeInfoList -> FileAttributeInfoList)
    -> Ptr FileAttributeInfoList -> IO FileAttributeInfoList
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr FileAttributeInfoList -> FileAttributeInfoList
    FileAttributeInfoList) Ptr FileAttributeInfoList
    result
        FileAttributeInfoList -> IO FileAttributeInfoList
    forall (m :: * -> *) a. Monad m => a -> m a
    return FileAttributeInfoList
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method FileAttributeInfoList::add
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "list"
    --           , argType =
    --               TInterface
    --                 Name { namespace = "Gio" , name = "FileAttributeInfoList" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GFileAttributeInfoList."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "name"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the attribute to add."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "type"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "FileAttributeType" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #GFileAttributeType for the attribute."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType =
    --               TInterface
    --                 Name { namespace = "Gio" , name = "FileAttributeInfoFlags" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "#GFileAttributeInfoFlags for the attribute."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_file_attribute_info_list_add" g_file_attribute_info_list_add ::
        Ptr FileAttributeInfoList ->            -- list : TInterface (Name {namespace = "Gio", name = "FileAttributeInfoList"})
        CString ->                              -- name : TBasicType TUTF8
        CUInt ->                                -- type : TInterface (Name {namespace = "Gio", name = "FileAttributeType"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "FileAttributeInfoFlags"})
        IO ()

    -- | Adds a new attribute with /@name@/ to the /@list@/, setting
    -- its /@type@/ and /@flags@/.
    fileAttributeInfoListAdd ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        FileAttributeInfoList
        -- ^ /@list@/: a t'GI.Gio.Structs.FileAttributeInfoList.FileAttributeInfoList'.
        -> T.Text
        -- ^ /@name@/: the name of the attribute to add.
        -> Gio.Enums.FileAttributeType
        -- ^ /@type@/: the t'GI.Gio.Enums.FileAttributeType' for the attribute.
        -> [Gio.Flags.FileAttributeInfoFlags]
        -- ^ /@flags@/: t'GI.Gio.Flags.FileAttributeInfoFlags' for the attribute.
        -> m ()
    fileAttributeInfoListAdd :: FileAttributeInfoList
    -> Text -> FileAttributeType -> [FileAttributeInfoFlags] -> m ()
    fileAttributeInfoListAdd list :: FileAttributeInfoList
    list name :: Text
    name type_ :: FileAttributeType
    type_ flags :: [FileAttributeInfoFlags]
    flags = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr FileAttributeInfoList
    list' <- FileAttributeInfoList -> IO (Ptr FileAttributeInfoList)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr FileAttributeInfoList
    list
        CString
    name' <- Text -> IO CString
    textToCString Text
    name
        let type_' :: CUInt
    type_' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt)
    -> (FileAttributeType -> Int) -> FileAttributeType -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FileAttributeType -> Int
    forall a. Enum a => a -> Int
    fromEnum) FileAttributeType
    type_
        let flags' :: CUInt
    flags' = [FileAttributeInfoFlags] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [FileAttributeInfoFlags]
    flags
        Ptr FileAttributeInfoList -> CString -> CUInt -> CUInt -> IO ()
    g_file_attribute_info_list_add Ptr FileAttributeInfoList
    list' CString
    name' CUInt
    type_' CUInt
    flags'
        FileAttributeInfoList -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr FileAttributeInfoList
    list
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    name'
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data FileAttributeInfoListAddMethodInfo
    instance (signature ~ (T.Text -> Gio.Enums.FileAttributeType -> [Gio.Flags.FileAttributeInfoFlags] -> m ()), MonadIO m) => O.MethodInfo FileAttributeInfoListAddMethodInfo FileAttributeInfoList signature where
        overloadedMethod = fileAttributeInfoListAdd

    #endif

    -- method FileAttributeInfoList::dup
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "list"
    --           , argType =
    --               TInterface
    --                 Name { namespace = "Gio" , name = "FileAttributeInfoList" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GFileAttributeInfoList to duplicate."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface
    --                  Name { namespace = "Gio" , name = "FileAttributeInfoList" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_file_attribute_info_list_dup" g_file_attribute_info_list_dup ::
        Ptr FileAttributeInfoList ->            -- list : TInterface (Name {namespace = "Gio", name = "FileAttributeInfoList"})
        IO (Ptr FileAttributeInfoList)

    -- | Makes a duplicate of a file attribute info list.
    fileAttributeInfoListDup ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        FileAttributeInfoList
        -- ^ /@list@/: a t'GI.Gio.Structs.FileAttributeInfoList.FileAttributeInfoList' to duplicate.
        -> m FileAttributeInfoList
        -- ^ __Returns:__ a copy of the given /@list@/.
    fileAttributeInfoListDup :: FileAttributeInfoList -> m FileAttributeInfoList
    fileAttributeInfoListDup list :: FileAttributeInfoList
    list = IO FileAttributeInfoList -> m FileAttributeInfoList
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO FileAttributeInfoList -> m FileAttributeInfoList)
    -> IO FileAttributeInfoList -> m FileAttributeInfoList
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr FileAttributeInfoList
    list' <- FileAttributeInfoList -> IO (Ptr FileAttributeInfoList)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr FileAttributeInfoList
    list
        Ptr FileAttributeInfoList
    result <- Ptr FileAttributeInfoList -> IO (Ptr FileAttributeInfoList)
    g_file_attribute_info_list_dup Ptr FileAttributeInfoList
    list'
        Text -> Ptr FileAttributeInfoList -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "fileAttributeInfoListDup" Ptr FileAttributeInfoList
    result
        FileAttributeInfoList
    result' <- ((ManagedPtr FileAttributeInfoList -> FileAttributeInfoList)
    -> Ptr FileAttributeInfoList -> IO FileAttributeInfoList
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr FileAttributeInfoList -> FileAttributeInfoList
    FileAttributeInfoList) Ptr FileAttributeInfoList
    result
        FileAttributeInfoList -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr FileAttributeInfoList
    list
        FileAttributeInfoList -> IO FileAttributeInfoList
    forall (m :: * -> *) a. Monad m => a -> m a
    return FileAttributeInfoList
    result'

    #if defined(ENABLE_OVERLOADING)
    data FileAttributeInfoListDupMethodInfo
    instance (signature ~ (m FileAttributeInfoList), MonadIO m) => O.MethodInfo FileAttributeInfoListDupMethodInfo FileAttributeInfoList signature where
        overloadedMethod = fileAttributeInfoListDup

    #endif

    -- method FileAttributeInfoList::lookup
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "list"
    --           , argType =
    --               TInterface
    --                 Name { namespace = "Gio" , name = "FileAttributeInfoList" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GFileAttributeInfoList."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "name"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the name of the attribute to look up."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface
    --                  Name { namespace = "Gio" , name = "FileAttributeInfo" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_file_attribute_info_list_lookup" g_file_attribute_info_list_lookup ::
        Ptr FileAttributeInfoList ->            -- list : TInterface (Name {namespace = "Gio", name = "FileAttributeInfoList"})
        CString ->                              -- name : TBasicType TUTF8
        IO (Ptr Gio.FileAttributeInfo.FileAttributeInfo)

    -- | Gets the file attribute with the name /@name@/ from /@list@/.
    fileAttributeInfoListLookup ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        FileAttributeInfoList
        -- ^ /@list@/: a t'GI.Gio.Structs.FileAttributeInfoList.FileAttributeInfoList'.
        -> T.Text
        -- ^ /@name@/: the name of the attribute to look up.
        -> m Gio.FileAttributeInfo.FileAttributeInfo
        -- ^ __Returns:__ a t'GI.Gio.Structs.FileAttributeInfo.FileAttributeInfo' for the /@name@/, or 'P.Nothing' if an
        -- attribute isn\'t found.
    fileAttributeInfoListLookup :: FileAttributeInfoList -> Text -> m FileAttributeInfo
    fileAttributeInfoListLookup list :: FileAttributeInfoList
    list name :: Text
    name = IO FileAttributeInfo -> m FileAttributeInfo
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO FileAttributeInfo -> m FileAttributeInfo)
    -> IO FileAttributeInfo -> m FileAttributeInfo
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr FileAttributeInfoList
    list' <- FileAttributeInfoList -> IO (Ptr FileAttributeInfoList)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr FileAttributeInfoList
    list
        CString
    name' <- Text -> IO CString
    textToCString Text
    name
        Ptr FileAttributeInfo
    result <- Ptr FileAttributeInfoList -> CString -> IO (Ptr FileAttributeInfo)
    g_file_attribute_info_list_lookup Ptr FileAttributeInfoList
    list' CString
    name'
        Text -> Ptr FileAttributeInfo -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "fileAttributeInfoListLookup" Ptr FileAttributeInfo
    result
        FileAttributeInfo
    result' <- ((ManagedPtr FileAttributeInfo -> FileAttributeInfo)
    -> Ptr FileAttributeInfo -> IO FileAttributeInfo
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr FileAttributeInfo -> FileAttributeInfo
    Gio.FileAttributeInfo.FileAttributeInfo) Ptr FileAttributeInfo
    result
        FileAttributeInfoList -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr FileAttributeInfoList
    list
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    name'
        FileAttributeInfo -> IO FileAttributeInfo
    forall (m :: * -> *) a. Monad m => a -> m a
    return FileAttributeInfo
    result'

    #if defined(ENABLE_OVERLOADING)
    data FileAttributeInfoListLookupMethodInfo
    instance (signature ~ (T.Text -> m Gio.FileAttributeInfo.FileAttributeInfo), MonadIO m) => O.MethodInfo FileAttributeInfoListLookupMethodInfo FileAttributeInfoList signature where
        overloadedMethod = fileAttributeInfoListLookup

    #endif

    -- method FileAttributeInfoList::ref
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "list"
    --           , argType =
    --               TInterface
    --                 Name { namespace = "Gio" , name = "FileAttributeInfoList" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GFileAttributeInfoList to reference."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface
    --                  Name { namespace = "Gio" , name = "FileAttributeInfoList" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_file_attribute_info_list_ref" g_file_attribute_info_list_ref ::
        Ptr FileAttributeInfoList ->            -- list : TInterface (Name {namespace = "Gio", name = "FileAttributeInfoList"})
        IO (Ptr FileAttributeInfoList)

    -- | References a file attribute info list.
    fileAttributeInfoListRef ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        FileAttributeInfoList
        -- ^ /@list@/: a t'GI.Gio.Structs.FileAttributeInfoList.FileAttributeInfoList' to reference.
        -> m FileAttributeInfoList
        -- ^ __Returns:__ t'GI.Gio.Structs.FileAttributeInfoList.FileAttributeInfoList' or 'P.Nothing' on error.
    fileAttributeInfoListRef :: FileAttributeInfoList -> m FileAttributeInfoList
    fileAttributeInfoListRef list :: FileAttributeInfoList
    list = IO FileAttributeInfoList -> m FileAttributeInfoList
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO FileAttributeInfoList -> m FileAttributeInfoList)
    -> IO FileAttributeInfoList -> m FileAttributeInfoList
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr FileAttributeInfoList
    list' <- FileAttributeInfoList -> IO (Ptr FileAttributeInfoList)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr FileAttributeInfoList
    list
        Ptr FileAttributeInfoList
    result <- Ptr FileAttributeInfoList -> IO (Ptr FileAttributeInfoList)
    g_file_attribute_info_list_ref Ptr FileAttributeInfoList
    list'
        Text -> Ptr FileAttributeInfoList -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "fileAttributeInfoListRef" Ptr FileAttributeInfoList
    result
        FileAttributeInfoList
    result' <- ((ManagedPtr FileAttributeInfoList -> FileAttributeInfoList)
    -> Ptr FileAttributeInfoList -> IO FileAttributeInfoList
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr FileAttributeInfoList -> FileAttributeInfoList
    FileAttributeInfoList) Ptr FileAttributeInfoList
    result
        FileAttributeInfoList -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr FileAttributeInfoList
    list
        FileAttributeInfoList -> IO FileAttributeInfoList
    forall (m :: * -> *) a. Monad m => a -> m a
    return FileAttributeInfoList
    result'

    #if defined(ENABLE_OVERLOADING)
    data FileAttributeInfoListRefMethodInfo
    instance (signature ~ (m FileAttributeInfoList), MonadIO m) => O.MethodInfo FileAttributeInfoListRefMethodInfo FileAttributeInfoList signature where
        overloadedMethod = fileAttributeInfoListRef

    #endif

    -- method FileAttributeInfoList::unref
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "list"
    --           , argType =
    --               TInterface
    --                 Name { namespace = "Gio" , name = "FileAttributeInfoList" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The #GFileAttributeInfoList to unreference."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_file_attribute_info_list_unref" g_file_attribute_info_list_unref ::
        Ptr FileAttributeInfoList ->            -- list : TInterface (Name {namespace = "Gio", name = "FileAttributeInfoList"})
        IO ()

    -- | Removes a reference from the given /@list@/. If the reference count
    -- falls to zero, the /@list@/ is deleted.
    fileAttributeInfoListUnref ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        FileAttributeInfoList
        -- ^ /@list@/: The t'GI.Gio.Structs.FileAttributeInfoList.FileAttributeInfoList' to unreference.
        -> m ()
    fileAttributeInfoListUnref :: FileAttributeInfoList -> m ()
    fileAttributeInfoListUnref list :: FileAttributeInfoList
    list = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr FileAttributeInfoList
    list' <- FileAttributeInfoList -> IO (Ptr FileAttributeInfoList)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr FileAttributeInfoList
    list
        Ptr FileAttributeInfoList -> IO ()
    g_file_attribute_info_list_unref Ptr FileAttributeInfoList
    list'
        FileAttributeInfoList -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr FileAttributeInfoList
    list
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data FileAttributeInfoListUnrefMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.MethodInfo FileAttributeInfoListUnrefMethodInfo FileAttributeInfoList signature where
        overloadedMethod = fileAttributeInfoListUnref

    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveFileAttributeInfoListMethod (t :: Symbol) (o :: *) :: * where
        ResolveFileAttributeInfoListMethod "add" o = FileAttributeInfoListAddMethodInfo
        ResolveFileAttributeInfoListMethod "dup" o = FileAttributeInfoListDupMethodInfo
        ResolveFileAttributeInfoListMethod "lookup" o = FileAttributeInfoListLookupMethodInfo
        ResolveFileAttributeInfoListMethod "ref" o = FileAttributeInfoListRefMethodInfo
        ResolveFileAttributeInfoListMethod "unref" o = FileAttributeInfoListUnrefMethodInfo
        ResolveFileAttributeInfoListMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveFileAttributeInfoListMethod t FileAttributeInfoList, O.MethodInfo info FileAttributeInfoList p) => OL.IsLabel t (FileAttributeInfoList -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod @info
    #else
        fromLabel _ = O.overloadedMethod @info
    #endif

    #endif