{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- IBusXML lists data structure and handling function for XML in IBus.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.IBus.Structs.XML
    ( 

-- * Exported types
    XML(..)                                 ,
    newZeroXML                              ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [copy]("GI.IBus.Structs.XML#g:method:copy"), [free]("GI.IBus.Structs.XML#g:method:free"), [output]("GI.IBus.Structs.XML#g:method:output").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveXMLMethod                        ,
#endif

-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    XMLCopyMethodInfo                       ,
#endif
    xMLCopy                                 ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    XMLFreeMethodInfo                       ,
#endif
    xMLFree                                 ,


-- ** output #method:output#

#if defined(ENABLE_OVERLOADING)
    XMLOutputMethodInfo                     ,
#endif
    xMLOutput                               ,


-- ** parseBuffer #method:parseBuffer#

    xMLParseBuffer                          ,


-- ** parseFile #method:parseFile#

    xMLParseFile                            ,




 -- * Properties


-- ** attributes #attr:attributes#
-- | Attributes of the XML node.

    clearXMLAttributes                      ,
    getXMLAttributes                        ,
    setXMLAttributes                        ,
#if defined(ENABLE_OVERLOADING)
    xML_attributes                          ,
#endif


-- ** name #attr:name#
-- | Name of XML tag.

    clearXMLName                            ,
    getXMLName                              ,
    setXMLName                              ,
#if defined(ENABLE_OVERLOADING)
    xML_name                                ,
#endif


-- ** subNodes #attr:subNodes#
-- | Children node of this XML node.

    clearXMLSubNodes                        ,
    getXMLSubNodes                          ,
    setXMLSubNodes                          ,
#if defined(ENABLE_OVERLOADING)
    xML_subNodes                            ,
#endif


-- ** text #attr:text#
-- | Text enclosed by XML start tag and end tag. i.e. \<tag>text\<\/tag>.

    clearXMLText                            ,
    getXMLText                              ,
    setXMLText                              ,
#if defined(ENABLE_OVERLOADING)
    xML_text                                ,
#endif




    ) 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 qualified GHC.Records as R

import qualified GI.GLib.Structs.String as GLib.String

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

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

foreign import ccall "ibus_xml_get_type" c_ibus_xml_get_type :: 
    IO GType

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

instance B.Types.TypedObject XML where
    glibType :: IO GType
glibType = IO GType
c_ibus_xml_get_type

instance B.Types.GBoxed XML

-- | Convert 'XML' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe XML) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ibus_xml_get_type
    gvalueSet_ :: Ptr GValue -> Maybe XML -> IO ()
gvalueSet_ Ptr GValue
gv Maybe XML
P.Nothing = Ptr GValue -> Ptr XML -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr XML
forall a. Ptr a
FP.nullPtr :: FP.Ptr XML)
    gvalueSet_ Ptr GValue
gv (P.Just XML
obj) = XML -> (Ptr XML -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr XML
obj (Ptr GValue -> Ptr XML -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe XML)
gvalueGet_ Ptr GValue
gv = do
        Ptr XML
ptr <- Ptr GValue -> IO (Ptr XML)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr XML)
        if Ptr XML
ptr Ptr XML -> Ptr XML -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr XML
forall a. Ptr a
FP.nullPtr
        then XML -> Maybe XML
forall a. a -> Maybe a
P.Just (XML -> Maybe XML) -> IO XML -> IO (Maybe XML)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr XML -> XML) -> Ptr XML -> IO XML
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr XML -> XML
XML Ptr XML
ptr
        else Maybe XML -> IO (Maybe XML)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe XML
forall a. Maybe a
P.Nothing
        
    

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

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


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

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

-- | Set the value of the “@name@” 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' #name
-- @
clearXMLName :: MonadIO m => XML -> m ()
clearXMLName :: forall (m :: * -> *). MonadIO m => XML -> m ()
clearXMLName XML
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ XML -> (Ptr XML -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr XML
s ((Ptr XML -> IO ()) -> IO ()) -> (Ptr XML -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr XML
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr XML
ptr Ptr XML -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data XMLNameFieldInfo
instance AttrInfo XMLNameFieldInfo where
    type AttrBaseTypeConstraint XMLNameFieldInfo = (~) XML
    type AttrAllowedOps XMLNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint XMLNameFieldInfo = (~) CString
    type AttrTransferTypeConstraint XMLNameFieldInfo = (~)CString
    type AttrTransferType XMLNameFieldInfo = CString
    type AttrGetType XMLNameFieldInfo = Maybe T.Text
    type AttrLabel XMLNameFieldInfo = "name"
    type AttrOrigin XMLNameFieldInfo = XML
    attrGet = getXMLName
    attrSet = setXMLName
    attrConstruct = undefined
    attrClear = clearXMLName
    attrTransfer _ v = do
        return v

xML_name :: AttrLabelProxy "name"
xML_name = AttrLabelProxy

#endif


-- | Get the value of the “@text@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' xML #text
-- @
getXMLText :: MonadIO m => XML -> m (Maybe T.Text)
getXMLText :: forall (m :: * -> *). MonadIO m => XML -> m (Maybe Text)
getXMLText XML
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ XML -> (Ptr XML -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr XML
s ((Ptr XML -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr XML -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr XML
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr XML
ptr Ptr XML -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CString
    Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
        Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result

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

-- | Set the value of the “@text@” 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' #text
-- @
clearXMLText :: MonadIO m => XML -> m ()
clearXMLText :: forall (m :: * -> *). MonadIO m => XML -> m ()
clearXMLText XML
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ XML -> (Ptr XML -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr XML
s ((Ptr XML -> IO ()) -> IO ()) -> (Ptr XML -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr XML
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr XML
ptr Ptr XML -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CString
forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data XMLTextFieldInfo
instance AttrInfo XMLTextFieldInfo where
    type AttrBaseTypeConstraint XMLTextFieldInfo = (~) XML
    type AttrAllowedOps XMLTextFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint XMLTextFieldInfo = (~) CString
    type AttrTransferTypeConstraint XMLTextFieldInfo = (~)CString
    type AttrTransferType XMLTextFieldInfo = CString
    type AttrGetType XMLTextFieldInfo = Maybe T.Text
    type AttrLabel XMLTextFieldInfo = "text"
    type AttrOrigin XMLTextFieldInfo = XML
    attrGet = getXMLText
    attrSet = setXMLText
    attrConstruct = undefined
    attrClear = clearXMLText
    attrTransfer _ v = do
        return v

xML_text :: AttrLabelProxy "text"
xML_text = AttrLabelProxy

#endif


-- | Get the value of the “@attributes@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' xML #attributes
-- @
getXMLAttributes :: MonadIO m => XML -> m (Maybe T.Text)
getXMLAttributes :: forall (m :: * -> *). MonadIO m => XML -> m (Maybe Text)
getXMLAttributes XML
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ XML -> (Ptr XML -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr XML
s ((Ptr XML -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr XML -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr XML
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr XML
ptr Ptr XML -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO CString
    Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
        Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result

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

-- | Set the value of the “@attributes@” 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' #attributes
-- @
clearXMLAttributes :: MonadIO m => XML -> m ()
clearXMLAttributes :: forall (m :: * -> *). MonadIO m => XML -> m ()
clearXMLAttributes XML
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ XML -> (Ptr XML -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr XML
s ((Ptr XML -> IO ()) -> IO ()) -> (Ptr XML -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr XML
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr XML
ptr Ptr XML -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CString
forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data XMLAttributesFieldInfo
instance AttrInfo XMLAttributesFieldInfo where
    type AttrBaseTypeConstraint XMLAttributesFieldInfo = (~) XML
    type AttrAllowedOps XMLAttributesFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint XMLAttributesFieldInfo = (~) CString
    type AttrTransferTypeConstraint XMLAttributesFieldInfo = (~)CString
    type AttrTransferType XMLAttributesFieldInfo = CString
    type AttrGetType XMLAttributesFieldInfo = Maybe T.Text
    type AttrLabel XMLAttributesFieldInfo = "attributes"
    type AttrOrigin XMLAttributesFieldInfo = XML
    attrGet = getXMLAttributes
    attrSet = setXMLAttributes
    attrConstruct = undefined
    attrClear = clearXMLAttributes
    attrTransfer _ v = do
        return v

xML_attributes :: AttrLabelProxy "attributes"
xML_attributes = AttrLabelProxy

#endif


-- | Get the value of the “@sub_nodes@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' xML #subNodes
-- @
getXMLSubNodes :: MonadIO m => XML -> m ([Ptr ()])
getXMLSubNodes :: forall (m :: * -> *). MonadIO m => XML -> m [Ptr ()]
getXMLSubNodes XML
s = IO [Ptr ()] -> m [Ptr ()]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Ptr ()] -> m [Ptr ()]) -> IO [Ptr ()] -> m [Ptr ()]
forall a b. (a -> b) -> a -> b
$ XML -> (Ptr XML -> IO [Ptr ()]) -> IO [Ptr ()]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr XML
s ((Ptr XML -> IO [Ptr ()]) -> IO [Ptr ()])
-> (Ptr XML -> IO [Ptr ()]) -> IO [Ptr ()]
forall a b. (a -> b) -> a -> b
$ \Ptr XML
ptr -> do
    Ptr (GList (Ptr ()))
val <- Ptr (Ptr (GList (Ptr ()))) -> IO (Ptr (GList (Ptr ())))
forall a. Storable a => Ptr a -> IO a
peek (Ptr XML
ptr Ptr XML -> Int -> Ptr (Ptr (GList (Ptr ())))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO (Ptr (GList (Ptr ())))
    [Ptr ()]
val' <- Ptr (GList (Ptr ())) -> IO [Ptr ()]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr ()))
val
    [Ptr ()] -> IO [Ptr ()]
forall (m :: * -> *) a. Monad m => a -> m a
return [Ptr ()]
val'

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

-- | Set the value of the “@sub_nodes@” 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' #subNodes
-- @
clearXMLSubNodes :: MonadIO m => XML -> m ()
clearXMLSubNodes :: forall (m :: * -> *). MonadIO m => XML -> m ()
clearXMLSubNodes XML
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ XML -> (Ptr XML -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr XML
s ((Ptr XML -> IO ()) -> IO ()) -> (Ptr XML -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr XML
ptr -> do
    Ptr (Ptr (GList (Ptr ()))) -> Ptr (GList (Ptr ())) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr XML
ptr Ptr XML -> Int -> Ptr (Ptr (GList (Ptr ())))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Ptr (GList (Ptr ()))
forall a. Ptr a
FP.nullPtr :: Ptr (GList (Ptr ())))

#if defined(ENABLE_OVERLOADING)
data XMLSubNodesFieldInfo
instance AttrInfo XMLSubNodesFieldInfo where
    type AttrBaseTypeConstraint XMLSubNodesFieldInfo = (~) XML
    type AttrAllowedOps XMLSubNodesFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint XMLSubNodesFieldInfo = (~) (Ptr (GList (Ptr ())))
    type AttrTransferTypeConstraint XMLSubNodesFieldInfo = (~)(Ptr (GList (Ptr ())))
    type AttrTransferType XMLSubNodesFieldInfo = (Ptr (GList (Ptr ())))
    type AttrGetType XMLSubNodesFieldInfo = [Ptr ()]
    type AttrLabel XMLSubNodesFieldInfo = "sub_nodes"
    type AttrOrigin XMLSubNodesFieldInfo = XML
    attrGet = getXMLSubNodes
    attrSet = setXMLSubNodes
    attrConstruct = undefined
    attrClear = clearXMLSubNodes
    attrTransfer _ v = do
        return v

xML_subNodes :: AttrLabelProxy "subNodes"
xML_subNodes = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList XML
type instance O.AttributeList XML = XMLAttributeList
type XMLAttributeList = ('[ '("name", XMLNameFieldInfo), '("text", XMLTextFieldInfo), '("attributes", XMLAttributesFieldInfo), '("subNodes", XMLSubNodesFieldInfo)] :: [(Symbol, *)])
#endif

-- method XML::copy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "node"
--           , argType = TInterface Name { namespace = "IBus" , name = "XML" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Root node of an XML tree."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "IBus" , name = "XML" })
-- throws : False
-- Skip return : False

foreign import ccall "ibus_xml_copy" ibus_xml_copy :: 
    Ptr XML ->                              -- node : TInterface (Name {namespace = "IBus", name = "XML"})
    IO (Ptr XML)

-- | Creates a copy of /@node@/, which should be freed with
-- 'GI.IBus.Structs.XML.xMLFree'. Primarily used by language bindings,
-- not that useful otherwise (since /@node@/ can just be copied
-- by assignment in C).
xMLCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    XML
    -- ^ /@node@/: Root node of an XML tree.
    -> m XML
    -- ^ __Returns:__ the newly allocated t'GI.IBus.Structs.XML.XML', which should
    --          be freed with 'GI.IBus.Structs.XML.xMLFree', or 'P.Nothing'
    --          if /@node@/ was 'P.Nothing'.
xMLCopy :: forall (m :: * -> *). (HasCallStack, MonadIO m) => XML -> m XML
xMLCopy XML
node = IO XML -> m XML
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO XML -> m XML) -> IO XML -> m XML
forall a b. (a -> b) -> a -> b
$ do
    Ptr XML
node' <- XML -> IO (Ptr XML)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr XML
node
    Ptr XML
result <- Ptr XML -> IO (Ptr XML)
ibus_xml_copy Ptr XML
node'
    Text -> Ptr XML -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"xMLCopy" Ptr XML
result
    XML
result' <- ((ManagedPtr XML -> XML) -> Ptr XML -> IO XML
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr XML -> XML
XML) Ptr XML
result
    XML -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr XML
node
    XML -> IO XML
forall (m :: * -> *) a. Monad m => a -> m a
return XML
result'

#if defined(ENABLE_OVERLOADING)
data XMLCopyMethodInfo
instance (signature ~ (m XML), MonadIO m) => O.OverloadedMethod XMLCopyMethodInfo XML signature where
    overloadedMethod = xMLCopy

instance O.OverloadedMethodInfo XMLCopyMethodInfo XML where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Structs.XML.xMLCopy",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Structs-XML.html#v:xMLCopy"
        }


#endif

-- method XML::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "node"
--           , argType = TInterface Name { namespace = "IBus" , name = "XML" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Root node of an XML tree."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_xml_free" ibus_xml_free :: 
    Ptr XML ->                              -- node : TInterface (Name {namespace = "IBus", name = "XML"})
    IO ()

-- | Free an XML tree.
xMLFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    XML
    -- ^ /@node@/: Root node of an XML tree.
    -> m ()
xMLFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => XML -> m ()
xMLFree XML
node = 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 XML
node' <- XML -> IO (Ptr XML)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr XML
node
    Ptr XML -> IO ()
ibus_xml_free Ptr XML
node'
    XML -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr XML
node
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data XMLFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod XMLFreeMethodInfo XML signature where
    overloadedMethod = xMLFree

instance O.OverloadedMethodInfo XMLFreeMethodInfo XML where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Structs.XML.xMLFree",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Structs-XML.html#v:xMLFree"
        }


#endif

-- method XML::output
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "node"
--           , argType = TInterface Name { namespace = "IBus" , name = "XML" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Root node of an XML tree."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "output"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "GString which stores the output."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_xml_output" ibus_xml_output :: 
    Ptr XML ->                              -- node : TInterface (Name {namespace = "IBus", name = "XML"})
    Ptr GLib.String.String ->               -- output : TInterface (Name {namespace = "GLib", name = "String"})
    IO ()

-- | Output an XML tree to a GString.
xMLOutput ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    XML
    -- ^ /@node@/: Root node of an XML tree.
    -> GLib.String.String
    -- ^ /@output@/: GString which stores the output.
    -> m ()
xMLOutput :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
XML -> String -> m ()
xMLOutput XML
node String
output = 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 XML
node' <- XML -> IO (Ptr XML)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr XML
node
    Ptr String
output' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
output
    Ptr XML -> Ptr String -> IO ()
ibus_xml_output Ptr XML
node' Ptr String
output'
    XML -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr XML
node
    String -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
output
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data XMLOutputMethodInfo
instance (signature ~ (GLib.String.String -> m ()), MonadIO m) => O.OverloadedMethod XMLOutputMethodInfo XML signature where
    overloadedMethod = xMLOutput

instance O.OverloadedMethodInfo XMLOutputMethodInfo XML where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Structs.XML.xMLOutput",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Structs-XML.html#v:xMLOutput"
        }


#endif

-- method XML::parse_buffer
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Buffer to be parsed."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "IBus" , name = "XML" })
-- throws : False
-- Skip return : False

foreign import ccall "ibus_xml_parse_buffer" ibus_xml_parse_buffer :: 
    CString ->                              -- buffer : TBasicType TUTF8
    IO (Ptr XML)

-- | Parse a string buffer which contains an XML-formatted string,
-- and return a corresponding XML tree.
xMLParseBuffer ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@buffer@/: Buffer to be parsed.
    -> m XML
    -- ^ __Returns:__ Root node of parsed XML tree.
xMLParseBuffer :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m XML
xMLParseBuffer Text
buffer = IO XML -> m XML
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO XML -> m XML) -> IO XML -> m XML
forall a b. (a -> b) -> a -> b
$ do
    CString
buffer' <- Text -> IO CString
textToCString Text
buffer
    Ptr XML
result <- CString -> IO (Ptr XML)
ibus_xml_parse_buffer CString
buffer'
    Text -> Ptr XML -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"xMLParseBuffer" Ptr XML
result
    XML
result' <- ((ManagedPtr XML -> XML) -> Ptr XML -> IO XML
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr XML -> XML
XML) Ptr XML
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
buffer'
    XML -> IO XML
forall (m :: * -> *) a. Monad m => a -> m a
return XML
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method XML::parse_file
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "File name to be parsed."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "IBus" , name = "XML" })
-- throws : False
-- Skip return : False

foreign import ccall "ibus_xml_parse_file" ibus_xml_parse_file :: 
    CString ->                              -- name : TBasicType TUTF8
    IO (Ptr XML)

-- | Parse an XML file and return a corresponding XML tree.
xMLParseFile ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@name@/: File name to be parsed.
    -> m XML
    -- ^ __Returns:__ Root node of parsed XML tree.
xMLParseFile :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m XML
xMLParseFile Text
name = IO XML -> m XML
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO XML -> m XML) -> IO XML -> m XML
forall a b. (a -> b) -> a -> b
$ do
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr XML
result <- CString -> IO (Ptr XML)
ibus_xml_parse_file CString
name'
    Text -> Ptr XML -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"xMLParseFile" Ptr XML
result
    XML
result' <- ((ManagedPtr XML -> XML) -> Ptr XML -> IO XML
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr XML -> XML
XML) Ptr XML
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    XML -> IO XML
forall (m :: * -> *) a. Monad m => a -> m a
return XML
result'

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveXMLMethod (t :: Symbol) (o :: *) :: * where
    ResolveXMLMethod "copy" o = XMLCopyMethodInfo
    ResolveXMLMethod "free" o = XMLFreeMethodInfo
    ResolveXMLMethod "output" o = XMLOutputMethodInfo
    ResolveXMLMethod l o = O.MethodResolutionFailed l o

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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveXMLMethod t XML, O.OverloadedMethod info XML p, R.HasField t XML p) => R.HasField t XML p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveXMLMethod t XML, O.OverloadedMethodInfo info XML) => OL.IsLabel t (O.MethodProxy info XML) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif