gi-girepository 1.0.16 → 1.0.18

raw patch · 27 files changed

+10142/−9 lines, 27 filesdep ~haskell-gidep ~haskell-gi-basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: haskell-gi, haskell-gi-base

API changes (from Hackage documentation)

Files

• ChangeLog.md +8/−0
• GI/GIRepository.hs +58/−0
• GI/GIRepository/Constants.hs +69/−0
• GI/GIRepository/Enums.hs +628/−0
• GI/GIRepository/Enums.hs-boot +40/−0
• GI/GIRepository/Flags.hs +215/−0
• GI/GIRepository/Flags.hs-boot +36/−0
• GI/GIRepository/Functions.hs +4961/−0
• GI/GIRepository/Objects.hs +41/−0
• GI/GIRepository/Objects/Repository.hs +1461/−0
• GI/GIRepository/Objects/Repository.hs-boot +83/−0
• GI/GIRepository/Structs.hs +47/−0
• GI/GIRepository/Structs/AttributeIter.hs +89/−0
• GI/GIRepository/Structs/AttributeIter.hs-boot +26/−0
• GI/GIRepository/Structs/BaseInfo.hs +591/−0
• GI/GIRepository/Structs/BaseInfo.hs-boot +53/−0
• GI/GIRepository/Structs/Typelib.hs +212/−0
• GI/GIRepository/Structs/Typelib.hs-boot +35/−0
• GI/GIRepository/Structs/UnresolvedInfo.hs +77/−0
• GI/GIRepository/Structs/UnresolvedInfo.hs-boot +26/−0
• GI/GIRepository/Unions.hs +41/−0
• GI/GIRepository/Unions/Argument.hs +1281/−0
• GI/GIRepository/Unions/Argument.hs-boot +26/−0
• LICENSE +14/−0
• README.md +1/−1
• gi-girepository.cabal +22/−7
• stack.yaml +1/−1

@@ -1,3 +1,11 @@+### 1.0.18+++ Update to haskell-gi(-base) 0.22++### 1.0.17+++ Update stack version to 12.10+ ### 1.0.16  + Add a missing dependency on `gi-glib`, needed for newer versions.

@@ -0,0 +1,58 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GIRepository+    (     module GI.GIRepository.Constants        ,+    module GI.GIRepository.Enums            ,+    module GI.GIRepository.Flags            ,+    module GI.GIRepository.Functions        ,+    module GI.GIRepository.Objects          ,+    module GI.GIRepository.Structs          ,+    module GI.GIRepository.Unions           ,++++    module Data.GI.Base                     ,+++    ) where++import GI.GIRepository.Constants+import GI.GIRepository.Enums+import GI.GIRepository.Flags+import GI.GIRepository.Functions+import GI.GIRepository.Objects+import GI.GIRepository.Structs+import GI.GIRepository.Unions++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.ManagedPtr as B.ManagedPtr+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.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 Data.GI.Base+

@@ -0,0 +1,69 @@+{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-}+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GIRepository.Constants+    ( +    pattern TYPE_TAG_N_TYPES                ,+    pattern MINOR_VERSION                   ,+    pattern MICRO_VERSION                   ,+    pattern MAJOR_VERSION                   ,++    ) 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.ManagedPtr as B.ManagedPtr+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.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+++{- |+TODO+-}+pattern TYPE_TAG_N_TYPES = 22 :: Int32++{- |+The minor version number of the girepository library.++/Since: 1.60/+-}+pattern MINOR_VERSION = 60 :: Int32++{- |+The micro version number of the girepository library.++/Since: 1.60/+-}+pattern MICRO_VERSION = 1 :: Int32++{- |+The major version number of the girepository library.++/Since: 1.60/+-}+pattern MAJOR_VERSION = 1 :: Int32++

@@ -0,0 +1,628 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GIRepository.Enums+    ( ++ -- * Enumerations+-- ** ArrayType #enum:ArrayType#++    ArrayType(..)                           ,+++-- ** Direction #enum:Direction#++    Direction(..)                           ,+++-- ** InfoType #enum:InfoType#++    InfoType(..)                            ,+++-- ** NvokeError #enum:NvokeError#++    NvokeError(..)                          ,+++-- ** RepositoryError #enum:RepositoryError#++    RepositoryError(..)                     ,+++-- ** ScopeType #enum:ScopeType#++    ScopeType(..)                           ,+++-- ** Transfer #enum:Transfer#++    Transfer(..)                            ,+++-- ** TypeTag #enum:TypeTag#++    TypeTag(..)                             ,+++++    ) 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.ManagedPtr as B.ManagedPtr+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.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+++-- Enum nvokeError+{- |+An error occuring while invoking a function via+@/g_function_info_invoke()/@.+-}+data NvokeError = +      NvokeErrorFailed+    {- ^+    invokation failed, unknown error.+    -}+    | NvokeErrorSymbolNotFound+    {- ^+    symbol couldn\'t be found in any of the+    libraries associated with the typelib of the function.+    -}+    | NvokeErrorArgumentMismatch+    {- ^+    the arguments provided didn\'t match+    the expected arguments for the functions type signature.+    -}+    | AnotherNvokeError Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum NvokeError where+    fromEnum NvokeErrorFailed = 0+    fromEnum NvokeErrorSymbolNotFound = 1+    fromEnum NvokeErrorArgumentMismatch = 2+    fromEnum (AnotherNvokeError k) = k++    toEnum 0 = NvokeErrorFailed+    toEnum 1 = NvokeErrorSymbolNotFound+    toEnum 2 = NvokeErrorArgumentMismatch+    toEnum k = AnotherNvokeError k++instance P.Ord NvokeError where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++-- Enum TypeTag+{- |+The type tag of a @/GITypeInfo/@.+-}+data TypeTag = +      TypeTagVoid+    {- ^+    void+    -}+    | TypeTagBoolean+    {- ^+    boolean+    -}+    | TypeTagInt8+    {- ^+    8-bit signed integer+    -}+    | TypeTagUint8+    {- ^+    8-bit unsigned integer+    -}+    | TypeTagInt16+    {- ^+    16-bit signed integer+    -}+    | TypeTagUint16+    {- ^+    16-bit unsigned integer+    -}+    | TypeTagInt32+    {- ^+    32-bit signed integer+    -}+    | TypeTagUint32+    {- ^+    32-bit unsigned integer+    -}+    | TypeTagInt64+    {- ^+    64-bit signed integer+    -}+    | TypeTagUint64+    {- ^+    64-bit unsigned integer+    -}+    | TypeTagFloat+    {- ^+    float+    -}+    | TypeTagDouble+    {- ^+    double floating point+    -}+    | TypeTagGtype+    {- ^+    a 'GType'+    -}+    | TypeTagUtf8+    {- ^+    a UTF-8 encoded string+    -}+    | TypeTagFilename+    {- ^+    a filename, encoded in the same encoding+      as the native filesystem is using.+    -}+    | TypeTagArray+    {- ^+    an array+    -}+    | TypeTagInterface+    {- ^+    an extended interface object+    -}+    | TypeTagGlist+    {- ^+    a 'GI.GLib.Structs.List.List'+    -}+    | TypeTagGslist+    {- ^+    a 'GI.GLib.Structs.SList.SList'+    -}+    | TypeTagGhash+    {- ^+    a 'GI.GLib.Structs.HashTable.HashTable'+    -}+    | TypeTagError+    {- ^+    a 'GError'+    -}+    | TypeTagUnichar+    {- ^+    Unicode character+    -}+    | AnotherTypeTag Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum TypeTag where+    fromEnum TypeTagVoid = 0+    fromEnum TypeTagBoolean = 1+    fromEnum TypeTagInt8 = 2+    fromEnum TypeTagUint8 = 3+    fromEnum TypeTagInt16 = 4+    fromEnum TypeTagUint16 = 5+    fromEnum TypeTagInt32 = 6+    fromEnum TypeTagUint32 = 7+    fromEnum TypeTagInt64 = 8+    fromEnum TypeTagUint64 = 9+    fromEnum TypeTagFloat = 10+    fromEnum TypeTagDouble = 11+    fromEnum TypeTagGtype = 12+    fromEnum TypeTagUtf8 = 13+    fromEnum TypeTagFilename = 14+    fromEnum TypeTagArray = 15+    fromEnum TypeTagInterface = 16+    fromEnum TypeTagGlist = 17+    fromEnum TypeTagGslist = 18+    fromEnum TypeTagGhash = 19+    fromEnum TypeTagError = 20+    fromEnum TypeTagUnichar = 21+    fromEnum (AnotherTypeTag k) = k++    toEnum 0 = TypeTagVoid+    toEnum 1 = TypeTagBoolean+    toEnum 2 = TypeTagInt8+    toEnum 3 = TypeTagUint8+    toEnum 4 = TypeTagInt16+    toEnum 5 = TypeTagUint16+    toEnum 6 = TypeTagInt32+    toEnum 7 = TypeTagUint32+    toEnum 8 = TypeTagInt64+    toEnum 9 = TypeTagUint64+    toEnum 10 = TypeTagFloat+    toEnum 11 = TypeTagDouble+    toEnum 12 = TypeTagGtype+    toEnum 13 = TypeTagUtf8+    toEnum 14 = TypeTagFilename+    toEnum 15 = TypeTagArray+    toEnum 16 = TypeTagInterface+    toEnum 17 = TypeTagGlist+    toEnum 18 = TypeTagGslist+    toEnum 19 = TypeTagGhash+    toEnum 20 = TypeTagError+    toEnum 21 = TypeTagUnichar+    toEnum k = AnotherTypeTag k++instance P.Ord TypeTag where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++-- Enum Transfer+{- |+The transfer is the exchange of data between two parts, from the callee to+the caller. The callee is either a function\/method\/signal or an+object\/interface where a property is defined. The caller is the side+accessing a property or calling a function.+'GI.GIRepository.Enums.Transfer' specifies who\'s responsible for freeing the resources after the+ownership transfer is complete. In case of a containing type such as a list,+an array or a hash table the container itself is specified differently from+the items within the container itself. Each container is freed differently,+check the documentation for the types themselves for information on how to+free them.+-}+data Transfer = +      TransferNothing+    {- ^+    transfer nothing from the callee (function or the type+    instance the property belongs to) to the caller. The callee retains the+    ownership of the transfer and the caller doesn\'t need to do anything to free+    up the resources of this transfer.+    -}+    | TransferContainer+    {- ^+    transfer the container (list, array, hash table) from+    the callee to the caller. The callee retains the ownership of the individual+    items in the container and the caller has to free up the container resources+    (@/g_list_free()/@\/'GI.GLib.Functions.hashTableDestroy' etc) of this transfer.+    -}+    | TransferEverything+    {- ^+    transfer everything, eg the container and its+    contents from the callee to the caller. This is the case when the callee+    creates a copy of all the data it returns. The caller is responsible for+    cleaning up the container and item resources of this transfer.+    -}+    | AnotherTransfer Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum Transfer where+    fromEnum TransferNothing = 0+    fromEnum TransferContainer = 1+    fromEnum TransferEverything = 2+    fromEnum (AnotherTransfer k) = k++    toEnum 0 = TransferNothing+    toEnum 1 = TransferContainer+    toEnum 2 = TransferEverything+    toEnum k = AnotherTransfer k++instance P.Ord Transfer where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++-- Enum ScopeType+{- |+Scope type of a @/GIArgInfo/@ representing callback, determines how the+callback is invoked and is used to decided when the invoke structs+can be freed.+-}+data ScopeType = +      ScopeTypeInvalid+    {- ^+    The argument is not of callback type.+    -}+    | ScopeTypeCall+    {- ^+    The callback and associated user_data is only+    used during the call to this function.+    -}+    | ScopeTypeAsync+    {- ^+    The callback and associated user_data is+    only used until the callback is invoked, and the callback.+    is invoked always exactly once.+    -}+    | ScopeTypeNotified+    {- ^+    The callback and and associated+    user_data is used until the caller is notfied via the destroy_notify.+    -}+    | AnotherScopeType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum ScopeType where+    fromEnum ScopeTypeInvalid = 0+    fromEnum ScopeTypeCall = 1+    fromEnum ScopeTypeAsync = 2+    fromEnum ScopeTypeNotified = 3+    fromEnum (AnotherScopeType k) = k++    toEnum 0 = ScopeTypeInvalid+    toEnum 1 = ScopeTypeCall+    toEnum 2 = ScopeTypeAsync+    toEnum 3 = ScopeTypeNotified+    toEnum k = AnotherScopeType k++instance P.Ord ScopeType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++-- Enum RepositoryError+{- |+An error code used with @/G_IREPOSITORY_ERROR/@ in a 'GError' returned+from a 'GI.GIRepository.Objects.Repository.Repository' routine.+-}+data RepositoryError = +      RepositoryErrorTypelibNotFound+    {- ^+    the typelib could not be found.+    -}+    | RepositoryErrorNamespaceMismatch+    {- ^+    the namespace does not match the+      requested namespace.+    -}+    | RepositoryErrorNamespaceVersionConflict+    {- ^+    the version of the+      typelib does not match the requested version.+    -}+    | RepositoryErrorLibraryNotFound+    {- ^+    the library used by the typelib+      could not be found.+    -}+    | AnotherRepositoryError Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum RepositoryError where+    fromEnum RepositoryErrorTypelibNotFound = 0+    fromEnum RepositoryErrorNamespaceMismatch = 1+    fromEnum RepositoryErrorNamespaceVersionConflict = 2+    fromEnum RepositoryErrorLibraryNotFound = 3+    fromEnum (AnotherRepositoryError k) = k++    toEnum 0 = RepositoryErrorTypelibNotFound+    toEnum 1 = RepositoryErrorNamespaceMismatch+    toEnum 2 = RepositoryErrorNamespaceVersionConflict+    toEnum 3 = RepositoryErrorLibraryNotFound+    toEnum k = AnotherRepositoryError k++instance P.Ord RepositoryError where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++-- Enum InfoType+{- |+The type of a GIBaseInfo struct.+-}+data InfoType = +      InfoTypeInvalid+    {- ^+    invalid type+    -}+    | InfoTypeFunction+    {- ^+    function, see @/GIFunctionInfo/@+    -}+    | InfoTypeCallback+    {- ^+    callback, see @/GIFunctionInfo/@+    -}+    | InfoTypeStruct+    {- ^+    struct, see @/GIStructInfo/@+    -}+    | InfoTypeBoxed+    {- ^+    boxed, see @/GIStructInfo/@ or @/GIUnionInfo/@+    -}+    | InfoTypeEnum+    {- ^+    enum, see @/GIEnumInfo/@+    -}+    | InfoTypeFlags+    {- ^+    flags, see @/GIEnumInfo/@+    -}+    | InfoTypeObject+    {- ^+    object, see @/GIObjectInfo/@+    -}+    | InfoTypeInterface+    {- ^+    interface, see @/GIInterfaceInfo/@+    -}+    | InfoTypeConstant+    {- ^+    contant, see @/GIConstantInfo/@+    -}+    | InfoTypeInvalid0+    {- ^+    deleted, used to be GI_INFO_TYPE_ERROR_DOMAIN.+    -}+    | InfoTypeUnion+    {- ^+    union, see @/GIUnionInfo/@+    -}+    | InfoTypeValue+    {- ^+    enum value, see @/GIValueInfo/@+    -}+    | InfoTypeSignal+    {- ^+    signal, see @/GISignalInfo/@+    -}+    | InfoTypeVfunc+    {- ^+    virtual function, see @/GIVFuncInfo/@+    -}+    | InfoTypeProperty+    {- ^+    GObject property, see @/GIPropertyInfo/@+    -}+    | InfoTypeField+    {- ^+    struct or union field, see @/GIFieldInfo/@+    -}+    | InfoTypeArg+    {- ^+    argument of a function or callback, see @/GIArgInfo/@+    -}+    | InfoTypeType+    {- ^+    type information, see @/GITypeInfo/@+    -}+    | InfoTypeUnresolved+    {- ^+    unresolved type, a type which is not present in+      the typelib, or any of its dependencies.+    -}+    | AnotherInfoType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum InfoType where+    fromEnum InfoTypeInvalid = 0+    fromEnum InfoTypeFunction = 1+    fromEnum InfoTypeCallback = 2+    fromEnum InfoTypeStruct = 3+    fromEnum InfoTypeBoxed = 4+    fromEnum InfoTypeEnum = 5+    fromEnum InfoTypeFlags = 6+    fromEnum InfoTypeObject = 7+    fromEnum InfoTypeInterface = 8+    fromEnum InfoTypeConstant = 9+    fromEnum InfoTypeInvalid0 = 10+    fromEnum InfoTypeUnion = 11+    fromEnum InfoTypeValue = 12+    fromEnum InfoTypeSignal = 13+    fromEnum InfoTypeVfunc = 14+    fromEnum InfoTypeProperty = 15+    fromEnum InfoTypeField = 16+    fromEnum InfoTypeArg = 17+    fromEnum InfoTypeType = 18+    fromEnum InfoTypeUnresolved = 19+    fromEnum (AnotherInfoType k) = k++    toEnum 0 = InfoTypeInvalid+    toEnum 1 = InfoTypeFunction+    toEnum 2 = InfoTypeCallback+    toEnum 3 = InfoTypeStruct+    toEnum 4 = InfoTypeBoxed+    toEnum 5 = InfoTypeEnum+    toEnum 6 = InfoTypeFlags+    toEnum 7 = InfoTypeObject+    toEnum 8 = InfoTypeInterface+    toEnum 9 = InfoTypeConstant+    toEnum 10 = InfoTypeInvalid0+    toEnum 11 = InfoTypeUnion+    toEnum 12 = InfoTypeValue+    toEnum 13 = InfoTypeSignal+    toEnum 14 = InfoTypeVfunc+    toEnum 15 = InfoTypeProperty+    toEnum 16 = InfoTypeField+    toEnum 17 = InfoTypeArg+    toEnum 18 = InfoTypeType+    toEnum 19 = InfoTypeUnresolved+    toEnum k = AnotherInfoType k++instance P.Ord InfoType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++-- Enum Direction+{- |+The direction of a @/GIArgInfo/@.+-}+data Direction = +      DirectionIn+    {- ^+    in argument.+    -}+    | DirectionOut+    {- ^+    out argument.+    -}+    | DirectionInout+    {- ^+    in and out argument.+    -}+    | AnotherDirection Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum Direction where+    fromEnum DirectionIn = 0+    fromEnum DirectionOut = 1+    fromEnum DirectionInout = 2+    fromEnum (AnotherDirection k) = k++    toEnum 0 = DirectionIn+    toEnum 1 = DirectionOut+    toEnum 2 = DirectionInout+    toEnum k = AnotherDirection k++instance P.Ord Direction where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++-- Enum ArrayType+{- |+The type of array in a @/GITypeInfo/@.+-}+data ArrayType = +      ArrayTypeC+    {- ^+    a C array, char[] for instance+    -}+    | ArrayTypeArray+    {- ^+    a /@gArray@/ array+    -}+    | ArrayTypePtrArray+    {- ^+    a 'GI.GLib.Structs.PtrArray.PtrArray' array+    -}+    | ArrayTypeByteArray+    {- ^+    a 'GI.GLib.Structs.ByteArray.ByteArray' array+    -}+    | AnotherArrayType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum ArrayType where+    fromEnum ArrayTypeC = 0+    fromEnum ArrayTypeArray = 1+    fromEnum ArrayTypePtrArray = 2+    fromEnum ArrayTypeByteArray = 3+    fromEnum (AnotherArrayType k) = k++    toEnum 0 = ArrayTypeC+    toEnum 1 = ArrayTypeArray+    toEnum 2 = ArrayTypePtrArray+    toEnum 3 = ArrayTypeByteArray+    toEnum k = AnotherArrayType k++instance P.Ord ArrayType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++

@@ -0,0 +1,40 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GIRepository.Enums 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.ManagedPtr as B.ManagedPtr+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.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++data NvokeError+instance P.Enum NvokeError where+data TypeTag+instance P.Enum TypeTag where+data Transfer+instance P.Enum Transfer where+data ScopeType+instance P.Enum ScopeType where+data RepositoryError+instance P.Enum RepositoryError where+data InfoType+instance P.Enum InfoType where+data Direction+instance P.Enum Direction where+data ArrayType+instance P.Enum ArrayType where

@@ -0,0 +1,215 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GIRepository.Flags+    ( ++ -- * Flags+-- ** FieldInfoFlags #flag:FieldInfoFlags#++    FieldInfoFlags(..)                      ,+++-- ** FunctionInfoFlags #flag:FunctionInfoFlags#++    FunctionInfoFlags(..)                   ,+++-- ** RepositoryLoadFlags #flag:RepositoryLoadFlags#++    RepositoryLoadFlags(..)                 ,+++-- ** VFuncInfoFlags #flag:VFuncInfoFlags#++    VFuncInfoFlags(..)                      ,+++++    ) 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.ManagedPtr as B.ManagedPtr+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.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+++-- Flags VFuncInfoFlags+{- |+Flags of a @/GIVFuncInfo/@ struct.+-}+data VFuncInfoFlags = +      VFuncInfoFlagsMustChainUp+    {- ^+    chains up to the parent type+    -}+    | VFuncInfoFlagsMustOverride+    {- ^+    overrides+    -}+    | VFuncInfoFlagsMustNotOverride+    {- ^+    does not override+    -}+    | VFuncInfoFlagsThrows+    {- ^+    Includes a 'GError'+    -}+    | AnotherVFuncInfoFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum VFuncInfoFlags where+    fromEnum VFuncInfoFlagsMustChainUp = 1+    fromEnum VFuncInfoFlagsMustOverride = 2+    fromEnum VFuncInfoFlagsMustNotOverride = 4+    fromEnum VFuncInfoFlagsThrows = 8+    fromEnum (AnotherVFuncInfoFlags k) = k++    toEnum 1 = VFuncInfoFlagsMustChainUp+    toEnum 2 = VFuncInfoFlagsMustOverride+    toEnum 4 = VFuncInfoFlagsMustNotOverride+    toEnum 8 = VFuncInfoFlagsThrows+    toEnum k = AnotherVFuncInfoFlags k++instance P.Ord VFuncInfoFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++instance IsGFlag VFuncInfoFlags++-- Flags RepositoryLoadFlags+{- |+Flags that control how a typelib is loaded.+-}+data RepositoryLoadFlags = +      RepositoryLoadFlagsIrepositoryLoadFlagLazy+    {- ^+    Lazily load the typelib.+    -}+    | AnotherRepositoryLoadFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum RepositoryLoadFlags where+    fromEnum RepositoryLoadFlagsIrepositoryLoadFlagLazy = 1+    fromEnum (AnotherRepositoryLoadFlags k) = k++    toEnum 1 = RepositoryLoadFlagsIrepositoryLoadFlagLazy+    toEnum k = AnotherRepositoryLoadFlags k++instance P.Ord RepositoryLoadFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++instance IsGFlag RepositoryLoadFlags++-- Flags FunctionInfoFlags+{- |+Flags for a @/GIFunctionInfo/@ struct.+-}+data FunctionInfoFlags = +      FunctionInfoFlagsIsMethod+    {- ^+    is a method.+    -}+    | FunctionInfoFlagsIsConstructor+    {- ^+    is a constructor.+    -}+    | FunctionInfoFlagsIsGetter+    {- ^+    is a getter of a @/GIPropertyInfo/@.+    -}+    | FunctionInfoFlagsIsSetter+    {- ^+    is a setter of a @/GIPropertyInfo/@.+    -}+    | FunctionInfoFlagsWrapsVfunc+    {- ^+    represents a virtual function.+    -}+    | FunctionInfoFlagsThrows+    {- ^+    the function may throw an error.+    -}+    | AnotherFunctionInfoFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum FunctionInfoFlags where+    fromEnum FunctionInfoFlagsIsMethod = 1+    fromEnum FunctionInfoFlagsIsConstructor = 2+    fromEnum FunctionInfoFlagsIsGetter = 4+    fromEnum FunctionInfoFlagsIsSetter = 8+    fromEnum FunctionInfoFlagsWrapsVfunc = 16+    fromEnum FunctionInfoFlagsThrows = 32+    fromEnum (AnotherFunctionInfoFlags k) = k++    toEnum 1 = FunctionInfoFlagsIsMethod+    toEnum 2 = FunctionInfoFlagsIsConstructor+    toEnum 4 = FunctionInfoFlagsIsGetter+    toEnum 8 = FunctionInfoFlagsIsSetter+    toEnum 16 = FunctionInfoFlagsWrapsVfunc+    toEnum 32 = FunctionInfoFlagsThrows+    toEnum k = AnotherFunctionInfoFlags k++instance P.Ord FunctionInfoFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++instance IsGFlag FunctionInfoFlags++-- Flags FieldInfoFlags+{- |+Flags for a @/GIFieldInfo/@.+-}+data FieldInfoFlags = +      FieldInfoFlagsReadable+    {- ^+    field is readable.+    -}+    | FieldInfoFlagsWritable+    {- ^+    field is writable.+    -}+    | AnotherFieldInfoFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum FieldInfoFlags where+    fromEnum FieldInfoFlagsReadable = 1+    fromEnum FieldInfoFlagsWritable = 2+    fromEnum (AnotherFieldInfoFlags k) = k++    toEnum 1 = FieldInfoFlagsReadable+    toEnum 2 = FieldInfoFlagsWritable+    toEnum k = AnotherFieldInfoFlags k++instance P.Ord FieldInfoFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++instance IsGFlag FieldInfoFlags++

@@ -0,0 +1,36 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GIRepository.Flags 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.ManagedPtr as B.ManagedPtr+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.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++data VFuncInfoFlags+instance P.Enum VFuncInfoFlags where+instance IsGFlag VFuncInfoFlags+data RepositoryLoadFlags+instance P.Enum RepositoryLoadFlags where+instance IsGFlag RepositoryLoadFlags+data FunctionInfoFlags+instance P.Enum FunctionInfoFlags where+instance IsGFlag FunctionInfoFlags+data FieldInfoFlags+instance P.Enum FieldInfoFlags where+instance IsGFlag FieldInfoFlags

@@ -0,0 +1,4961 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GIRepository.Functions+    ( ++ -- * Methods+-- ** argInfoGetClosure #method:argInfoGetClosure#++    argInfoGetClosure                       ,+++-- ** argInfoGetDestroy #method:argInfoGetDestroy#++    argInfoGetDestroy                       ,+++-- ** argInfoGetDirection #method:argInfoGetDirection#++    argInfoGetDirection                     ,+++-- ** argInfoGetOwnershipTransfer #method:argInfoGetOwnershipTransfer#++    argInfoGetOwnershipTransfer             ,+++-- ** argInfoGetScope #method:argInfoGetScope#++    argInfoGetScope                         ,+++-- ** argInfoGetType #method:argInfoGetType#++    argInfoGetType                          ,+++-- ** argInfoIsCallerAllocates #method:argInfoIsCallerAllocates#++    argInfoIsCallerAllocates                ,+++-- ** argInfoIsOptional #method:argInfoIsOptional#++    argInfoIsOptional                       ,+++-- ** argInfoIsReturnValue #method:argInfoIsReturnValue#++    argInfoIsReturnValue                    ,+++-- ** argInfoIsSkip #method:argInfoIsSkip#++    argInfoIsSkip                           ,+++-- ** argInfoLoadType #method:argInfoLoadType#++    argInfoLoadType                         ,+++-- ** argInfoMayBeNull #method:argInfoMayBeNull#++    argInfoMayBeNull                        ,+++-- ** callableInfoCanThrowGerror #method:callableInfoCanThrowGerror#++    callableInfoCanThrowGerror              ,+++-- ** callableInfoGetArg #method:callableInfoGetArg#++    callableInfoGetArg                      ,+++-- ** callableInfoGetCallerOwns #method:callableInfoGetCallerOwns#++    callableInfoGetCallerOwns               ,+++-- ** callableInfoGetInstanceOwnershipTransfer #method:callableInfoGetInstanceOwnershipTransfer#++    callableInfoGetInstanceOwnershipTransfer,+++-- ** callableInfoGetNArgs #method:callableInfoGetNArgs#++    callableInfoGetNArgs                    ,+++-- ** callableInfoGetReturnAttribute #method:callableInfoGetReturnAttribute#++    callableInfoGetReturnAttribute          ,+++-- ** callableInfoGetReturnType #method:callableInfoGetReturnType#++    callableInfoGetReturnType               ,+++-- ** callableInfoInvoke #method:callableInfoInvoke#++    callableInfoInvoke                      ,+++-- ** callableInfoIsMethod #method:callableInfoIsMethod#++    callableInfoIsMethod                    ,+++-- ** callableInfoIterateReturnAttributes #method:callableInfoIterateReturnAttributes#++    callableInfoIterateReturnAttributes     ,+++-- ** callableInfoLoadArg #method:callableInfoLoadArg#++    callableInfoLoadArg                     ,+++-- ** callableInfoLoadReturnType #method:callableInfoLoadReturnType#++    callableInfoLoadReturnType              ,+++-- ** callableInfoMayReturnNull #method:callableInfoMayReturnNull#++    callableInfoMayReturnNull               ,+++-- ** callableInfoSkipReturn #method:callableInfoSkipReturn#++    callableInfoSkipReturn                  ,+++-- ** cclosureMarshalGeneric #method:cclosureMarshalGeneric#++    cclosureMarshalGeneric                  ,+++-- ** constantInfoGetType #method:constantInfoGetType#++    constantInfoGetType                     ,+++-- ** enumInfoGetErrorDomain #method:enumInfoGetErrorDomain#++    enumInfoGetErrorDomain                  ,+++-- ** enumInfoGetMethod #method:enumInfoGetMethod#++    enumInfoGetMethod                       ,+++-- ** enumInfoGetNMethods #method:enumInfoGetNMethods#++    enumInfoGetNMethods                     ,+++-- ** enumInfoGetNValues #method:enumInfoGetNValues#++    enumInfoGetNValues                      ,+++-- ** enumInfoGetStorageType #method:enumInfoGetStorageType#++    enumInfoGetStorageType                  ,+++-- ** enumInfoGetValue #method:enumInfoGetValue#++    enumInfoGetValue                        ,+++-- ** fieldInfoGetFlags #method:fieldInfoGetFlags#++    fieldInfoGetFlags                       ,+++-- ** fieldInfoGetOffset #method:fieldInfoGetOffset#++    fieldInfoGetOffset                      ,+++-- ** fieldInfoGetSize #method:fieldInfoGetSize#++    fieldInfoGetSize                        ,+++-- ** fieldInfoGetType #method:fieldInfoGetType#++    fieldInfoGetType                        ,+++-- ** functionInfoGetFlags #method:functionInfoGetFlags#++    functionInfoGetFlags                    ,+++-- ** functionInfoGetProperty #method:functionInfoGetProperty#++    functionInfoGetProperty                 ,+++-- ** functionInfoGetSymbol #method:functionInfoGetSymbol#++    functionInfoGetSymbol                   ,+++-- ** functionInfoGetVfunc #method:functionInfoGetVfunc#++    functionInfoGetVfunc                    ,+++-- ** infoNew #method:infoNew#++    infoNew                                 ,+++-- ** infoTypeToString #method:infoTypeToString#++    infoTypeToString                        ,+++-- ** interfaceInfoFindMethod #method:interfaceInfoFindMethod#++    interfaceInfoFindMethod                 ,+++-- ** interfaceInfoFindSignal #method:interfaceInfoFindSignal#++    interfaceInfoFindSignal                 ,+++-- ** interfaceInfoFindVfunc #method:interfaceInfoFindVfunc#++    interfaceInfoFindVfunc                  ,+++-- ** interfaceInfoGetConstant #method:interfaceInfoGetConstant#++    interfaceInfoGetConstant                ,+++-- ** interfaceInfoGetIfaceStruct #method:interfaceInfoGetIfaceStruct#++    interfaceInfoGetIfaceStruct             ,+++-- ** interfaceInfoGetMethod #method:interfaceInfoGetMethod#++    interfaceInfoGetMethod                  ,+++-- ** interfaceInfoGetNConstants #method:interfaceInfoGetNConstants#++    interfaceInfoGetNConstants              ,+++-- ** interfaceInfoGetNMethods #method:interfaceInfoGetNMethods#++    interfaceInfoGetNMethods                ,+++-- ** interfaceInfoGetNPrerequisites #method:interfaceInfoGetNPrerequisites#++    interfaceInfoGetNPrerequisites          ,+++-- ** interfaceInfoGetNProperties #method:interfaceInfoGetNProperties#++    interfaceInfoGetNProperties             ,+++-- ** interfaceInfoGetNSignals #method:interfaceInfoGetNSignals#++    interfaceInfoGetNSignals                ,+++-- ** interfaceInfoGetNVfuncs #method:interfaceInfoGetNVfuncs#++    interfaceInfoGetNVfuncs                 ,+++-- ** interfaceInfoGetPrerequisite #method:interfaceInfoGetPrerequisite#++    interfaceInfoGetPrerequisite            ,+++-- ** interfaceInfoGetProperty #method:interfaceInfoGetProperty#++    interfaceInfoGetProperty                ,+++-- ** interfaceInfoGetSignal #method:interfaceInfoGetSignal#++    interfaceInfoGetSignal                  ,+++-- ** interfaceInfoGetVfunc #method:interfaceInfoGetVfunc#++    interfaceInfoGetVfunc                   ,+++-- ** invokeErrorQuark #method:invokeErrorQuark#++    invokeErrorQuark                        ,+++-- ** objectInfoFindMethod #method:objectInfoFindMethod#++    objectInfoFindMethod                    ,+++-- ** objectInfoFindMethodUsingInterfaces #method:objectInfoFindMethodUsingInterfaces#++    objectInfoFindMethodUsingInterfaces     ,+++-- ** objectInfoFindSignal #method:objectInfoFindSignal#++    objectInfoFindSignal                    ,+++-- ** objectInfoFindVfunc #method:objectInfoFindVfunc#++    objectInfoFindVfunc                     ,+++-- ** objectInfoFindVfuncUsingInterfaces #method:objectInfoFindVfuncUsingInterfaces#++    objectInfoFindVfuncUsingInterfaces      ,+++-- ** objectInfoGetAbstract #method:objectInfoGetAbstract#++    objectInfoGetAbstract                   ,+++-- ** objectInfoGetClassStruct #method:objectInfoGetClassStruct#++    objectInfoGetClassStruct                ,+++-- ** objectInfoGetConstant #method:objectInfoGetConstant#++    objectInfoGetConstant                   ,+++-- ** objectInfoGetField #method:objectInfoGetField#++    objectInfoGetField                      ,+++-- ** objectInfoGetFundamental #method:objectInfoGetFundamental#++    objectInfoGetFundamental                ,+++-- ** objectInfoGetGetValueFunction #method:objectInfoGetGetValueFunction#++    objectInfoGetGetValueFunction           ,+++-- ** objectInfoGetInterface #method:objectInfoGetInterface#++    objectInfoGetInterface                  ,+++-- ** objectInfoGetMethod #method:objectInfoGetMethod#++    objectInfoGetMethod                     ,+++-- ** objectInfoGetNConstants #method:objectInfoGetNConstants#++    objectInfoGetNConstants                 ,+++-- ** objectInfoGetNFields #method:objectInfoGetNFields#++    objectInfoGetNFields                    ,+++-- ** objectInfoGetNInterfaces #method:objectInfoGetNInterfaces#++    objectInfoGetNInterfaces                ,+++-- ** objectInfoGetNMethods #method:objectInfoGetNMethods#++    objectInfoGetNMethods                   ,+++-- ** objectInfoGetNProperties #method:objectInfoGetNProperties#++    objectInfoGetNProperties                ,+++-- ** objectInfoGetNSignals #method:objectInfoGetNSignals#++    objectInfoGetNSignals                   ,+++-- ** objectInfoGetNVfuncs #method:objectInfoGetNVfuncs#++    objectInfoGetNVfuncs                    ,+++-- ** objectInfoGetParent #method:objectInfoGetParent#++    objectInfoGetParent                     ,+++-- ** objectInfoGetProperty #method:objectInfoGetProperty#++    objectInfoGetProperty                   ,+++-- ** objectInfoGetRefFunction #method:objectInfoGetRefFunction#++    objectInfoGetRefFunction                ,+++-- ** objectInfoGetSetValueFunction #method:objectInfoGetSetValueFunction#++    objectInfoGetSetValueFunction           ,+++-- ** objectInfoGetSignal #method:objectInfoGetSignal#++    objectInfoGetSignal                     ,+++-- ** objectInfoGetTypeInit #method:objectInfoGetTypeInit#++    objectInfoGetTypeInit                   ,+++-- ** objectInfoGetTypeName #method:objectInfoGetTypeName#++    objectInfoGetTypeName                   ,+++-- ** objectInfoGetUnrefFunction #method:objectInfoGetUnrefFunction#++    objectInfoGetUnrefFunction              ,+++-- ** objectInfoGetVfunc #method:objectInfoGetVfunc#++    objectInfoGetVfunc                      ,+++-- ** propertyInfoGetFlags #method:propertyInfoGetFlags#++    propertyInfoGetFlags                    ,+++-- ** propertyInfoGetOwnershipTransfer #method:propertyInfoGetOwnershipTransfer#++    propertyInfoGetOwnershipTransfer        ,+++-- ** propertyInfoGetType #method:propertyInfoGetType#++    propertyInfoGetType                     ,+++-- ** registeredTypeInfoGetGType #method:registeredTypeInfoGetGType#++    registeredTypeInfoGetGType              ,+++-- ** registeredTypeInfoGetTypeInit #method:registeredTypeInfoGetTypeInit#++    registeredTypeInfoGetTypeInit           ,+++-- ** registeredTypeInfoGetTypeName #method:registeredTypeInfoGetTypeName#++    registeredTypeInfoGetTypeName           ,+++-- ** signalInfoGetClassClosure #method:signalInfoGetClassClosure#++    signalInfoGetClassClosure               ,+++-- ** signalInfoGetFlags #method:signalInfoGetFlags#++    signalInfoGetFlags                      ,+++-- ** signalInfoTrueStopsEmit #method:signalInfoTrueStopsEmit#++    signalInfoTrueStopsEmit                 ,+++-- ** structInfoFindField #method:structInfoFindField#++    structInfoFindField                     ,+++-- ** structInfoFindMethod #method:structInfoFindMethod#++    structInfoFindMethod                    ,+++-- ** structInfoGetAlignment #method:structInfoGetAlignment#++    structInfoGetAlignment                  ,+++-- ** structInfoGetField #method:structInfoGetField#++    structInfoGetField                      ,+++-- ** structInfoGetMethod #method:structInfoGetMethod#++    structInfoGetMethod                     ,+++-- ** structInfoGetNFields #method:structInfoGetNFields#++    structInfoGetNFields                    ,+++-- ** structInfoGetNMethods #method:structInfoGetNMethods#++    structInfoGetNMethods                   ,+++-- ** structInfoGetSize #method:structInfoGetSize#++    structInfoGetSize                       ,+++-- ** structInfoIsForeign #method:structInfoIsForeign#++    structInfoIsForeign                     ,+++-- ** structInfoIsGtypeStruct #method:structInfoIsGtypeStruct#++    structInfoIsGtypeStruct                 ,+++-- ** typeInfoGetArrayFixedSize #method:typeInfoGetArrayFixedSize#++    typeInfoGetArrayFixedSize               ,+++-- ** typeInfoGetArrayLength #method:typeInfoGetArrayLength#++    typeInfoGetArrayLength                  ,+++-- ** typeInfoGetArrayType #method:typeInfoGetArrayType#++    typeInfoGetArrayType                    ,+++-- ** typeInfoGetInterface #method:typeInfoGetInterface#++    typeInfoGetInterface                    ,+++-- ** typeInfoGetParamType #method:typeInfoGetParamType#++    typeInfoGetParamType                    ,+++-- ** typeInfoGetTag #method:typeInfoGetTag#++    typeInfoGetTag                          ,+++-- ** typeInfoIsPointer #method:typeInfoIsPointer#++    typeInfoIsPointer                       ,+++-- ** typeInfoIsZeroTerminated #method:typeInfoIsZeroTerminated#++    typeInfoIsZeroTerminated                ,+++-- ** typeTagToString #method:typeTagToString#++    typeTagToString                         ,+++-- ** unionInfoFindMethod #method:unionInfoFindMethod#++    unionInfoFindMethod                     ,+++-- ** unionInfoGetAlignment #method:unionInfoGetAlignment#++    unionInfoGetAlignment                   ,+++-- ** unionInfoGetDiscriminator #method:unionInfoGetDiscriminator#++    unionInfoGetDiscriminator               ,+++-- ** unionInfoGetDiscriminatorOffset #method:unionInfoGetDiscriminatorOffset#++    unionInfoGetDiscriminatorOffset         ,+++-- ** unionInfoGetDiscriminatorType #method:unionInfoGetDiscriminatorType#++    unionInfoGetDiscriminatorType           ,+++-- ** unionInfoGetField #method:unionInfoGetField#++    unionInfoGetField                       ,+++-- ** unionInfoGetMethod #method:unionInfoGetMethod#++    unionInfoGetMethod                      ,+++-- ** unionInfoGetNFields #method:unionInfoGetNFields#++    unionInfoGetNFields                     ,+++-- ** unionInfoGetNMethods #method:unionInfoGetNMethods#++    unionInfoGetNMethods                    ,+++-- ** unionInfoGetSize #method:unionInfoGetSize#++    unionInfoGetSize                        ,+++-- ** unionInfoIsDiscriminated #method:unionInfoIsDiscriminated#++    unionInfoIsDiscriminated                ,+++-- ** valueInfoGetValue #method:valueInfoGetValue#++    valueInfoGetValue                       ,+++-- ** vfuncInfoGetAddress #method:vfuncInfoGetAddress#++    vfuncInfoGetAddress                     ,+++-- ** vfuncInfoGetFlags #method:vfuncInfoGetFlags#++    vfuncInfoGetFlags                       ,+++-- ** vfuncInfoGetInvoker #method:vfuncInfoGetInvoker#++    vfuncInfoGetInvoker                     ,+++-- ** vfuncInfoGetOffset #method:vfuncInfoGetOffset#++    vfuncInfoGetOffset                      ,+++-- ** vfuncInfoGetSignal #method:vfuncInfoGetSignal#++    vfuncInfoGetSignal                      ,+++++    ) 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.ManagedPtr as B.ManagedPtr+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.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.GIRepository.Enums as GIRepository.Enums+import {-# SOURCE #-} qualified GI.GIRepository.Flags as GIRepository.Flags+import {-# SOURCE #-} qualified GI.GIRepository.Structs.AttributeIter as GIRepository.AttributeIter+import {-# SOURCE #-} qualified GI.GIRepository.Structs.BaseInfo as GIRepository.BaseInfo+import {-# SOURCE #-} qualified GI.GIRepository.Structs.Typelib as GIRepository.Typelib+import {-# SOURCE #-} qualified GI.GIRepository.Unions.Argument as GIRepository.Argument+import qualified GI.GObject.Flags as GObject.Flags++-- function g_vfunc_info_get_signal+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIVFuncInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_vfunc_info_get_signal" g_vfunc_info_get_signal :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the signal for the virtual function if one is set.+The signal comes from the object or interface to which+this virtual function belongs.+-}+vfuncInfoGetSignal ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIVFuncInfo/@ -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the signal or 'Nothing' if none set -}+vfuncInfoGetSignal info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_vfunc_info_get_signal info'+    checkUnexpectedReturnNULL "vfuncInfoGetSignal" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_vfunc_info_get_offset+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIVFuncInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_vfunc_info_get_offset" g_vfunc_info_get_offset :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the offset of the function pointer in the class struct. The value+0xFFFF indicates that the struct offset is unknown.+-}+vfuncInfoGetOffset ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIVFuncInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ the struct offset or 0xFFFF if it\'s unknown -}+vfuncInfoGetOffset info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_vfunc_info_get_offset info'+    touchManagedPtr info+    return result+++-- function g_vfunc_info_get_invoker+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIVFuncInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_vfunc_info_get_invoker" g_vfunc_info_get_invoker :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+If this virtual function has an associated invoker method, this+method will return it.  An invoker method is a C entry point.++Not all virtuals will have invokers.+-}+vfuncInfoGetInvoker ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIVFuncInfo/@ -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIVFuncInfo/@ or 'Nothing'. Free it with+@/g_base_info_unref()/@ when done. -}+vfuncInfoGetInvoker info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_vfunc_info_get_invoker info'+    checkUnexpectedReturnNULL "vfuncInfoGetInvoker" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_vfunc_info_get_flags+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIVFuncInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "VFuncInfoFlags"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_vfunc_info_get_flags" g_vfunc_info_get_flags :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CUInt++{- |+Obtain the flags for this virtual function info. See 'GI.GIRepository.Flags.VFuncInfoFlags' for+more information about possible flag values.+-}+vfuncInfoGetFlags ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIVFuncInfo/@ -}+    -> m [GIRepository.Flags.VFuncInfoFlags]+    {- ^ __Returns:__ the flags -}+vfuncInfoGetFlags info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_vfunc_info_get_flags info'+    let result' = wordToGFlags result+    touchManagedPtr info+    return result'+++-- function g_vfunc_info_get_address+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIVFuncInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "implementor_gtype", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GType implementing this virtual function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TPtr)+-- throws : True+-- Skip return : False++foreign import ccall "g_vfunc_info_get_address" g_vfunc_info_get_address :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    CGType ->                               -- implementor_gtype : TBasicType TGType+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr ())++{- |+This method will look up where inside the type struct of /@implementorGtype@/+is the implementation for /@info@/.+-}+vfuncInfoGetAddress ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIVFuncInfo/@ -}+    -> GType+    {- ^ /@implementorGtype@/: 'GType' implementing this virtual function -}+    -> m (Ptr ())+    {- ^ __Returns:__ address to a function or 'Nothing' if an error happened /(Can throw 'Data.GI.Base.GError.GError')/ -}+vfuncInfoGetAddress info implementorGtype = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    let implementorGtype' = gtypeToCGType implementorGtype+    onException (do+        result <- propagateGError $ g_vfunc_info_get_address info' implementorGtype'+        touchManagedPtr info+        return result+     ) (do+        return ()+     )+++-- function g_value_info_get_value+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIValueInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt64)+-- throws : False+-- Skip return : False++foreign import ccall "g_value_info_get_value" g_value_info_get_value :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int64++{- |+Obtain the enumeration value of the @/GIValueInfo/@.+-}+valueInfoGetValue ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIValueInfo/@ -}+    -> m Int64+    {- ^ __Returns:__ the enumeration value. This will always be representable+  as a 32-bit signed or unsigned value. The use of gint64 as the+  return type is to allow both. -}+valueInfoGetValue info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_value_info_get_value info'+    touchManagedPtr info+    return result+++-- function g_union_info_is_discriminated+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_union_info_is_discriminated" g_union_info_is_discriminated :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+Return true if this union contains discriminator field.+-}+unionInfoIsDiscriminated ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIUnionInfo/@ -}+    -> m Bool+    {- ^ __Returns:__ 'True' if this is a discriminated union, 'False' otherwise -}+unionInfoIsDiscriminated info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_union_info_is_discriminated info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'+++-- function g_union_info_get_size+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUInt64)+-- throws : False+-- Skip return : False++foreign import ccall "g_union_info_get_size" g_union_info_get_size :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Word64++{- |+Obtain the total size of the union.+-}+unionInfoGetSize ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIUnionInfo/@ -}+    -> m Word64+    {- ^ __Returns:__ size of the union in bytes -}+unionInfoGetSize info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_union_info_get_size info'+    touchManagedPtr info+    return result+++-- function g_union_info_get_n_methods+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_union_info_get_n_methods" g_union_info_get_n_methods :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of methods this union has.+-}+unionInfoGetNMethods ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIUnionInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of methods -}+unionInfoGetNMethods info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_union_info_get_n_methods info'+    touchManagedPtr info+    return result+++-- function g_union_info_get_n_fields+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_union_info_get_n_fields" g_union_info_get_n_fields :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of fields this union has.+-}+unionInfoGetNFields ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIUnionInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of fields -}+unionInfoGetNFields info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_union_info_get_n_fields info'+    touchManagedPtr info+    return result+++-- function g_union_info_get_method+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a method index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_union_info_get_method" g_union_info_get_method :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the type information for method with specified index.+-}+unionInfoGetMethod ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIUnionInfo/@ -}+    -> Int32+    {- ^ /@n@/: a method index -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIFunctionInfo/@, free it with @/g_base_info_unref()/@+when done. -}+unionInfoGetMethod info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_union_info_get_method info' n+    checkUnexpectedReturnNULL "unionInfoGetMethod" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_union_info_get_field+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a field index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_union_info_get_field" g_union_info_get_field :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the type information for field with specified index.+-}+unionInfoGetField ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIUnionInfo/@ -}+    -> Int32+    {- ^ /@n@/: a field index -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIFieldInfo/@, free it with @/g_base_info_unref()/@+when done. -}+unionInfoGetField info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_union_info_get_field info' n+    checkUnexpectedReturnNULL "unionInfoGetField" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_union_info_get_discriminator_type+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_union_info_get_discriminator_type" g_union_info_get_discriminator_type :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the type information of the union discriminator.+-}+unionInfoGetDiscriminatorType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIUnionInfo/@ -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GITypeInfo/@, free it with @/g_base_info_unref()/@+when done. -}+unionInfoGetDiscriminatorType info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_union_info_get_discriminator_type info'+    checkUnexpectedReturnNULL "unionInfoGetDiscriminatorType" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_union_info_get_discriminator_offset+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_union_info_get_discriminator_offset" g_union_info_get_discriminator_offset :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Returns offset of the discriminator field in the structure.+-}+unionInfoGetDiscriminatorOffset ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIUnionInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ offset in bytes of the discriminator -}+unionInfoGetDiscriminatorOffset info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_union_info_get_discriminator_offset info'+    touchManagedPtr info+    return result+++-- function g_union_info_get_discriminator+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a union field index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_union_info_get_discriminator" g_union_info_get_discriminator :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain discriminator value assigned for n-th union field, i.e. n-th+union field is the active one if discriminator contains this+constant.+-}+unionInfoGetDiscriminator ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIUnionInfo/@ -}+    -> Int32+    {- ^ /@n@/: a union field index -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIConstantInfo/@, free it with @/g_base_info_unref()/@+when done. -}+unionInfoGetDiscriminator info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_union_info_get_discriminator info' n+    checkUnexpectedReturnNULL "unionInfoGetDiscriminator" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_union_info_get_alignment+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUInt64)+-- throws : False+-- Skip return : False++foreign import ccall "g_union_info_get_alignment" g_union_info_get_alignment :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Word64++{- |+Obtain the required alignment of the union.+-}+unionInfoGetAlignment ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIUnionInfo/@ -}+    -> m Word64+    {- ^ __Returns:__ required alignment in bytes -}+unionInfoGetAlignment info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_union_info_get_alignment info'+    touchManagedPtr info+    return result+++-- function g_union_info_find_method+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", 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 "a method name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_union_info_find_method" g_union_info_find_method :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the type information for method named /@name@/.+-}+unionInfoFindMethod ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIUnionInfo/@ -}+    -> T.Text+    {- ^ /@name@/: a method name -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIFunctionInfo/@, free it with @/g_base_info_unref()/@+when done. -}+unionInfoFindMethod info name = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    name' <- textToCString name+    result <- g_union_info_find_method info' name'+    checkUnexpectedReturnNULL "unionInfoFindMethod" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    freeMem name'+    return result'+++-- function g_type_tag_to_string+-- Args : [Arg {argCName = "type", argType = TInterface (Name {namespace = "GIRepository", name = "TypeTag"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the type_tag", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_type_tag_to_string" g_type_tag_to_string :: +    CUInt ->                                -- type : TInterface (Name {namespace = "GIRepository", name = "TypeTag"})+    IO CString++{- |+Obtain a string representation of /@type@/+-}+typeTagToString ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.Enums.TypeTag+    {- ^ /@type@/: the type_tag -}+    -> m T.Text+    {- ^ __Returns:__ the string -}+typeTagToString type_ = liftIO $ do+    let type_' = (fromIntegral . fromEnum) type_+    result <- g_type_tag_to_string type_'+    checkUnexpectedReturnNULL "typeTagToString" result+    result' <- cstringToText result+    return result'+++-- function g_type_info_is_zero_terminated+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GITypeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_type_info_is_zero_terminated" g_type_info_is_zero_terminated :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+Obtain if the last element of the array is 'Nothing'. The type tag must be a+@/GI_TYPE_TAG_ARRAY/@ or 'False' will returned.+-}+typeInfoIsZeroTerminated ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GITypeInfo/@ -}+    -> m Bool+    {- ^ __Returns:__ 'True' if zero terminated -}+typeInfoIsZeroTerminated info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_type_info_is_zero_terminated info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'+++-- function g_type_info_is_pointer+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GITypeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_type_info_is_pointer" g_type_info_is_pointer :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+Obtain if the type is passed as a reference.++Note that the types of 'GI.GIRepository.Enums.DirectionOut' and 'GI.GIRepository.Enums.DirectionInout' parameters+will only be pointers if the underlying type being transferred is a pointer+(i.e. only if the type of the C function’s formal parameter is a pointer to a+pointer).+-}+typeInfoIsPointer ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GITypeInfo/@ -}+    -> m Bool+    {- ^ __Returns:__ 'True' if it is a pointer -}+typeInfoIsPointer info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_type_info_is_pointer info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'+++-- function g_type_info_get_tag+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GITypeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "TypeTag"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_type_info_get_tag" g_type_info_get_tag :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CUInt++{- |+Obtain the type tag for the type. See 'GI.GIRepository.Enums.TypeTag' for a list+of type tags.+-}+typeInfoGetTag ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GITypeInfo/@ -}+    -> m GIRepository.Enums.TypeTag+    {- ^ __Returns:__ the type tag -}+typeInfoGetTag info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_type_info_get_tag info'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr info+    return result'+++-- function g_type_info_get_param_type+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GITypeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of the parameter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_type_info_get_param_type" g_type_info_get_param_type :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the parameter type /@n@/.+-}+typeInfoGetParamType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GITypeInfo/@ -}+    -> Int32+    {- ^ /@n@/: index of the parameter -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the param type info -}+typeInfoGetParamType info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_type_info_get_param_type info' n+    checkUnexpectedReturnNULL "typeInfoGetParamType" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_type_info_get_interface+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GITypeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_type_info_get_interface" g_type_info_get_interface :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+For types which have @/GI_TYPE_TAG_INTERFACE/@ such as GObjects and boxed values,+this function returns full information about the referenced type.  You can then+inspect the type of the returned 'GI.GIRepository.Structs.BaseInfo.BaseInfo' to further query whether it is+a concrete GObject, a GInterface, a structure, etc. using 'GI.GIRepository.Structs.BaseInfo.baseInfoGetType'.+-}+typeInfoGetInterface ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GITypeInfo/@ -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the 'GI.GIRepository.Structs.BaseInfo.BaseInfo', or 'Nothing'. Free it with+@/g_base_info_unref()/@ when done. -}+typeInfoGetInterface info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_type_info_get_interface info'+    checkUnexpectedReturnNULL "typeInfoGetInterface" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_type_info_get_array_type+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GITypeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "ArrayType"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_type_info_get_array_type" g_type_info_get_array_type :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CUInt++{- |+Obtain the array type for this type. See 'GI.GIRepository.Enums.ArrayType' for a list of+possible values. If the type tag of this type is not array, -1 will be+returned.+-}+typeInfoGetArrayType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GITypeInfo/@ -}+    -> m GIRepository.Enums.ArrayType+    {- ^ __Returns:__ the array type or -1 -}+typeInfoGetArrayType info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_type_info_get_array_type info'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr info+    return result'+++-- function g_type_info_get_array_length+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GITypeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_type_info_get_array_length" g_type_info_get_array_length :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the array length of the type. The type tag must be a+@/GI_TYPE_TAG_ARRAY/@ or -1 will returned.+-}+typeInfoGetArrayLength ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GITypeInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ the array length, or -1 if the type is not an array -}+typeInfoGetArrayLength info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_type_info_get_array_length info'+    touchManagedPtr info+    return result+++-- function g_type_info_get_array_fixed_size+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GITypeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_type_info_get_array_fixed_size" g_type_info_get_array_fixed_size :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the fixed array size of the type. The type tag must be a+@/GI_TYPE_TAG_ARRAY/@ or -1 will returned.+-}+typeInfoGetArrayFixedSize ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GITypeInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ the size or -1 if it\'s not an array -}+typeInfoGetArrayFixedSize info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_type_info_get_array_fixed_size info'+    touchManagedPtr info+    return result+++-- function g_struct_info_is_gtype_struct+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_struct_info_is_gtype_struct" g_struct_info_is_gtype_struct :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+Return true if this structure represents the \"class structure\" for some+'GI.GObject.Objects.Object.Object' or @/GInterface/@.  This function is mainly useful to hide this kind of structure+from generated public APIs.+-}+structInfoIsGtypeStruct ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIStructInfo/@ -}+    -> m Bool+    {- ^ __Returns:__ 'True' if this is a class struct, 'False' otherwise -}+structInfoIsGtypeStruct info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_struct_info_is_gtype_struct info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'+++-- function g_struct_info_is_foreign+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_struct_info_is_foreign" g_struct_info_is_foreign :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+TODO+-}+structInfoIsForeign ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: TODO -}+    -> m Bool+    {- ^ __Returns:__ TODO -}+structInfoIsForeign info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_struct_info_is_foreign info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'+++-- function g_struct_info_get_size+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUInt64)+-- throws : False+-- Skip return : False++foreign import ccall "g_struct_info_get_size" g_struct_info_get_size :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Word64++{- |+Obtain the total size of the structure.+-}+structInfoGetSize ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIStructInfo/@ -}+    -> m Word64+    {- ^ __Returns:__ size of the structure in bytes -}+structInfoGetSize info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_struct_info_get_size info'+    touchManagedPtr info+    return result+++-- function g_struct_info_get_n_methods+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_struct_info_get_n_methods" g_struct_info_get_n_methods :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of methods this structure has.+-}+structInfoGetNMethods ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIStructInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of methods -}+structInfoGetNMethods info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_struct_info_get_n_methods info'+    touchManagedPtr info+    return result+++-- function g_struct_info_get_n_fields+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_struct_info_get_n_fields" g_struct_info_get_n_fields :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of fields this structure has.+-}+structInfoGetNFields ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIStructInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of fields -}+structInfoGetNFields info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_struct_info_get_n_fields info'+    touchManagedPtr info+    return result+++-- function g_struct_info_get_method+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a method index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_struct_info_get_method" g_struct_info_get_method :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the type information for method with specified index.+-}+structInfoGetMethod ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIStructInfo/@ -}+    -> Int32+    {- ^ /@n@/: a method index -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIFunctionInfo/@, free it with @/g_base_info_unref()/@+when done. -}+structInfoGetMethod info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_struct_info_get_method info' n+    checkUnexpectedReturnNULL "structInfoGetMethod" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_struct_info_get_field+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a field index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_struct_info_get_field" g_struct_info_get_field :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the type information for field with specified index.+-}+structInfoGetField ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIStructInfo/@ -}+    -> Int32+    {- ^ /@n@/: a field index -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIFieldInfo/@, free it with @/g_base_info_unref()/@+when done. -}+structInfoGetField info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_struct_info_get_field info' n+    checkUnexpectedReturnNULL "structInfoGetField" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_struct_info_get_alignment+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUInt64)+-- throws : False+-- Skip return : False++foreign import ccall "g_struct_info_get_alignment" g_struct_info_get_alignment :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Word64++{- |+Obtain the required alignment of the structure.+-}+structInfoGetAlignment ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIStructInfo/@ -}+    -> m Word64+    {- ^ __Returns:__ required alignment in bytes -}+structInfoGetAlignment info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_struct_info_get_alignment info'+    touchManagedPtr info+    return result+++-- function g_struct_info_find_method+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", 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 "a method name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_struct_info_find_method" g_struct_info_find_method :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the type information for method named /@name@/.+-}+structInfoFindMethod ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIStructInfo/@ -}+    -> T.Text+    {- ^ /@name@/: a method name -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIFunctionInfo/@, free it with @/g_base_info_unref()/@+when done. -}+structInfoFindMethod info name = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    name' <- textToCString name+    result <- g_struct_info_find_method info' name'+    checkUnexpectedReturnNULL "structInfoFindMethod" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    freeMem name'+    return result'+++-- function g_struct_info_find_field+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", 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 "a field name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_struct_info_find_field" g_struct_info_find_field :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the type information for field named /@name@/.++/Since: 1.46/+-}+structInfoFindField ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIStructInfo/@ -}+    -> T.Text+    {- ^ /@name@/: a field name -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIFieldInfo/@ or 'Nothing' if not found,+free it with @/g_base_info_unref()/@ when done. -}+structInfoFindField info name = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    name' <- textToCString name+    result <- g_struct_info_find_field info' name'+    checkUnexpectedReturnNULL "structInfoFindField" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    freeMem name'+    return result'+++-- function g_signal_info_true_stops_emit+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GISignalInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_signal_info_true_stops_emit" g_signal_info_true_stops_emit :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+Obtain if the returning true in the signal handler will+stop the emission of the signal.+-}+signalInfoTrueStopsEmit ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GISignalInfo/@ -}+    -> m Bool+    {- ^ __Returns:__ 'True' if returning true stops the signal emission -}+signalInfoTrueStopsEmit info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_signal_info_true_stops_emit info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'+++-- function g_signal_info_get_flags+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GISignalInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GObject", name = "SignalFlags"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_signal_info_get_flags" g_signal_info_get_flags :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CUInt++{- |+Obtain the flags for this signal info. See 'GI.GObject.Flags.SignalFlags' for+more information about possible flag values.+-}+signalInfoGetFlags ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GISignalInfo/@ -}+    -> m [GObject.Flags.SignalFlags]+    {- ^ __Returns:__ the flags -}+signalInfoGetFlags info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_signal_info_get_flags info'+    let result' = wordToGFlags result+    touchManagedPtr info+    return result'+++-- function g_signal_info_get_class_closure+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GISignalInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_signal_info_get_class_closure" g_signal_info_get_class_closure :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the class closure for this signal if one is set. The class+closure is a virtual function on the type that the signal belongs to.+If the signal lacks a closure 'Nothing' will be returned.+-}+signalInfoGetClassClosure ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GISignalInfo/@ -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the class closure or 'Nothing' -}+signalInfoGetClassClosure info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_signal_info_get_class_closure info'+    checkUnexpectedReturnNULL "signalInfoGetClassClosure" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_registered_type_info_get_type_name+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIRegisteredTypeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_registered_type_info_get_type_name" g_registered_type_info_get_type_name :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CString++{- |+Obtain the type name of the struct within the GObject type system.+This type can be passed to 'GI.GObject.Functions.typeName' to get a 'GType'.+-}+registeredTypeInfoGetTypeName ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIRegisteredTypeInfo/@ -}+    -> m T.Text+    {- ^ __Returns:__ the type name -}+registeredTypeInfoGetTypeName info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_registered_type_info_get_type_name info'+    checkUnexpectedReturnNULL "registeredTypeInfoGetTypeName" result+    result' <- cstringToText result+    touchManagedPtr info+    return result'+++-- function g_registered_type_info_get_type_init+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIRegisteredTypeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_registered_type_info_get_type_init" g_registered_type_info_get_type_init :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CString++{- |+Obtain the type init function for /@info@/. The type init function is the+function which will register the GType within the GObject type system.+Usually this is not called by langauge bindings or applications, use+'GI.GIRepository.Functions.registeredTypeInfoGetGType' directly instead.+-}+registeredTypeInfoGetTypeInit ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIRegisteredTypeInfo/@ -}+    -> m T.Text+    {- ^ __Returns:__ the symbol name of the type init function, suitable for+passing into @/g_module_symbol()/@. -}+registeredTypeInfoGetTypeInit info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_registered_type_info_get_type_init info'+    checkUnexpectedReturnNULL "registeredTypeInfoGetTypeInit" result+    result' <- cstringToText result+    touchManagedPtr info+    return result'+++-- function g_registered_type_info_get_g_type+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIRegisteredTypeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TGType)+-- throws : False+-- Skip return : False++foreign import ccall "g_registered_type_info_get_g_type" g_registered_type_info_get_g_type :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CGType++{- |+Obtain the 'GType' for this registered type or G_TYPE_NONE which a special meaning.+It means that either there is no type information associated with this /@info@/ or+that the shared library which provides the type_init function for this+/@info@/ cannot be called.+-}+registeredTypeInfoGetGType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIRegisteredTypeInfo/@ -}+    -> m GType+    {- ^ __Returns:__ the 'GType'. -}+registeredTypeInfoGetGType info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_registered_type_info_get_g_type info'+    let result' = GType result+    touchManagedPtr info+    return result'+++-- function g_property_info_get_type+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIPropertyInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_property_info_get_type" g_property_info_get_type :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the type information for the property /@info@/.+-}+propertyInfoGetType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIPropertyInfo/@ -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GITypeInfo/@, free it with+@/g_base_info_unref()/@ when done. -}+propertyInfoGetType info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_property_info_get_type info'+    checkUnexpectedReturnNULL "propertyInfoGetType" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_property_info_get_ownership_transfer+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIPropertyInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Transfer"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_property_info_get_ownership_transfer" g_property_info_get_ownership_transfer :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CUInt++{- |+Obtain the ownership transfer for this property. See 'GI.GIRepository.Enums.Transfer' for more+information about transfer values.+-}+propertyInfoGetOwnershipTransfer ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIPropertyInfo/@ -}+    -> m GIRepository.Enums.Transfer+    {- ^ __Returns:__ the transfer -}+propertyInfoGetOwnershipTransfer info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_property_info_get_ownership_transfer info'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr info+    return result'+++-- function g_property_info_get_flags+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIPropertyInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GObject", name = "ParamFlags"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_property_info_get_flags" g_property_info_get_flags :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CUInt++{- |+Obtain the flags for this property info. See 'GI.GObject.Flags.ParamFlags' for+more information about possible flag values.+-}+propertyInfoGetFlags ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIPropertyInfo/@ -}+    -> m [GObject.Flags.ParamFlags]+    {- ^ __Returns:__ the flags -}+propertyInfoGetFlags info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_property_info_get_flags info'+    let result' = wordToGFlags result+    touchManagedPtr info+    return result'+++-- function g_object_info_get_vfunc+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of virtual function to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_vfunc" g_object_info_get_vfunc :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain an object type virtual function at index /@n@/.+-}+objectInfoGetVfunc ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> Int32+    {- ^ /@n@/: index of virtual function to get -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIVFuncInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+objectInfoGetVfunc info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_vfunc info' n+    checkUnexpectedReturnNULL "objectInfoGetVfunc" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_object_info_get_unref_function+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_unref_function" g_object_info_get_unref_function :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CString++{- |+Obtain the symbol name of the function that should be called to unref this+object type. It\'s mainly used fundamental types. The type signature for+the symbol is @/GIObjectInfoUnrefFunction/@, to fetch the function pointer+see 'GI.GIRepository.Functions.objectInfoGetUnrefFunction'.+-}+objectInfoGetUnrefFunction ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> m T.Text+    {- ^ __Returns:__ the symbol or 'Nothing' -}+objectInfoGetUnrefFunction info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_unref_function info'+    checkUnexpectedReturnNULL "objectInfoGetUnrefFunction" result+    result' <- cstringToText result+    touchManagedPtr info+    return result'+++-- function g_object_info_get_type_name+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_type_name" g_object_info_get_type_name :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CString++{- |+Obtain the name of the objects class\/type.+-}+objectInfoGetTypeName ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> m T.Text+    {- ^ __Returns:__ name of the objects type -}+objectInfoGetTypeName info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_type_name info'+    checkUnexpectedReturnNULL "objectInfoGetTypeName" result+    result' <- cstringToText result+    touchManagedPtr info+    return result'+++-- function g_object_info_get_type_init+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_type_init" g_object_info_get_type_init :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CString++{- |+Obtain the function which when called will return the GType+function for which this object type is registered.+-}+objectInfoGetTypeInit ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> m T.Text+    {- ^ __Returns:__ the type init function -}+objectInfoGetTypeInit info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_type_init info'+    checkUnexpectedReturnNULL "objectInfoGetTypeInit" result+    result' <- cstringToText result+    touchManagedPtr info+    return result'+++-- function g_object_info_get_signal+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of signal to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_signal" g_object_info_get_signal :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain an object type signal at index /@n@/.+-}+objectInfoGetSignal ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> Int32+    {- ^ /@n@/: index of signal to get -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GISignalInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+objectInfoGetSignal info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_signal info' n+    checkUnexpectedReturnNULL "objectInfoGetSignal" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_object_info_get_set_value_function+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_set_value_function" g_object_info_get_set_value_function :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CString++{- |+Obtain the symbol name of the function that should be called to convert+set a GValue giving an object instance pointer of this object type.+I\'s mainly used fundamental types. The type signature for the symbol+is @/GIObjectInfoSetValueFunction/@, to fetch the function pointer+see 'GI.GIRepository.Functions.objectInfoGetSetValueFunction'.+-}+objectInfoGetSetValueFunction ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> m T.Text+    {- ^ __Returns:__ the symbol or 'Nothing' -}+objectInfoGetSetValueFunction info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_set_value_function info'+    checkUnexpectedReturnNULL "objectInfoGetSetValueFunction" result+    result' <- cstringToText result+    touchManagedPtr info+    return result'+++-- function g_object_info_get_ref_function+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_ref_function" g_object_info_get_ref_function :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CString++{- |+Obtain the symbol name of the function that should be called to ref this+object type. It\'s mainly used fundamental types. The type signature for+the symbol is @/GIObjectInfoRefFunction/@, to fetch the function pointer+see 'GI.GIRepository.Functions.objectInfoGetRefFunction'.+-}+objectInfoGetRefFunction ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> m T.Text+    {- ^ __Returns:__ the symbol or 'Nothing' -}+objectInfoGetRefFunction info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_ref_function info'+    checkUnexpectedReturnNULL "objectInfoGetRefFunction" result+    result' <- cstringToText result+    touchManagedPtr info+    return result'+++-- function g_object_info_get_property+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of property to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_property" g_object_info_get_property :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain an object type property at index /@n@/.+-}+objectInfoGetProperty ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> Int32+    {- ^ /@n@/: index of property to get -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIPropertyInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+objectInfoGetProperty info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_property info' n+    checkUnexpectedReturnNULL "objectInfoGetProperty" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_object_info_get_parent+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_parent" g_object_info_get_parent :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the parent of the object type.+-}+objectInfoGetParent ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIObjectInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+objectInfoGetParent info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_parent info'+    checkUnexpectedReturnNULL "objectInfoGetParent" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_object_info_get_n_vfuncs+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_n_vfuncs" g_object_info_get_n_vfuncs :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of virtual functions that this object type has.+-}+objectInfoGetNVfuncs ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of virtual functions -}+objectInfoGetNVfuncs info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_n_vfuncs info'+    touchManagedPtr info+    return result+++-- function g_object_info_get_n_signals+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_n_signals" g_object_info_get_n_signals :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of signals that this object type has.+-}+objectInfoGetNSignals ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of signals -}+objectInfoGetNSignals info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_n_signals info'+    touchManagedPtr info+    return result+++-- function g_object_info_get_n_properties+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_n_properties" g_object_info_get_n_properties :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of properties that this object type has.+-}+objectInfoGetNProperties ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of properties -}+objectInfoGetNProperties info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_n_properties info'+    touchManagedPtr info+    return result+++-- function g_object_info_get_n_methods+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_n_methods" g_object_info_get_n_methods :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of methods that this object type has.+-}+objectInfoGetNMethods ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of methods -}+objectInfoGetNMethods info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_n_methods info'+    touchManagedPtr info+    return result+++-- function g_object_info_get_n_interfaces+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_n_interfaces" g_object_info_get_n_interfaces :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of interfaces that this object type has.+-}+objectInfoGetNInterfaces ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of interfaces -}+objectInfoGetNInterfaces info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_n_interfaces info'+    touchManagedPtr info+    return result+++-- function g_object_info_get_n_fields+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_n_fields" g_object_info_get_n_fields :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of fields that this object type has.+-}+objectInfoGetNFields ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of fields -}+objectInfoGetNFields info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_n_fields info'+    touchManagedPtr info+    return result+++-- function g_object_info_get_n_constants+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_n_constants" g_object_info_get_n_constants :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of constants that this object type has.+-}+objectInfoGetNConstants ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of constants -}+objectInfoGetNConstants info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_n_constants info'+    touchManagedPtr info+    return result+++-- function g_object_info_get_method+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of method to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_method" g_object_info_get_method :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain an object type method at index /@n@/.+-}+objectInfoGetMethod ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> Int32+    {- ^ /@n@/: index of method to get -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIFunctionInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+objectInfoGetMethod info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_method info' n+    checkUnexpectedReturnNULL "objectInfoGetMethod" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_object_info_get_interface+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of interface to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_interface" g_object_info_get_interface :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain an object type interface at index /@n@/.+-}+objectInfoGetInterface ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> Int32+    {- ^ /@n@/: index of interface to get -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIInterfaceInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+objectInfoGetInterface info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_interface info' n+    checkUnexpectedReturnNULL "objectInfoGetInterface" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_object_info_get_get_value_function+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_get_value_function" g_object_info_get_get_value_function :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CString++{- |+Obtain the symbol name of the function that should be called to convert+an object instance pointer of this object type to a GValue.+I\'s mainly used fundamental types. The type signature for the symbol+is @/GIObjectInfoGetValueFunction/@, to fetch the function pointer+see 'GI.GIRepository.Functions.objectInfoGetGetValueFunction'.+-}+objectInfoGetGetValueFunction ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> m T.Text+    {- ^ __Returns:__ the symbol or 'Nothing' -}+objectInfoGetGetValueFunction info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_get_value_function info'+    checkUnexpectedReturnNULL "objectInfoGetGetValueFunction" result+    result' <- cstringToText result+    touchManagedPtr info+    return result'+++-- function g_object_info_get_fundamental+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_fundamental" g_object_info_get_fundamental :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+Obtain if the object type is of a fundamental type which is not+G_TYPE_OBJECT. This is mostly for supporting GstMiniObject.+-}+objectInfoGetFundamental ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> m Bool+    {- ^ __Returns:__ 'True' if the object type is a fundamental type -}+objectInfoGetFundamental info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_fundamental info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'+++-- function g_object_info_get_field+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of field to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_field" g_object_info_get_field :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain an object type field at index /@n@/.+-}+objectInfoGetField ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> Int32+    {- ^ /@n@/: index of field to get -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIFieldInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+objectInfoGetField info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_field info' n+    checkUnexpectedReturnNULL "objectInfoGetField" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_object_info_get_constant+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of constant to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_constant" g_object_info_get_constant :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain an object type constant at index /@n@/.+-}+objectInfoGetConstant ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> Int32+    {- ^ /@n@/: index of constant to get -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIConstantInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+objectInfoGetConstant info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_constant info' n+    checkUnexpectedReturnNULL "objectInfoGetConstant" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_object_info_get_class_struct+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_class_struct" g_object_info_get_class_struct :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Every 'GI.GObject.Objects.Object.Object' has two structures; an instance structure and a class+structure.  This function returns the metadata for the class structure.+-}+objectInfoGetClassStruct ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIStructInfo/@ or 'Nothing'. Free with+@/g_base_info_unref()/@ when done. -}+objectInfoGetClassStruct info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_class_struct info'+    checkUnexpectedReturnNULL "objectInfoGetClassStruct" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_object_info_get_abstract+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_get_abstract" g_object_info_get_abstract :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+Obtain if the object type is an abstract type, eg if it cannot be+instantiated+-}+objectInfoGetAbstract ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> m Bool+    {- ^ __Returns:__ 'True' if the object type is abstract -}+objectInfoGetAbstract info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_object_info_get_abstract info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'+++-- function g_object_info_find_vfunc_using_interfaces+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "name of vfunc to obtain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "implementor", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The implementor of the interface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_find_vfunc_using_interfaces" g_object_info_find_vfunc_using_interfaces :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    CString ->                              -- name : TBasicType TUTF8+    Ptr (Ptr GIRepository.BaseInfo.BaseInfo) -> -- implementor : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Locate a virtual function slot with name /@name@/, searching both the object+/@info@/ and any interfaces it implements.  Note that the namespace for+virtuals is distinct from that of methods; there may or may not be a+concrete method associated for a virtual. If there is one, it may be+retrieved using 'GI.GIRepository.Functions.vfuncInfoGetInvoker', otherwise 'Nothing' will be+returned.++Note that this function does *not* search parent classes; you will have+to chain up if that\'s desired.+-}+objectInfoFindVfuncUsingInterfaces ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> T.Text+    {- ^ /@name@/: name of vfunc to obtain -}+    -> m ((GIRepository.BaseInfo.BaseInfo, GIRepository.BaseInfo.BaseInfo))+    {- ^ __Returns:__ the @/GIVFuncInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+objectInfoFindVfuncUsingInterfaces info name = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    name' <- textToCString name+    implementor <- allocMem :: IO (Ptr (Ptr GIRepository.BaseInfo.BaseInfo))+    result <- g_object_info_find_vfunc_using_interfaces info' name' implementor+    checkUnexpectedReturnNULL "objectInfoFindVfuncUsingInterfaces" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    implementor' <- peek implementor+    implementor'' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) implementor'+    touchManagedPtr info+    freeMem name'+    freeMem implementor+    return (result', implementor'')+++-- function g_object_info_find_vfunc+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 a virtual function to find.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_find_vfunc" g_object_info_find_vfunc :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Locate a virtual function slot with name /@name@/. Note that the namespace+for virtuals is distinct from that of methods; there may or may not be+a concrete method associated for a virtual. If there is one, it may+be retrieved using 'GI.GIRepository.Functions.vfuncInfoGetInvoker', otherwise 'Nothing' will be+returned.+See the documentation for 'GI.GIRepository.Functions.vfuncInfoGetInvoker' for more+information on invoking virtuals.+-}+objectInfoFindVfunc ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> T.Text+    {- ^ /@name@/: The name of a virtual function to find. -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIVFuncInfo/@, or 'Nothing'. Free it with+@/g_base_info_unref()/@ when done. -}+objectInfoFindVfunc info name = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    name' <- textToCString name+    result <- g_object_info_find_vfunc info' name'+    checkUnexpectedReturnNULL "objectInfoFindVfunc" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    freeMem name'+    return result'+++-- function g_object_info_find_signal+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "Name of signal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_find_signal" g_object_info_find_signal :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+TODO+-}+objectInfoFindSignal ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> T.Text+    {- ^ /@name@/: Name of signal -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ Info for the signal with name /@name@/ in /@info@/, or 'Nothing' on failure. -}+objectInfoFindSignal info name = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    name' <- textToCString name+    result <- g_object_info_find_signal info' name'+    checkUnexpectedReturnNULL "objectInfoFindSignal" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    freeMem name'+    return result'+++-- function g_object_info_find_method_using_interfaces+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "name of method to obtain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "implementor", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The implementor of the interface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_find_method_using_interfaces" g_object_info_find_method_using_interfaces :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    CString ->                              -- name : TBasicType TUTF8+    Ptr (Ptr GIRepository.BaseInfo.BaseInfo) -> -- implementor : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain a method of the object given a /@name@/, searching both the+object /@info@/ and any interfaces it implements.  'Nothing' will be+returned if there\'s no method available with that name.++Note that this function does *not* search parent classes; you will have+to chain up if that\'s desired.+-}+objectInfoFindMethodUsingInterfaces ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> T.Text+    {- ^ /@name@/: name of method to obtain -}+    -> m ((GIRepository.BaseInfo.BaseInfo, GIRepository.BaseInfo.BaseInfo))+    {- ^ __Returns:__ the @/GIFunctionInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+objectInfoFindMethodUsingInterfaces info name = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    name' <- textToCString name+    implementor <- allocMem :: IO (Ptr (Ptr GIRepository.BaseInfo.BaseInfo))+    result <- g_object_info_find_method_using_interfaces info' name' implementor+    checkUnexpectedReturnNULL "objectInfoFindMethodUsingInterfaces" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    implementor' <- peek implementor+    implementor'' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) implementor'+    touchManagedPtr info+    freeMem name'+    freeMem implementor+    return (result', implementor'')+++-- function g_object_info_find_method+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "name of method to obtain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_object_info_find_method" g_object_info_find_method :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain a method of the object type given a /@name@/. 'Nothing' will be+returned if there\'s no method available with that name.+-}+objectInfoFindMethod ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIObjectInfo/@ -}+    -> T.Text+    {- ^ /@name@/: name of method to obtain -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIFunctionInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+objectInfoFindMethod info name = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    name' <- textToCString name+    result <- g_object_info_find_method info' name'+    checkUnexpectedReturnNULL "objectInfoFindMethod" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    freeMem name'+    return result'+++-- function g_invoke_error_quark+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUInt32)+-- throws : False+-- Skip return : False++foreign import ccall "g_invoke_error_quark" g_invoke_error_quark :: +    IO Word32++{- |+TODO+-}+invokeErrorQuark ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Word32+    {- ^ __Returns:__ TODO -}+invokeErrorQuark  = liftIO $ do+    result <- g_invoke_error_quark+    return result+++-- function g_interface_info_get_vfunc+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of virtual function to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_interface_info_get_vfunc" g_interface_info_get_vfunc :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain an interface type virtual function at index /@n@/.+-}+interfaceInfoGetVfunc ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIInterfaceInfo/@ -}+    -> Int32+    {- ^ /@n@/: index of virtual function to get -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIVFuncInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+interfaceInfoGetVfunc info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_interface_info_get_vfunc info' n+    checkUnexpectedReturnNULL "interfaceInfoGetVfunc" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_interface_info_get_signal+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of signal to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_interface_info_get_signal" g_interface_info_get_signal :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain an interface type signal at index /@n@/.+-}+interfaceInfoGetSignal ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIInterfaceInfo/@ -}+    -> Int32+    {- ^ /@n@/: index of signal to get -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GISignalInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+interfaceInfoGetSignal info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_interface_info_get_signal info' n+    checkUnexpectedReturnNULL "interfaceInfoGetSignal" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_interface_info_get_property+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of property to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_interface_info_get_property" g_interface_info_get_property :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain an interface type property at index /@n@/.+-}+interfaceInfoGetProperty ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIInterfaceInfo/@ -}+    -> Int32+    {- ^ /@n@/: index of property to get -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIPropertyInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+interfaceInfoGetProperty info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_interface_info_get_property info' n+    checkUnexpectedReturnNULL "interfaceInfoGetProperty" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_interface_info_get_prerequisite+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of prerequisites to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_interface_info_get_prerequisite" g_interface_info_get_prerequisite :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain an interface type prerequisites index /@n@/.+-}+interfaceInfoGetPrerequisite ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIInterfaceInfo/@ -}+    -> Int32+    {- ^ /@n@/: index of prerequisites to get -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the prerequisites as a 'GI.GIRepository.Structs.BaseInfo.BaseInfo'. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+interfaceInfoGetPrerequisite info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_interface_info_get_prerequisite info' n+    checkUnexpectedReturnNULL "interfaceInfoGetPrerequisite" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_interface_info_get_n_vfuncs+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_interface_info_get_n_vfuncs" g_interface_info_get_n_vfuncs :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of virtual functions that this interface type has.+-}+interfaceInfoGetNVfuncs ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIInterfaceInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of virtual functions -}+interfaceInfoGetNVfuncs info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_interface_info_get_n_vfuncs info'+    touchManagedPtr info+    return result+++-- function g_interface_info_get_n_signals+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_interface_info_get_n_signals" g_interface_info_get_n_signals :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of signals that this interface type has.+-}+interfaceInfoGetNSignals ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIInterfaceInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of signals -}+interfaceInfoGetNSignals info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_interface_info_get_n_signals info'+    touchManagedPtr info+    return result+++-- function g_interface_info_get_n_properties+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_interface_info_get_n_properties" g_interface_info_get_n_properties :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of properties that this interface type has.+-}+interfaceInfoGetNProperties ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIInterfaceInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of properties -}+interfaceInfoGetNProperties info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_interface_info_get_n_properties info'+    touchManagedPtr info+    return result+++-- function g_interface_info_get_n_prerequisites+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_interface_info_get_n_prerequisites" g_interface_info_get_n_prerequisites :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of prerequisites for this interface type.+A prerequisites is another interface that needs to be implemented for+interface, similar to an base class for GObjects.+-}+interfaceInfoGetNPrerequisites ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIInterfaceInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of prerequisites -}+interfaceInfoGetNPrerequisites info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_interface_info_get_n_prerequisites info'+    touchManagedPtr info+    return result+++-- function g_interface_info_get_n_methods+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_interface_info_get_n_methods" g_interface_info_get_n_methods :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of methods that this interface type has.+-}+interfaceInfoGetNMethods ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIInterfaceInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of methods -}+interfaceInfoGetNMethods info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_interface_info_get_n_methods info'+    touchManagedPtr info+    return result+++-- function g_interface_info_get_n_constants+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_interface_info_get_n_constants" g_interface_info_get_n_constants :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of constants that this interface type has.+-}+interfaceInfoGetNConstants ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIInterfaceInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of constants -}+interfaceInfoGetNConstants info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_interface_info_get_n_constants info'+    touchManagedPtr info+    return result+++-- function g_interface_info_get_method+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of method to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_interface_info_get_method" g_interface_info_get_method :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain an interface type method at index /@n@/.+-}+interfaceInfoGetMethod ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIInterfaceInfo/@ -}+    -> Int32+    {- ^ /@n@/: index of method to get -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIFunctionInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+interfaceInfoGetMethod info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_interface_info_get_method info' n+    checkUnexpectedReturnNULL "interfaceInfoGetMethod" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_interface_info_get_iface_struct+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_interface_info_get_iface_struct" g_interface_info_get_iface_struct :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Returns the layout C structure associated with this @/GInterface/@.+-}+interfaceInfoGetIfaceStruct ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIInterfaceInfo/@ -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIStructInfo/@ or 'Nothing'. Free it with+@/g_base_info_unref()/@ when done. -}+interfaceInfoGetIfaceStruct info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_interface_info_get_iface_struct info'+    checkUnexpectedReturnNULL "interfaceInfoGetIfaceStruct" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_interface_info_get_constant+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of constant to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_interface_info_get_constant" g_interface_info_get_constant :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain an interface type constant at index /@n@/.+-}+interfaceInfoGetConstant ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIInterfaceInfo/@ -}+    -> Int32+    {- ^ /@n@/: index of constant to get -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIConstantInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+interfaceInfoGetConstant info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_interface_info_get_constant info' n+    checkUnexpectedReturnNULL "interfaceInfoGetConstant" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_interface_info_find_vfunc+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", 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 a virtual function to find.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_interface_info_find_vfunc" g_interface_info_find_vfunc :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Locate a virtual function slot with name /@name@/. See the documentation+for 'GI.GIRepository.Functions.objectInfoFindVfunc' for more information on virtuals.+-}+interfaceInfoFindVfunc ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIInterfaceInfo/@ -}+    -> T.Text+    {- ^ /@name@/: The name of a virtual function to find. -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIVFuncInfo/@, or 'Nothing'. Free it with+@/g_base_info_unref()/@ when done. -}+interfaceInfoFindVfunc info name = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    name' <- textToCString name+    result <- g_interface_info_find_vfunc info' name'+    checkUnexpectedReturnNULL "interfaceInfoFindVfunc" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    freeMem name'+    return result'+++-- function g_interface_info_find_signal+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", 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 "Name of signal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_interface_info_find_signal" g_interface_info_find_signal :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+TODO++/Since: 1.34/+-}+interfaceInfoFindSignal ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIInterfaceInfo/@ -}+    -> T.Text+    {- ^ /@name@/: Name of signal -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ Info for the signal with name /@name@/ in /@info@/, or+'Nothing' on failure. -}+interfaceInfoFindSignal info name = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    name' <- textToCString name+    result <- g_interface_info_find_signal info' name'+    checkUnexpectedReturnNULL "interfaceInfoFindSignal" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    freeMem name'+    return result'+++-- function g_interface_info_find_method+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", 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 "name of method to obtain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_interface_info_find_method" g_interface_info_find_method :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain a method of the interface type given a /@name@/. 'Nothing' will be+returned if there\'s no method available with that name.+-}+interfaceInfoFindMethod ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIInterfaceInfo/@ -}+    -> T.Text+    {- ^ /@name@/: name of method to obtain -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIFunctionInfo/@ or 'Nothing' if none found.+Free the struct by calling @/g_base_info_unref()/@ when done. -}+interfaceInfoFindMethod info name = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    name' <- textToCString name+    result <- g_interface_info_find_method info' name'+    checkUnexpectedReturnNULL "interfaceInfoFindMethod" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    freeMem name'+    return result'+++-- function g_info_type_to_string+-- Args : [Arg {argCName = "type", argType = TInterface (Name {namespace = "GIRepository", name = "InfoType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the info type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_info_type_to_string" g_info_type_to_string :: +    CUInt ->                                -- type : TInterface (Name {namespace = "GIRepository", name = "InfoType"})+    IO CString++{- |+Obtain a string representation of /@type@/+-}+infoTypeToString ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.Enums.InfoType+    {- ^ /@type@/: the info type -}+    -> m T.Text+    {- ^ __Returns:__ the string -}+infoTypeToString type_ = liftIO $ do+    let type_' = (fromIntegral . fromEnum) type_+    result <- g_info_type_to_string type_'+    checkUnexpectedReturnNULL "infoTypeToString" result+    result' <- cstringToText result+    return result'+++-- function g_info_new+-- Args : [Arg {argCName = "type", argType = TInterface (Name {namespace = "GIRepository", name = "InfoType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "container", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "typelib", argType = TInterface (Name {namespace = "GIRepository", name = "Typelib"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_info_new" g_info_new :: +    CUInt ->                                -- type : TInterface (Name {namespace = "GIRepository", name = "InfoType"})+    Ptr GIRepository.BaseInfo.BaseInfo ->   -- container : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Ptr GIRepository.Typelib.Typelib ->     -- typelib : TInterface (Name {namespace = "GIRepository", name = "Typelib"})+    Word32 ->                               -- offset : TBasicType TUInt32+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+TODO+-}+infoNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.Enums.InfoType+    {- ^ /@type@/: TODO -}+    -> GIRepository.BaseInfo.BaseInfo+    {- ^ /@container@/: TODO -}+    -> GIRepository.Typelib.Typelib+    {- ^ /@typelib@/: TODO -}+    -> Word32+    {- ^ /@offset@/: TODO -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ TODO -}+infoNew type_ container typelib offset = liftIO $ do+    let type_' = (fromIntegral . fromEnum) type_+    container' <- unsafeManagedPtrGetPtr container+    typelib' <- unsafeManagedPtrGetPtr typelib+    result <- g_info_new type_' container' typelib' offset+    checkUnexpectedReturnNULL "infoNew" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr container+    touchManagedPtr typelib+    return result'+++-- function g_function_info_get_vfunc+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIFunctionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_function_info_get_vfunc" g_function_info_get_vfunc :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the virtual function associated with this @/GIFunctionInfo/@.+Only @/GIFunctionInfo/@ with the flag 'GI.GIRepository.Flags.FunctionInfoFlagsWrapsVfunc' has+a virtual function set. For other cases, 'Nothing' will be returned.+-}+functionInfoGetVfunc ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIFunctionInfo/@ -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the virtual function or 'Nothing' if not set.+Free it by calling @/g_base_info_unref()/@ when done. -}+functionInfoGetVfunc info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_function_info_get_vfunc info'+    checkUnexpectedReturnNULL "functionInfoGetVfunc" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_function_info_get_symbol+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIFunctionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_function_info_get_symbol" g_function_info_get_symbol :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CString++{- |+Obtain the symbol of the function. The symbol is the name of the+exported function, suitable to be used as an argument to+@/g_module_symbol()/@.+-}+functionInfoGetSymbol ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIFunctionInfo/@ -}+    -> m T.Text+    {- ^ __Returns:__ the symbol -}+functionInfoGetSymbol info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_function_info_get_symbol info'+    checkUnexpectedReturnNULL "functionInfoGetSymbol" result+    result' <- cstringToText result+    touchManagedPtr info+    return result'+++-- function g_function_info_get_property+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIFunctionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_function_info_get_property" g_function_info_get_property :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the property associated with this @/GIFunctionInfo/@.+Only @/GIFunctionInfo/@ with the flag 'GI.GIRepository.Flags.FunctionInfoFlagsIsGetter' or+'GI.GIRepository.Flags.FunctionInfoFlagsIsSetter' have a property set. For other cases,+'Nothing' will be returned.+-}+functionInfoGetProperty ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIFunctionInfo/@ -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the property or 'Nothing' if not set. Free it with+@/g_base_info_unref()/@ when done. -}+functionInfoGetProperty info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_function_info_get_property info'+    checkUnexpectedReturnNULL "functionInfoGetProperty" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_function_info_get_flags+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIFunctionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "FunctionInfoFlags"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_function_info_get_flags" g_function_info_get_flags :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CUInt++{- |+Obtain the 'GI.GIRepository.Flags.FunctionInfoFlags' for the /@info@/.+-}+functionInfoGetFlags ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIFunctionInfo/@ -}+    -> m [GIRepository.Flags.FunctionInfoFlags]+    {- ^ __Returns:__ the flags -}+functionInfoGetFlags info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_function_info_get_flags info'+    let result' = wordToGFlags result+    touchManagedPtr info+    return result'+++-- function g_field_info_get_type+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIFieldInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_field_info_get_type" g_field_info_get_type :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the type of a field as a @/GITypeInfo/@.+-}+fieldInfoGetType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIFieldInfo/@ -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GITypeInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+fieldInfoGetType info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_field_info_get_type info'+    checkUnexpectedReturnNULL "fieldInfoGetType" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_field_info_get_size+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIFieldInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_field_info_get_size" g_field_info_get_size :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the size in bits of the field member, this is how+much space you need to allocate to store the field.+-}+fieldInfoGetSize ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIFieldInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ the field size -}+fieldInfoGetSize info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_field_info_get_size info'+    touchManagedPtr info+    return result+++-- function g_field_info_get_offset+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIFieldInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_field_info_get_offset" g_field_info_get_offset :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the offset in bytes of the field member, this is relative+to the beginning of the struct or union.+-}+fieldInfoGetOffset ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIFieldInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ the field offset -}+fieldInfoGetOffset info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_field_info_get_offset info'+    touchManagedPtr info+    return result+++-- function g_field_info_get_flags+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIFieldInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "FieldInfoFlags"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_field_info_get_flags" g_field_info_get_flags :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CUInt++{- |+Obtain the flags for this @/GIFieldInfo/@. See 'GI.GIRepository.Flags.FieldInfoFlags' for possible+flag values.+-}+fieldInfoGetFlags ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIFieldInfo/@ -}+    -> m [GIRepository.Flags.FieldInfoFlags]+    {- ^ __Returns:__ the flags -}+fieldInfoGetFlags info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_field_info_get_flags info'+    let result' = wordToGFlags result+    touchManagedPtr info+    return result'+++-- function g_enum_info_get_value+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIEnumInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of value to fetch", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_enum_info_get_value" g_enum_info_get_value :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain a value for this enumeration.+-}+enumInfoGetValue ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIEnumInfo/@ -}+    -> Int32+    {- ^ /@n@/: index of value to fetch -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the enumeration value or 'Nothing' if type tag is wrong,+free the struct with @/g_base_info_unref()/@ when done. -}+enumInfoGetValue info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_enum_info_get_value info' n+    checkUnexpectedReturnNULL "enumInfoGetValue" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_enum_info_get_storage_type+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIEnumInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "TypeTag"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_enum_info_get_storage_type" g_enum_info_get_storage_type :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CUInt++{- |+Obtain the tag of the type used for the enum in the C ABI. This will+will be a signed or unsigned integral type.++Note that in the current implementation the width of the type is+computed correctly, but the signed or unsigned nature of the type+may not match the sign of the type used by the C compiler.+-}+enumInfoGetStorageType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIEnumInfo/@ -}+    -> m GIRepository.Enums.TypeTag+    {- ^ __Returns:__ the storage type for the enumeration -}+enumInfoGetStorageType info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_enum_info_get_storage_type info'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr info+    return result'+++-- function g_enum_info_get_n_values+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIEnumInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_enum_info_get_n_values" g_enum_info_get_n_values :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of values this enumeration contains.+-}+enumInfoGetNValues ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIEnumInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ the number of enumeration values -}+enumInfoGetNValues info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_enum_info_get_n_values info'+    touchManagedPtr info+    return result+++-- function g_enum_info_get_n_methods+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIEnumInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_enum_info_get_n_methods" g_enum_info_get_n_methods :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of methods that this enum type has.++/Since: 1.30/+-}+enumInfoGetNMethods ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIEnumInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ number of methods -}+enumInfoGetNMethods info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_enum_info_get_n_methods info'+    touchManagedPtr info+    return result+++-- function g_enum_info_get_method+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIEnumInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of method to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_enum_info_get_method" g_enum_info_get_method :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain an enum type method at index /@n@/.++/Since: 1.30/+-}+enumInfoGetMethod ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIEnumInfo/@ -}+    -> Int32+    {- ^ /@n@/: index of method to get -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIFunctionInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+enumInfoGetMethod info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_enum_info_get_method info' n+    checkUnexpectedReturnNULL "enumInfoGetMethod" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_enum_info_get_error_domain+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIEnumInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_enum_info_get_error_domain" g_enum_info_get_error_domain :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CString++{- |+Obtain the string form of the quark for the error domain associated with+this enum, if any.++/Since: 1.30/+-}+enumInfoGetErrorDomain ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIEnumInfo/@ -}+    -> m T.Text+    {- ^ __Returns:__ the string form of the error domain associated+with this enum, or 'Nothing'. -}+enumInfoGetErrorDomain info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_enum_info_get_error_domain info'+    checkUnexpectedReturnNULL "enumInfoGetErrorDomain" result+    result' <- cstringToText result+    touchManagedPtr info+    return result'+++-- function g_constant_info_get_type+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIConstantInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_constant_info_get_type" g_constant_info_get_type :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the type of the constant as a @/GITypeInfo/@.+-}+constantInfoGetType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIConstantInfo/@ -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GITypeInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+constantInfoGetType info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_constant_info_get_type info'+    checkUnexpectedReturnNULL "constantInfoGetType" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function gi_cclosure_marshal_generic+-- Args : [Arg {argCName = "closure", argType = TGClosure Nothing, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_gvalue", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_param_values", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "param_values", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "invocation_hint", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "marshal_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gi_cclosure_marshal_generic" gi_cclosure_marshal_generic :: +    Ptr (GClosure ()) ->                    -- closure : TGClosure Nothing+    Ptr GValue ->                           -- return_gvalue : TInterface (Name {namespace = "GObject", name = "Value"})+    Word32 ->                               -- n_param_values : TBasicType TUInt+    Ptr GValue ->                           -- param_values : TInterface (Name {namespace = "GObject", name = "Value"})+    Ptr () ->                               -- invocation_hint : TBasicType TPtr+    Ptr () ->                               -- marshal_data : TBasicType TPtr+    IO ()++{- |+/No description available in the introspection data./+-}+cclosureMarshalGeneric ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GClosure a+    -> GValue+    -> Word32+    -> GValue+    -> Ptr ()+    -> Ptr ()+    -> m ()+cclosureMarshalGeneric closure returnGvalue nParamValues paramValues invocationHint marshalData = liftIO $ do+    closure' <- unsafeManagedPtrCastPtr closure+    returnGvalue' <- unsafeManagedPtrGetPtr returnGvalue+    paramValues' <- unsafeManagedPtrGetPtr paramValues+    gi_cclosure_marshal_generic closure' returnGvalue' nParamValues paramValues' invocationHint marshalData+    touchManagedPtr closure+    touchManagedPtr returnGvalue+    touchManagedPtr paramValues+    return ()+++-- function g_callable_info_skip_return+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_callable_info_skip_return" g_callable_info_skip_return :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+See if a callable\'s return value is only useful in C.+-}+callableInfoSkipReturn ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GICallableInfo/@ -}+    -> m Bool+    {- ^ __Returns:__ 'True' if return value is only useful in C. -}+callableInfoSkipReturn info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_callable_info_skip_return info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'+++-- function g_callable_info_may_return_null+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_callable_info_may_return_null" g_callable_info_may_return_null :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+See if a callable could return 'Nothing'.+-}+callableInfoMayReturnNull ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GICallableInfo/@ -}+    -> m Bool+    {- ^ __Returns:__ 'True' if callable could return 'Nothing' -}+callableInfoMayReturnNull info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_callable_info_may_return_null info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'+++-- function g_callable_info_load_return_type+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Initialized with return type of @info", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "g_callable_info_load_return_type" g_callable_info_load_return_type :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Ptr GIRepository.BaseInfo.BaseInfo ->   -- type : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO ()++{- |+Obtain information about a return value of callable; this+function is a variant of 'GI.GIRepository.Functions.callableInfoGetReturnType' designed for stack+allocation.++The initialized /@type@/ must not be referenced after /@info@/ is deallocated.+-}+callableInfoLoadReturnType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GICallableInfo/@ -}+    -> m (GIRepository.BaseInfo.BaseInfo)+callableInfoLoadReturnType info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    type_ <- callocBoxedBytes 72 :: IO (Ptr GIRepository.BaseInfo.BaseInfo)+    g_callable_info_load_return_type info' type_+    type_' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) type_+    touchManagedPtr info+    return type_'+++-- function g_callable_info_load_arg+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the argument index to fetch", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "arg", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Initialize with argument number @n", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "g_callable_info_load_arg" g_callable_info_load_arg :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    Ptr GIRepository.BaseInfo.BaseInfo ->   -- arg : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO ()++{- |+Obtain information about a particular argument of this callable; this+function is a variant of 'GI.GIRepository.Functions.callableInfoGetArg' designed for stack+allocation.++The initialized /@arg@/ must not be referenced after /@info@/ is deallocated.+-}+callableInfoLoadArg ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GICallableInfo/@ -}+    -> Int32+    {- ^ /@n@/: the argument index to fetch -}+    -> m (GIRepository.BaseInfo.BaseInfo)+callableInfoLoadArg info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    arg <- callocBoxedBytes 72 :: IO (Ptr GIRepository.BaseInfo.BaseInfo)+    g_callable_info_load_arg info' n arg+    arg' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) arg+    touchManagedPtr info+    return arg'+++-- function g_callable_info_iterate_return_attributes+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iterator", argType = TInterface (Name {namespace = "GIRepository", name = "AttributeIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIAttributeIter structure, must be initialized; see below", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Returned name, must not be freed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Returned name, must not be freed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_callable_info_iterate_return_attributes" g_callable_info_iterate_return_attributes :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Ptr GIRepository.AttributeIter.AttributeIter -> -- iterator : TInterface (Name {namespace = "GIRepository", name = "AttributeIter"})+    Ptr CString ->                          -- name : TBasicType TUTF8+    Ptr CString ->                          -- value : TBasicType TUTF8+    IO CInt++{- |+Iterate over all attributes associated with the return value.  The+iterator structure is typically stack allocated, and must have its+first member initialized to 'Nothing'.++Both the /@name@/ and /@value@/ should be treated as constants+and must not be freed.++See 'GI.GIRepository.Structs.BaseInfo.baseInfoIterateAttributes' for an example of how to use a+similar API.+-}+callableInfoIterateReturnAttributes ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GICallableInfo/@ -}+    -> GIRepository.AttributeIter.AttributeIter+    {- ^ /@iterator@/: a 'GI.GIRepository.Structs.AttributeIter.AttributeIter' structure, must be initialized; see below -}+    -> m ((Bool, T.Text, T.Text))+    {- ^ __Returns:__ 'True' if there are more attributes -}+callableInfoIterateReturnAttributes info iterator = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    iterator' <- unsafeManagedPtrGetPtr iterator+    name <- allocMem :: IO (Ptr CString)+    value <- allocMem :: IO (Ptr CString)+    result <- g_callable_info_iterate_return_attributes info' iterator' name value+    let result' = (/= 0) result+    name' <- peek name+    name'' <- cstringToText name'+    value' <- peek value+    value'' <- cstringToText value'+    touchManagedPtr info+    touchManagedPtr iterator+    freeMem name+    freeMem value+    return (result', name'', value'')+++-- function g_callable_info_is_method+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_callable_info_is_method" g_callable_info_is_method :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+Determines if the callable info is a method. For @/GIVFuncInfo/@\<!-- -->s,+@/GICallbackInfo/@\<!-- -->s, and @/GISignalInfo/@\<!-- -->s,+this is always true. Otherwise, this looks at the 'GI.GIRepository.Flags.FunctionInfoFlagsIsMethod'+flag on the @/GIFunctionInfo/@.++Concretely, this function returns whether 'GI.GIRepository.Functions.callableInfoGetNArgs'+matches the number of arguments in the raw C method. For methods, there+is one more C argument than is exposed by introspection: the \"self\"+or \"this\" object.++/Since: 1.34/+-}+callableInfoIsMethod ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GICallableInfo/@ -}+    -> m Bool+    {- ^ __Returns:__ 'True' if /@info@/ is a method, 'False' otherwise -}+callableInfoIsMethod info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_callable_info_is_method info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'+++-- function g_callable_info_invoke+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "function", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "in_args", argType = TCArray False (-1) 3 (TInterface (Name {namespace = "GIRepository", name = "Argument"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_in_args", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_args", argType = TCArray False (-1) 5 (TInterface (Name {namespace = "GIRepository", name = "Argument"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_out_args", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_value", argType = TInterface (Name {namespace = "GIRepository", name = "Argument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_method", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "throws", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "n_out_args", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_in_args", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Just (TBasicType TBoolean)+-- throws : True+-- Skip return : False++foreign import ccall "g_callable_info_invoke" g_callable_info_invoke :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Ptr () ->                               -- function : TBasicType TPtr+    Ptr GIRepository.Argument.Argument ->   -- in_args : TCArray False (-1) 3 (TInterface (Name {namespace = "GIRepository", name = "Argument"}))+    Int32 ->                                -- n_in_args : TBasicType TInt+    Ptr GIRepository.Argument.Argument ->   -- out_args : TCArray False (-1) 5 (TInterface (Name {namespace = "GIRepository", name = "Argument"}))+    Int32 ->                                -- n_out_args : TBasicType TInt+    Ptr GIRepository.Argument.Argument ->   -- return_value : TInterface (Name {namespace = "GIRepository", name = "Argument"})+    CInt ->                                 -- is_method : TBasicType TBoolean+    CInt ->                                 -- throws : TBasicType TBoolean+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{- |+TODO+-}+callableInfoInvoke ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: TODO -}+    -> Ptr ()+    {- ^ /@function@/: TODO -}+    -> [GIRepository.Argument.Argument]+    {- ^ /@inArgs@/: TODO -}+    -> [GIRepository.Argument.Argument]+    {- ^ /@outArgs@/: TODO -}+    -> GIRepository.Argument.Argument+    {- ^ /@returnValue@/: TODO -}+    -> Bool+    {- ^ /@isMethod@/: TODO -}+    -> Bool+    {- ^ /@throws@/: TODO -}+    -> m ()+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+callableInfoInvoke info function inArgs outArgs returnValue isMethod throws = liftIO $ do+    let nOutArgs = fromIntegral $ length outArgs+    let nInArgs = fromIntegral $ length inArgs+    info' <- unsafeManagedPtrGetPtr info+    inArgs' <- mapM unsafeManagedPtrGetPtr inArgs+    inArgs'' <- packBlockArray 8 inArgs'+    outArgs' <- mapM unsafeManagedPtrGetPtr outArgs+    outArgs'' <- packBlockArray 8 outArgs'+    returnValue' <- unsafeManagedPtrGetPtr returnValue+    let isMethod' = (fromIntegral . fromEnum) isMethod+    let throws' = (fromIntegral . fromEnum) throws+    onException (do+        _ <- propagateGError $ g_callable_info_invoke info' function inArgs'' nInArgs outArgs'' nOutArgs returnValue' isMethod' throws'+        touchManagedPtr info+        mapM_ touchManagedPtr inArgs+        mapM_ touchManagedPtr outArgs+        touchManagedPtr returnValue+        freeMem inArgs''+        freeMem outArgs''+        return ()+     ) (do+        freeMem inArgs''+        freeMem outArgs''+     )+++-- function g_callable_info_get_return_type+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_callable_info_get_return_type" g_callable_info_get_return_type :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the return type of a callable item as a @/GITypeInfo/@.+-}+callableInfoGetReturnType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GICallableInfo/@ -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GITypeInfo/@. Free the struct by calling+@/g_base_info_unref()/@ when done. -}+callableInfoGetReturnType info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_callable_info_get_return_type info'+    checkUnexpectedReturnNULL "callableInfoGetReturnType" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_callable_info_get_return_attribute+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", 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 "a freeform string naming an attribute", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_callable_info_get_return_attribute" g_callable_info_get_return_attribute :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    CString ->                              -- name : TBasicType TUTF8+    IO CString++{- |+Retrieve an arbitrary attribute associated with the return value.+-}+callableInfoGetReturnAttribute ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GICallableInfo/@ -}+    -> T.Text+    {- ^ /@name@/: a freeform string naming an attribute -}+    -> m T.Text+    {- ^ __Returns:__ The value of the attribute, or 'Nothing' if no such attribute exists -}+callableInfoGetReturnAttribute info name = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    name' <- textToCString name+    result <- g_callable_info_get_return_attribute info' name'+    checkUnexpectedReturnNULL "callableInfoGetReturnAttribute" result+    result' <- cstringToText result+    touchManagedPtr info+    freeMem name'+    return result'+++-- function g_callable_info_get_n_args+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_callable_info_get_n_args" g_callable_info_get_n_args :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the number of arguments (both IN and OUT) for this callable.+-}+callableInfoGetNArgs ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GICallableInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ The number of arguments this callable expects. -}+callableInfoGetNArgs info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_callable_info_get_n_args info'+    touchManagedPtr info+    return result+++-- function g_callable_info_get_instance_ownership_transfer+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Transfer"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_callable_info_get_instance_ownership_transfer" g_callable_info_get_instance_ownership_transfer :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CUInt++{- |+Obtains the ownership transfer for the instance argument.+'GI.GIRepository.Enums.Transfer' contains a list of possible transfer values.++/Since: 1.42/+-}+callableInfoGetInstanceOwnershipTransfer ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GICallableInfo/@ -}+    -> m GIRepository.Enums.Transfer+    {- ^ __Returns:__ the transfer mode of the instance argument -}+callableInfoGetInstanceOwnershipTransfer info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_callable_info_get_instance_ownership_transfer info'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr info+    return result'+++-- function g_callable_info_get_caller_owns+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Transfer"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_callable_info_get_caller_owns" g_callable_info_get_caller_owns :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CUInt++{- |+See whether the caller owns the return value of this callable.+'GI.GIRepository.Enums.Transfer' contains a list of possible transfer values.+-}+callableInfoGetCallerOwns ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GICallableInfo/@ -}+    -> m GIRepository.Enums.Transfer+    {- ^ __Returns:__ the transfer mode for the return value of the callable -}+callableInfoGetCallerOwns info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_callable_info_get_caller_owns info'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr info+    return result'+++-- function g_callable_info_get_arg+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the argument index to fetch", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_callable_info_get_arg" g_callable_info_get_arg :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Int32 ->                                -- n : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain information about a particular argument of this callable.+-}+callableInfoGetArg ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GICallableInfo/@ -}+    -> Int32+    {- ^ /@n@/: the argument index to fetch -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GIArgInfo/@. Free it with+@/g_base_info_unref()/@ when done. -}+callableInfoGetArg info n = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_callable_info_get_arg info' n+    checkUnexpectedReturnNULL "callableInfoGetArg" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_callable_info_can_throw_gerror+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_callable_info_can_throw_gerror" g_callable_info_can_throw_gerror :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+TODO++/Since: 1.34/+-}+callableInfoCanThrowGerror ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GICallableInfo/@ -}+    -> m Bool+    {- ^ __Returns:__ 'True' if this @/GICallableInfo/@ can throw a 'GError' -}+callableInfoCanThrowGerror info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_callable_info_can_throw_gerror info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'+++-- function g_arg_info_may_be_null+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_arg_info_may_be_null" g_arg_info_may_be_null :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+Obtain if the type of the argument includes the possibility of 'Nothing'.+For \'in\' values this means that 'Nothing' is a valid value.  For \'out\'+values, this means that 'Nothing' may be returned.++See also 'GI.GIRepository.Functions.argInfoIsOptional'.+-}+argInfoMayBeNull ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIArgInfo/@ -}+    -> m Bool+    {- ^ __Returns:__ 'True' if the value may be 'Nothing' -}+argInfoMayBeNull info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_arg_info_may_be_null info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'+++-- function g_arg_info_load_type+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Initialized with information about type of @info", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "g_arg_info_load_type" g_arg_info_load_type :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Ptr GIRepository.BaseInfo.BaseInfo ->   -- type : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO ()++{- |+Obtain information about a the type of given argument /@info@/; this+function is a variant of 'GI.GIRepository.Functions.argInfoGetType' designed for stack+allocation.++The initialized /@type@/ must not be referenced after /@info@/ is deallocated.+-}+argInfoLoadType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIArgInfo/@ -}+    -> m (GIRepository.BaseInfo.BaseInfo)+argInfoLoadType info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    type_ <- callocBoxedBytes 72 :: IO (Ptr GIRepository.BaseInfo.BaseInfo)+    g_arg_info_load_type info' type_+    type_' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) type_+    touchManagedPtr info+    return type_'+++-- function g_arg_info_is_skip+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_arg_info_is_skip" g_arg_info_is_skip :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+Obtain if an argument is only useful in C.++/Since: 1.30/+-}+argInfoIsSkip ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIArgInfo/@ -}+    -> m Bool+    {- ^ __Returns:__ 'True' if argument is only useful in C. -}+argInfoIsSkip info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_arg_info_is_skip info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'+++-- function g_arg_info_is_return_value+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_arg_info_is_return_value" g_arg_info_is_return_value :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+Obtain if the argument is a return value. It can either be a+parameter or a return value.+-}+argInfoIsReturnValue ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIArgInfo/@ -}+    -> m Bool+    {- ^ __Returns:__ 'True' if it is a return value -}+argInfoIsReturnValue info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_arg_info_is_return_value info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'+++-- function g_arg_info_is_optional+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_arg_info_is_optional" g_arg_info_is_optional :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+Obtain if the argument is optional.  For \'out\' arguments this means+that you can pass 'Nothing' in order to ignore the result.+-}+argInfoIsOptional ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIArgInfo/@ -}+    -> m Bool+    {- ^ __Returns:__ 'True' if it is an optional argument -}+argInfoIsOptional info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_arg_info_is_optional info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'+++-- function g_arg_info_is_caller_allocates+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_arg_info_is_caller_allocates" g_arg_info_is_caller_allocates :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+Obtain if the argument is a pointer to a struct or object that will+receive an output of a function.  The default assumption for+'GI.GIRepository.Enums.DirectionOut' arguments which have allocation is that the+callee allocates; if this is 'True', then the caller must allocate.+-}+argInfoIsCallerAllocates ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIArgInfo/@ -}+    -> m Bool+    {- ^ __Returns:__ 'True' if caller is required to have allocated the argument -}+argInfoIsCallerAllocates info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_arg_info_is_caller_allocates info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'+++-- function g_arg_info_get_type+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_arg_info_get_type" g_arg_info_get_type :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Obtain the type information for /@info@/.+-}+argInfoGetType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIArgInfo/@ -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ the @/GITypeInfo/@ holding the type+  information for /@info@/, free it with @/g_base_info_unref()/@+  when done. -}+argInfoGetType info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_arg_info_get_type info'+    checkUnexpectedReturnNULL "argInfoGetType" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr info+    return result'+++-- function g_arg_info_get_scope+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "ScopeType"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_arg_info_get_scope" g_arg_info_get_scope :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CUInt++{- |+Obtain the scope type for this argument. The scope type explains+how a callback is going to be invoked, most importantly when+the resources required to invoke it can be freed.+'GI.GIRepository.Enums.ScopeType' contains a list of possible values.+-}+argInfoGetScope ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIArgInfo/@ -}+    -> m GIRepository.Enums.ScopeType+    {- ^ __Returns:__ the scope type -}+argInfoGetScope info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_arg_info_get_scope info'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr info+    return result'+++-- function g_arg_info_get_ownership_transfer+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Transfer"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_arg_info_get_ownership_transfer" g_arg_info_get_ownership_transfer :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CUInt++{- |+Obtain the ownership transfer for this argument.+'GI.GIRepository.Enums.Transfer' contains a list of possible values.+-}+argInfoGetOwnershipTransfer ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIArgInfo/@ -}+    -> m GIRepository.Enums.Transfer+    {- ^ __Returns:__ the transfer -}+argInfoGetOwnershipTransfer info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_arg_info_get_ownership_transfer info'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr info+    return result'+++-- function g_arg_info_get_direction+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Direction"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_arg_info_get_direction" g_arg_info_get_direction :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CUInt++{- |+Obtain the direction of the argument. Check 'GI.GIRepository.Enums.Direction' for possible+direction values.+-}+argInfoGetDirection ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIArgInfo/@ -}+    -> m GIRepository.Enums.Direction+    {- ^ __Returns:__ the direction -}+argInfoGetDirection info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_arg_info_get_direction info'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr info+    return result'+++-- function g_arg_info_get_destroy+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_arg_info_get_destroy" g_arg_info_get_destroy :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtains the index of the 'GI.GLib.Callbacks.DestroyNotify' argument. This is only valid+for arguments which are callbacks.+-}+argInfoGetDestroy ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIArgInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ index of the 'GI.GLib.Callbacks.DestroyNotify' argument or -1 if there is none -}+argInfoGetDestroy info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_arg_info_get_destroy info'+    touchManagedPtr info+    return result+++-- function g_arg_info_get_closure+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_arg_info_get_closure" g_arg_info_get_closure :: +    Ptr GIRepository.BaseInfo.BaseInfo ->   -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO Int32++{- |+Obtain the index of the user data argument. This is only valid+for arguments which are callbacks.+-}+argInfoGetClosure ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GIRepository.BaseInfo.BaseInfo+    {- ^ /@info@/: a @/GIArgInfo/@ -}+    -> m Int32+    {- ^ __Returns:__ index of the user data argument or -1 if there is none -}+argInfoGetClosure info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_arg_info_get_closure info'+    touchManagedPtr info+    return result+++

@@ -0,0 +1,41 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GIRepository.Objects+    (     module GI.GIRepository.Objects.Repository,+++    ) where++import GI.GIRepository.Objects.Repository++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.ManagedPtr as B.ManagedPtr+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.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+++

@@ -0,0 +1,1461 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++'GI.GIRepository.Objects.Repository.Repository' is used to manage repositories of namespaces. Namespaces+are represented on disk by type libraries (.typelib files).++=== Discovery of type libraries++'GI.GIRepository.Objects.Repository.Repository' will typically look for a @girepository-1.0@ directory+under the library directory used when compiling gobject-introspection.++It is possible to control the search paths programmatically, using+'GI.GIRepository.Objects.Repository.repositoryPrependSearchPath'. It is also possible to modify+the search paths by using the @GI_TYPELIB_PATH@ environment variable.+The environment variable takes precedence over the default search path+and the 'GI.GIRepository.Objects.Repository.repositoryPrependSearchPath' calls.+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GIRepository.Objects.Repository+    ( ++-- * Exported types+    Repository(..)                          ,+    IsRepository                            ,+    toRepository                            ,+    noRepository                            ,+++ -- * Methods+-- ** dump #method:dump#++    repositoryDump                          ,+++-- ** enumerateVersions #method:enumerateVersions#++#if ENABLE_OVERLOADING+    RepositoryEnumerateVersionsMethodInfo   ,+#endif+    repositoryEnumerateVersions             ,+++-- ** errorQuark #method:errorQuark#++    repositoryErrorQuark                    ,+++-- ** findByErrorDomain #method:findByErrorDomain#++#if ENABLE_OVERLOADING+    RepositoryFindByErrorDomainMethodInfo   ,+#endif+    repositoryFindByErrorDomain             ,+++-- ** findByGtype #method:findByGtype#++#if ENABLE_OVERLOADING+    RepositoryFindByGtypeMethodInfo         ,+#endif+    repositoryFindByGtype                   ,+++-- ** findByName #method:findByName#++#if ENABLE_OVERLOADING+    RepositoryFindByNameMethodInfo          ,+#endif+    repositoryFindByName                    ,+++-- ** getCPrefix #method:getCPrefix#++#if ENABLE_OVERLOADING+    RepositoryGetCPrefixMethodInfo          ,+#endif+    repositoryGetCPrefix                    ,+++-- ** getDefault #method:getDefault#++    repositoryGetDefault                    ,+++-- ** getDependencies #method:getDependencies#++#if ENABLE_OVERLOADING+    RepositoryGetDependenciesMethodInfo     ,+#endif+    repositoryGetDependencies               ,+++-- ** getImmediateDependencies #method:getImmediateDependencies#++#if ENABLE_OVERLOADING+    RepositoryGetImmediateDependenciesMethodInfo,+#endif+    repositoryGetImmediateDependencies      ,+++-- ** getInfo #method:getInfo#++#if ENABLE_OVERLOADING+    RepositoryGetInfoMethodInfo             ,+#endif+    repositoryGetInfo                       ,+++-- ** getLoadedNamespaces #method:getLoadedNamespaces#++#if ENABLE_OVERLOADING+    RepositoryGetLoadedNamespacesMethodInfo ,+#endif+    repositoryGetLoadedNamespaces           ,+++-- ** getNInfos #method:getNInfos#++#if ENABLE_OVERLOADING+    RepositoryGetNInfosMethodInfo           ,+#endif+    repositoryGetNInfos                     ,+++-- ** getObjectGtypeInterfaces #method:getObjectGtypeInterfaces#++#if ENABLE_OVERLOADING+    RepositoryGetObjectGtypeInterfacesMethodInfo,+#endif+    repositoryGetObjectGtypeInterfaces      ,+++-- ** getOptionGroup #method:getOptionGroup#++    repositoryGetOptionGroup                ,+++-- ** getSearchPath #method:getSearchPath#++    repositoryGetSearchPath                 ,+++-- ** getSharedLibrary #method:getSharedLibrary#++#if ENABLE_OVERLOADING+    RepositoryGetSharedLibraryMethodInfo    ,+#endif+    repositoryGetSharedLibrary              ,+++-- ** getTypelibPath #method:getTypelibPath#++#if ENABLE_OVERLOADING+    RepositoryGetTypelibPathMethodInfo      ,+#endif+    repositoryGetTypelibPath                ,+++-- ** getVersion #method:getVersion#++#if ENABLE_OVERLOADING+    RepositoryGetVersionMethodInfo          ,+#endif+    repositoryGetVersion                    ,+++-- ** isRegistered #method:isRegistered#++#if ENABLE_OVERLOADING+    RepositoryIsRegisteredMethodInfo        ,+#endif+    repositoryIsRegistered                  ,+++-- ** loadTypelib #method:loadTypelib#++#if ENABLE_OVERLOADING+    RepositoryLoadTypelibMethodInfo         ,+#endif+    repositoryLoadTypelib                   ,+++-- ** prependLibraryPath #method:prependLibraryPath#++    repositoryPrependLibraryPath            ,+++-- ** prependSearchPath #method:prependSearchPath#++    repositoryPrependSearchPath             ,+++-- ** require #method:require#++#if ENABLE_OVERLOADING+    RepositoryRequireMethodInfo             ,+#endif+    repositoryRequire                       ,+++-- ** requirePrivate #method:requirePrivate#++#if ENABLE_OVERLOADING+    RepositoryRequirePrivateMethodInfo      ,+#endif+    repositoryRequirePrivate                ,+++++    ) 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.ManagedPtr as B.ManagedPtr+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.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.GIRepository.Flags as GIRepository.Flags+import {-# SOURCE #-} qualified GI.GIRepository.Structs.BaseInfo as GIRepository.BaseInfo+import {-# SOURCE #-} qualified GI.GIRepository.Structs.Typelib as GIRepository.Typelib+import qualified GI.GLib.Structs.OptionGroup as GLib.OptionGroup+import qualified GI.GObject.Objects.Object as GObject.Object++-- | Memory-managed wrapper type.+newtype Repository = Repository (ManagedPtr Repository)+foreign import ccall "g_irepository_get_type"+    c_g_irepository_get_type :: IO GType++instance GObject Repository where+    gobjectType = c_g_irepository_get_type+    ++-- | Type class for types which can be safely cast to `Repository`, for instance with `toRepository`.+class (GObject o, O.IsDescendantOf Repository o) => IsRepository o+instance (GObject o, O.IsDescendantOf Repository o) => IsRepository o++instance O.HasParentTypes Repository+type instance O.ParentTypes Repository = '[GObject.Object.Object]++-- | Cast to `Repository`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toRepository :: (MonadIO m, IsRepository o) => o -> m Repository+toRepository = liftIO . unsafeCastTo Repository++-- | A convenience alias for `Nothing` :: `Maybe` `Repository`.+noRepository :: Maybe Repository+noRepository = Nothing++#if ENABLE_OVERLOADING+type family ResolveRepositoryMethod (t :: Symbol) (o :: *) :: * where+    ResolveRepositoryMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveRepositoryMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveRepositoryMethod "enumerateVersions" o = RepositoryEnumerateVersionsMethodInfo+    ResolveRepositoryMethod "findByErrorDomain" o = RepositoryFindByErrorDomainMethodInfo+    ResolveRepositoryMethod "findByGtype" o = RepositoryFindByGtypeMethodInfo+    ResolveRepositoryMethod "findByName" o = RepositoryFindByNameMethodInfo+    ResolveRepositoryMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveRepositoryMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveRepositoryMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveRepositoryMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveRepositoryMethod "isRegistered" o = RepositoryIsRegisteredMethodInfo+    ResolveRepositoryMethod "loadTypelib" o = RepositoryLoadTypelibMethodInfo+    ResolveRepositoryMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveRepositoryMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveRepositoryMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveRepositoryMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveRepositoryMethod "require" o = RepositoryRequireMethodInfo+    ResolveRepositoryMethod "requirePrivate" o = RepositoryRequirePrivateMethodInfo+    ResolveRepositoryMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveRepositoryMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveRepositoryMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveRepositoryMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveRepositoryMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveRepositoryMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveRepositoryMethod "getCPrefix" o = RepositoryGetCPrefixMethodInfo+    ResolveRepositoryMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveRepositoryMethod "getDependencies" o = RepositoryGetDependenciesMethodInfo+    ResolveRepositoryMethod "getImmediateDependencies" o = RepositoryGetImmediateDependenciesMethodInfo+    ResolveRepositoryMethod "getInfo" o = RepositoryGetInfoMethodInfo+    ResolveRepositoryMethod "getLoadedNamespaces" o = RepositoryGetLoadedNamespacesMethodInfo+    ResolveRepositoryMethod "getNInfos" o = RepositoryGetNInfosMethodInfo+    ResolveRepositoryMethod "getObjectGtypeInterfaces" o = RepositoryGetObjectGtypeInterfacesMethodInfo+    ResolveRepositoryMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveRepositoryMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveRepositoryMethod "getSharedLibrary" o = RepositoryGetSharedLibraryMethodInfo+    ResolveRepositoryMethod "getTypelibPath" o = RepositoryGetTypelibPathMethodInfo+    ResolveRepositoryMethod "getVersion" o = RepositoryGetVersionMethodInfo+    ResolveRepositoryMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveRepositoryMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveRepositoryMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveRepositoryMethod t Repository, O.MethodInfo info Repository p) => OL.IsLabel t (Repository -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList Repository+type instance O.AttributeList Repository = RepositoryAttributeList+type RepositoryAttributeList = ('[ ] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type instance O.SignalList Repository = RepositorySignalList+type RepositorySignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++-- method Repository::enumerate_versions+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n  process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "GI namespace, e.g. \"Gtk\"", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TGList (TBasicType TUTF8))+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_enumerate_versions" g_irepository_enumerate_versions :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    CString ->                              -- namespace_ : TBasicType TUTF8+    IO (Ptr (GList CString))++{- |+Obtain an unordered list of versions (either currently loaded or+available) for /@namespace_@/ in this /@repository@/.+-}+repositoryEnumerateVersions ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton+  process-global default 'GI.GIRepository.Objects.Repository.Repository' -}+    -> T.Text+    {- ^ /@namespace_@/: GI namespace, e.g. \"Gtk\" -}+    -> m [T.Text]+    {- ^ __Returns:__ the array of versions. -}+repositoryEnumerateVersions repository namespace_ = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    namespace_' <- textToCString namespace_+    result <- g_irepository_enumerate_versions repository' namespace_'+    result' <- unpackGList result+    result'' <- mapM cstringToText result'+    mapGList freeMem result+    g_list_free result+    touchManagedPtr repository+    freeMem namespace_'+    return result''++#if ENABLE_OVERLOADING+data RepositoryEnumerateVersionsMethodInfo+instance (signature ~ (T.Text -> m [T.Text]), MonadIO m, IsRepository a) => O.MethodInfo RepositoryEnumerateVersionsMethodInfo a signature where+    overloadedMethod _ = repositoryEnumerateVersions++#endif++-- method Repository::find_by_error_domain+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n  process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "domain", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GError domain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_find_by_error_domain" g_irepository_find_by_error_domain :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    Word32 ->                               -- domain : TBasicType TUInt32+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Searches for the enum type corresponding to the given 'GError'+domain. Before calling this function for a particular namespace,+you must call 'GI.GIRepository.Objects.Repository.repositoryRequire' once to load the namespace, or+otherwise ensure the namespace has already been loaded.++/Since: 1.30/+-}+repositoryFindByErrorDomain ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton+  process-global default 'GI.GIRepository.Objects.Repository.Repository' -}+    -> Word32+    {- ^ /@domain@/: a 'GError' domain -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ @/GIEnumInfo/@ representing metadata about /@domain@/\'s+enum type, or 'Nothing' -}+repositoryFindByErrorDomain repository domain = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    result <- g_irepository_find_by_error_domain repository' domain+    checkUnexpectedReturnNULL "repositoryFindByErrorDomain" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr repository+    return result'++#if ENABLE_OVERLOADING+data RepositoryFindByErrorDomainMethodInfo+instance (signature ~ (Word32 -> m GIRepository.BaseInfo.BaseInfo), MonadIO m, IsRepository a) => O.MethodInfo RepositoryFindByErrorDomainMethodInfo a signature where+    overloadedMethod _ = repositoryFindByErrorDomain++#endif++-- method Repository::find_by_gtype+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n  process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gtype", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "GType to search for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_find_by_gtype" g_irepository_find_by_gtype :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    CGType ->                               -- gtype : TBasicType TGType+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Searches all loaded namespaces for a particular 'GType'.  Note that+in order to locate the metadata, the namespace corresponding to+the type must first have been loaded.  There is currently no+mechanism for determining the namespace which corresponds to an+arbitrary GType - thus, this function will operate most reliably+when you know the GType to originate from be from a loaded namespace.+-}+repositoryFindByGtype ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton+  process-global default 'GI.GIRepository.Objects.Repository.Repository' -}+    -> GType+    {- ^ /@gtype@/: GType to search for -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ 'GI.GIRepository.Structs.BaseInfo.BaseInfo' representing metadata about /@type@/, or 'Nothing' -}+repositoryFindByGtype repository gtype = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    let gtype' = gtypeToCGType gtype+    result <- g_irepository_find_by_gtype repository' gtype'+    checkUnexpectedReturnNULL "repositoryFindByGtype" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr repository+    return result'++#if ENABLE_OVERLOADING+data RepositoryFindByGtypeMethodInfo+instance (signature ~ (GType -> m GIRepository.BaseInfo.BaseInfo), MonadIO m, IsRepository a) => O.MethodInfo RepositoryFindByGtypeMethodInfo a signature where+    overloadedMethod _ = repositoryFindByGtype++#endif++-- method Repository::find_by_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n  process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace which will be searched", 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 "Entry name to find", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_find_by_name" g_irepository_find_by_name :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    CString ->                              -- namespace_ : TBasicType TUTF8+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+Searches for a particular entry in a namespace.  Before calling+this function for a particular namespace, you must call+'GI.GIRepository.Objects.Repository.repositoryRequire' once to load the namespace, or otherwise+ensure the namespace has already been loaded.+-}+repositoryFindByName ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton+  process-global default 'GI.GIRepository.Objects.Repository.Repository' -}+    -> T.Text+    {- ^ /@namespace_@/: Namespace which will be searched -}+    -> T.Text+    {- ^ /@name@/: Entry name to find -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ 'GI.GIRepository.Structs.BaseInfo.BaseInfo' representing metadata about /@name@/, or 'Nothing' -}+repositoryFindByName repository namespace_ name = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    namespace_' <- textToCString namespace_+    name' <- textToCString name+    result <- g_irepository_find_by_name repository' namespace_' name'+    checkUnexpectedReturnNULL "repositoryFindByName" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr repository+    freeMem namespace_'+    freeMem name'+    return result'++#if ENABLE_OVERLOADING+data RepositoryFindByNameMethodInfo+instance (signature ~ (T.Text -> T.Text -> m GIRepository.BaseInfo.BaseInfo), MonadIO m, IsRepository a) => O.MethodInfo RepositoryFindByNameMethodInfo a signature where+    overloadedMethod _ = repositoryFindByName++#endif++-- method Repository::get_c_prefix+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n  process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace to inspect", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_get_c_prefix" g_irepository_get_c_prefix :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    CString ->                              -- namespace_ : TBasicType TUTF8+    IO CString++{- |+This function returns the \"C prefix\", or the C level namespace+associated with the given introspection namespace.  Each C symbol+starts with this prefix, as well each 'GType' in the library.++Note: The namespace must have already been loaded using a function+such as 'GI.GIRepository.Objects.Repository.repositoryRequire' before calling this function.+-}+repositoryGetCPrefix ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton+  process-global default 'GI.GIRepository.Objects.Repository.Repository' -}+    -> T.Text+    {- ^ /@namespace_@/: Namespace to inspect -}+    -> m T.Text+    {- ^ __Returns:__ C namespace prefix, or 'Nothing' if none associated -}+repositoryGetCPrefix repository namespace_ = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    namespace_' <- textToCString namespace_+    result <- g_irepository_get_c_prefix repository' namespace_'+    checkUnexpectedReturnNULL "repositoryGetCPrefix" result+    result' <- cstringToText result+    touchManagedPtr repository+    freeMem namespace_'+    return result'++#if ENABLE_OVERLOADING+data RepositoryGetCPrefixMethodInfo+instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetCPrefixMethodInfo a signature where+    overloadedMethod _ = repositoryGetCPrefix++#endif++-- method Repository::get_dependencies+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n  process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace of interest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8))+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_get_dependencies" g_irepository_get_dependencies :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    CString ->                              -- namespace_ : TBasicType TUTF8+    IO (Ptr CString)++{- |+Return an array of all (transitive) versioned dependencies for+/@namespace_@/. Returned strings are of the form+\<code>namespace-version\<\/code>.++Note: /@namespace_@/ must have already been loaded using a function+such as 'GI.GIRepository.Objects.Repository.repositoryRequire' before calling this function.++To get only the immediate dependencies for /@namespace_@/, use+'GI.GIRepository.Objects.Repository.repositoryGetImmediateDependencies'.+-}+repositoryGetDependencies ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton+  process-global default 'GI.GIRepository.Objects.Repository.Repository' -}+    -> T.Text+    {- ^ /@namespace_@/: Namespace of interest -}+    -> m [T.Text]+    {- ^ __Returns:__ Zero-terminated string array of all versioned+  dependencies -}+repositoryGetDependencies repository namespace_ = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    namespace_' <- textToCString namespace_+    result <- g_irepository_get_dependencies repository' namespace_'+    checkUnexpectedReturnNULL "repositoryGetDependencies" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr repository+    freeMem namespace_'+    return result'++#if ENABLE_OVERLOADING+data RepositoryGetDependenciesMethodInfo+instance (signature ~ (T.Text -> m [T.Text]), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetDependenciesMethodInfo a signature where+    overloadedMethod _ = repositoryGetDependencies++#endif++-- method Repository::get_immediate_dependencies+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n  process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace of interest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8))+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_get_immediate_dependencies" g_irepository_get_immediate_dependencies :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    CString ->                              -- namespace_ : TBasicType TUTF8+    IO (Ptr CString)++{- |+Return an array of the immediate versioned dependencies for /@namespace_@/.+Returned strings are of the form \<code>namespace-version\<\/code>.++Note: /@namespace_@/ must have already been loaded using a function+such as 'GI.GIRepository.Objects.Repository.repositoryRequire' before calling this function.++To get the transitive closure of dependencies for /@namespace_@/, use+'GI.GIRepository.Objects.Repository.repositoryGetDependencies'.++/Since: 1.44/+-}+repositoryGetImmediateDependencies ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton+  process-global default 'GI.GIRepository.Objects.Repository.Repository' -}+    -> T.Text+    {- ^ /@namespace_@/: Namespace of interest -}+    -> m [T.Text]+    {- ^ __Returns:__ Zero-terminated string array of immediate versioned+  dependencies -}+repositoryGetImmediateDependencies repository namespace_ = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    namespace_' <- textToCString namespace_+    result <- g_irepository_get_immediate_dependencies repository' namespace_'+    checkUnexpectedReturnNULL "repositoryGetImmediateDependencies" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr repository+    freeMem namespace_'+    return result'++#if ENABLE_OVERLOADING+data RepositoryGetImmediateDependenciesMethodInfo+instance (signature ~ (T.Text -> m [T.Text]), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetImmediateDependenciesMethodInfo a signature where+    overloadedMethod _ = repositoryGetImmediateDependencies++#endif++-- method Repository::get_info+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n  process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace to inspect", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "0-based offset into namespace metadata for entry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_get_info" g_irepository_get_info :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    CString ->                              -- namespace_ : TBasicType TUTF8+    Int32 ->                                -- index : TBasicType TInt+    IO (Ptr GIRepository.BaseInfo.BaseInfo)++{- |+This function returns a particular metadata entry in the+given namespace /@namespace_@/.  The namespace must have+already been loaded before calling this function.+See 'GI.GIRepository.Objects.Repository.repositoryGetNInfos' to find the maximum number of+entries.+-}+repositoryGetInfo ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton+  process-global default 'GI.GIRepository.Objects.Repository.Repository' -}+    -> T.Text+    {- ^ /@namespace_@/: Namespace to inspect -}+    -> Int32+    {- ^ /@index@/: 0-based offset into namespace metadata for entry -}+    -> m GIRepository.BaseInfo.BaseInfo+    {- ^ __Returns:__ 'GI.GIRepository.Structs.BaseInfo.BaseInfo' containing metadata -}+repositoryGetInfo repository namespace_ index = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    namespace_' <- textToCString namespace_+    result <- g_irepository_get_info repository' namespace_' index+    checkUnexpectedReturnNULL "repositoryGetInfo" result+    result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result+    touchManagedPtr repository+    freeMem namespace_'+    return result'++#if ENABLE_OVERLOADING+data RepositoryGetInfoMethodInfo+instance (signature ~ (T.Text -> Int32 -> m GIRepository.BaseInfo.BaseInfo), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetInfoMethodInfo a signature where+    overloadedMethod _ = repositoryGetInfo++#endif++-- method Repository::get_loaded_namespaces+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n  process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8))+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_get_loaded_namespaces" g_irepository_get_loaded_namespaces :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    IO (Ptr CString)++{- |+Return the list of currently loaded namespaces.+-}+repositoryGetLoadedNamespaces ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton+  process-global default 'GI.GIRepository.Objects.Repository.Repository' -}+    -> m [T.Text]+    {- ^ __Returns:__ List of namespaces -}+repositoryGetLoadedNamespaces repository = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    result <- g_irepository_get_loaded_namespaces repository'+    checkUnexpectedReturnNULL "repositoryGetLoadedNamespaces" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr repository+    return result'++#if ENABLE_OVERLOADING+data RepositoryGetLoadedNamespacesMethodInfo+instance (signature ~ (m [T.Text]), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetLoadedNamespacesMethodInfo a signature where+    overloadedMethod _ = repositoryGetLoadedNamespaces++#endif++-- method Repository::get_n_infos+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n  process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace to inspect", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_get_n_infos" g_irepository_get_n_infos :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    CString ->                              -- namespace_ : TBasicType TUTF8+    IO Int32++{- |+This function returns the number of metadata entries in+given namespace /@namespace_@/.  The namespace must have+already been loaded before calling this function.+-}+repositoryGetNInfos ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton+  process-global default 'GI.GIRepository.Objects.Repository.Repository' -}+    -> T.Text+    {- ^ /@namespace_@/: Namespace to inspect -}+    -> m Int32+    {- ^ __Returns:__ number of metadata entries -}+repositoryGetNInfos repository namespace_ = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    namespace_' <- textToCString namespace_+    result <- g_irepository_get_n_infos repository' namespace_'+    touchManagedPtr repository+    freeMem namespace_'+    return result++#if ENABLE_OVERLOADING+data RepositoryGetNInfosMethodInfo+instance (signature ~ (T.Text -> m Int32), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetNInfosMethodInfo a signature where+    overloadedMethod _ = repositoryGetNInfos++#endif++-- method Repository::get_object_gtype_interfaces+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIRepository, or %NULL for the default repository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gtype", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GType whose fundamental type is G_TYPE_OBJECT", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_interfaces_out", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of interfaces", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "interfaces_out", argType = TCArray False (-1) 2 (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Interfaces for @gtype", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "n_interfaces_out", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of interfaces", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_get_object_gtype_interfaces" g_irepository_get_object_gtype_interfaces :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    CGType ->                               -- gtype : TBasicType TGType+    Ptr Word32 ->                           -- n_interfaces_out : TBasicType TUInt+    Ptr (Ptr GIRepository.BaseInfo.BaseInfo) -> -- interfaces_out : TCArray False (-1) 2 (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+    IO ()++{- |+Look up the implemented interfaces for /@gtype@/.  This function+cannot fail per se; but for a totally \"unknown\" 'GType', it may+return 0 implemented interfaces.++The semantics of this function are designed for a dynamic binding,+where in certain cases (such as a function which returns an+interface which may have \"hidden\" implementation classes), not all+data may be statically known, and will have to be determined from+the 'GType' of the object.  An example is @/g_file_new_for_path()/@+returning a concrete class of @/GLocalFile/@, which is a 'GType' we+see at runtime, but not statically.++/Since: 1.60/+-}+repositoryGetObjectGtypeInterfaces ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: a 'GI.GIRepository.Objects.Repository.Repository', or 'Nothing' for the default repository -}+    -> GType+    {- ^ /@gtype@/: a 'GType' whose fundamental type is G_TYPE_OBJECT -}+    -> m ([GIRepository.BaseInfo.BaseInfo])+repositoryGetObjectGtypeInterfaces repository gtype = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    let gtype' = gtypeToCGType gtype+    nInterfacesOut <- allocMem :: IO (Ptr Word32)+    interfacesOut <- allocMem :: IO (Ptr (Ptr GIRepository.BaseInfo.BaseInfo))+    g_irepository_get_object_gtype_interfaces repository' gtype' nInterfacesOut interfacesOut+    nInterfacesOut' <- peek nInterfacesOut+    interfacesOut' <- peek interfacesOut+    interfacesOut'' <- (unpackBoxedArrayWithLength 72 nInterfacesOut') interfacesOut'+    interfacesOut''' <- mapM (newBoxed GIRepository.BaseInfo.BaseInfo) interfacesOut''+    touchManagedPtr repository+    freeMem nInterfacesOut+    freeMem interfacesOut+    return interfacesOut'''++#if ENABLE_OVERLOADING+data RepositoryGetObjectGtypeInterfacesMethodInfo+instance (signature ~ (GType -> m ([GIRepository.BaseInfo.BaseInfo])), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetObjectGtypeInterfacesMethodInfo a signature where+    overloadedMethod _ = repositoryGetObjectGtypeInterfaces++#endif++-- method Repository::get_shared_library+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n  process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace to inspect", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_get_shared_library" g_irepository_get_shared_library :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    CString ->                              -- namespace_ : TBasicType TUTF8+    IO CString++{- |+This function returns a comma-separated list of paths to the+shared C libraries associated with the given namespace /@namespace_@/.+There may be no shared library path associated, in which case this+function will return 'Nothing'.++Note: The namespace must have already been loaded using a function+such as 'GI.GIRepository.Objects.Repository.repositoryRequire' before calling this function.+-}+repositoryGetSharedLibrary ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton+  process-global default 'GI.GIRepository.Objects.Repository.Repository' -}+    -> T.Text+    {- ^ /@namespace_@/: Namespace to inspect -}+    -> m T.Text+    {- ^ __Returns:__ Comma-separated list of paths to shared libraries,+  or 'Nothing' if none are associated -}+repositoryGetSharedLibrary repository namespace_ = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    namespace_' <- textToCString namespace_+    result <- g_irepository_get_shared_library repository' namespace_'+    checkUnexpectedReturnNULL "repositoryGetSharedLibrary" result+    result' <- cstringToText result+    touchManagedPtr repository+    freeMem namespace_'+    return result'++#if ENABLE_OVERLOADING+data RepositoryGetSharedLibraryMethodInfo+instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetSharedLibraryMethodInfo a signature where+    overloadedMethod _ = repositoryGetSharedLibrary++#endif++-- method Repository::get_typelib_path+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n  process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "GI namespace to use, e.g. \"Gtk\"", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_get_typelib_path" g_irepository_get_typelib_path :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    CString ->                              -- namespace_ : TBasicType TUTF8+    IO CString++{- |+If namespace /@namespace_@/ is loaded, return the full path to the+.typelib file it was loaded from.  If the typelib for+namespace /@namespace_@/ was included in a shared library, return+the special string \"&lt;builtin&gt;\".+-}+repositoryGetTypelibPath ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton+  process-global default 'GI.GIRepository.Objects.Repository.Repository' -}+    -> T.Text+    {- ^ /@namespace_@/: GI namespace to use, e.g. \"Gtk\" -}+    -> m T.Text+    {- ^ __Returns:__ Filesystem path (or $lt;builtin$gt;) if successful, 'Nothing' if namespace is not loaded -}+repositoryGetTypelibPath repository namespace_ = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    namespace_' <- textToCString namespace_+    result <- g_irepository_get_typelib_path repository' namespace_'+    checkUnexpectedReturnNULL "repositoryGetTypelibPath" result+    result' <- cstringToText result+    touchManagedPtr repository+    freeMem namespace_'+    return result'++#if ENABLE_OVERLOADING+data RepositoryGetTypelibPathMethodInfo+instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetTypelibPathMethodInfo a signature where+    overloadedMethod _ = repositoryGetTypelibPath++#endif++-- method Repository::get_version+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n  process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace to inspect", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_get_version" g_irepository_get_version :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    CString ->                              -- namespace_ : TBasicType TUTF8+    IO CString++{- |+This function returns the loaded version associated with the given+namespace /@namespace_@/.++Note: The namespace must have already been loaded using a function+such as 'GI.GIRepository.Objects.Repository.repositoryRequire' before calling this function.+-}+repositoryGetVersion ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton+  process-global default 'GI.GIRepository.Objects.Repository.Repository' -}+    -> T.Text+    {- ^ /@namespace_@/: Namespace to inspect -}+    -> m T.Text+    {- ^ __Returns:__ Loaded version -}+repositoryGetVersion repository namespace_ = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    namespace_' <- textToCString namespace_+    result <- g_irepository_get_version repository' namespace_'+    checkUnexpectedReturnNULL "repositoryGetVersion" result+    result' <- cstringToText result+    touchManagedPtr repository+    freeMem namespace_'+    return result'++#if ENABLE_OVERLOADING+data RepositoryGetVersionMethodInfo+instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetVersionMethodInfo a signature where+    overloadedMethod _ = repositoryGetVersion++#endif++-- method Repository::is_registered+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n  process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace of interest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "version", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Required version, may be %NULL for latest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_is_registered" g_irepository_is_registered :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    CString ->                              -- namespace_ : TBasicType TUTF8+    CString ->                              -- version : TBasicType TUTF8+    IO CInt++{- |+Check whether a particular namespace (and optionally, a specific+version thereof) is currently loaded.  This function is likely to+only be useful in unusual circumstances; in order to act upon+metadata in the namespace, you should call 'GI.GIRepository.Objects.Repository.repositoryRequire'+instead which will ensure the namespace is loaded, and return as+quickly as this function will if it has already been loaded.+-}+repositoryIsRegistered ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton+  process-global default 'GI.GIRepository.Objects.Repository.Repository' -}+    -> T.Text+    {- ^ /@namespace_@/: Namespace of interest -}+    -> Maybe (T.Text)+    {- ^ /@version@/: Required version, may be 'Nothing' for latest -}+    -> m Bool+    {- ^ __Returns:__ 'True' if namespace-version is loaded, 'False' otherwise -}+repositoryIsRegistered repository namespace_ version = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    namespace_' <- textToCString namespace_+    maybeVersion <- case version of+        Nothing -> return nullPtr+        Just jVersion -> do+            jVersion' <- textToCString jVersion+            return jVersion'+    result <- g_irepository_is_registered repository' namespace_' maybeVersion+    let result' = (/= 0) result+    touchManagedPtr repository+    freeMem namespace_'+    freeMem maybeVersion+    return result'++#if ENABLE_OVERLOADING+data RepositoryIsRegisteredMethodInfo+instance (signature ~ (T.Text -> Maybe (T.Text) -> m Bool), MonadIO m, IsRepository a) => O.MethodInfo RepositoryIsRegisteredMethodInfo a signature where+    overloadedMethod _ = repositoryIsRegistered++#endif++-- method Repository::load_typelib+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n  process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "typelib", argType = TInterface (Name {namespace = "GIRepository", name = "Typelib"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GIRepository", name = "RepositoryLoadFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : True+-- Skip return : False++foreign import ccall "g_irepository_load_typelib" g_irepository_load_typelib :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    Ptr GIRepository.Typelib.Typelib ->     -- typelib : TInterface (Name {namespace = "GIRepository", name = "Typelib"})+    CUInt ->                                -- flags : TInterface (Name {namespace = "GIRepository", name = "RepositoryLoadFlags"})+    Ptr (Ptr GError) ->                     -- error+    IO CString++{- |+TODO+-}+repositoryLoadTypelib ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton+  process-global default 'GI.GIRepository.Objects.Repository.Repository' -}+    -> GIRepository.Typelib.Typelib+    {- ^ /@typelib@/: TODO -}+    -> [GIRepository.Flags.RepositoryLoadFlags]+    {- ^ /@flags@/: TODO -}+    -> m T.Text+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+repositoryLoadTypelib repository typelib flags = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    typelib' <- unsafeManagedPtrGetPtr typelib+    let flags' = gflagsToWord flags+    onException (do+        result <- propagateGError $ g_irepository_load_typelib repository' typelib' flags'+        checkUnexpectedReturnNULL "repositoryLoadTypelib" result+        result' <- cstringToText result+        touchManagedPtr repository+        touchManagedPtr typelib+        return result'+     ) (do+        return ()+     )++#if ENABLE_OVERLOADING+data RepositoryLoadTypelibMethodInfo+instance (signature ~ (GIRepository.Typelib.Typelib -> [GIRepository.Flags.RepositoryLoadFlags] -> m T.Text), MonadIO m, IsRepository a) => O.MethodInfo RepositoryLoadTypelibMethodInfo a signature where+    overloadedMethod _ = repositoryLoadTypelib++#endif++-- method Repository::require+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n  process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "GI namespace to use, e.g. \"Gtk\"", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "version", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Version of namespace, may be %NULL for latest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GIRepository", name = "RepositoryLoadFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Set of %GIRepositoryLoadFlags, may be 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Typelib"}))+-- throws : True+-- Skip return : False++foreign import ccall "g_irepository_require" g_irepository_require :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    CString ->                              -- namespace_ : TBasicType TUTF8+    CString ->                              -- version : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface (Name {namespace = "GIRepository", name = "RepositoryLoadFlags"})+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GIRepository.Typelib.Typelib)++{- |+Force the namespace /@namespace_@/ to be loaded if it isn\'t already.+If /@namespace_@/ is not loaded, this function will search for a+\".typelib\" file using the repository search path.  In addition, a+version /@version@/ of namespace may be specified.  If /@version@/ is+not specified, the latest will be used.+-}+repositoryRequire ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton+  process-global default 'GI.GIRepository.Objects.Repository.Repository' -}+    -> T.Text+    {- ^ /@namespace_@/: GI namespace to use, e.g. \"Gtk\" -}+    -> Maybe (T.Text)+    {- ^ /@version@/: Version of namespace, may be 'Nothing' for latest -}+    -> [GIRepository.Flags.RepositoryLoadFlags]+    {- ^ /@flags@/: Set of @/GIRepositoryLoadFlags/@, may be 0 -}+    -> m GIRepository.Typelib.Typelib+    {- ^ __Returns:__ a pointer to the 'GI.GIRepository.Structs.Typelib.Typelib' if successful, 'Nothing' otherwise /(Can throw 'Data.GI.Base.GError.GError')/ -}+repositoryRequire repository namespace_ version flags = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    namespace_' <- textToCString namespace_+    maybeVersion <- case version of+        Nothing -> return nullPtr+        Just jVersion -> do+            jVersion' <- textToCString jVersion+            return jVersion'+    let flags' = gflagsToWord flags+    onException (do+        result <- propagateGError $ g_irepository_require repository' namespace_' maybeVersion flags'+        checkUnexpectedReturnNULL "repositoryRequire" result+        result' <- (newPtr GIRepository.Typelib.Typelib) result+        touchManagedPtr repository+        freeMem namespace_'+        freeMem maybeVersion+        return result'+     ) (do+        freeMem namespace_'+        freeMem maybeVersion+     )++#if ENABLE_OVERLOADING+data RepositoryRequireMethodInfo+instance (signature ~ (T.Text -> Maybe (T.Text) -> [GIRepository.Flags.RepositoryLoadFlags] -> m GIRepository.Typelib.Typelib), MonadIO m, IsRepository a) => O.MethodInfo RepositoryRequireMethodInfo a signature where+    overloadedMethod _ = repositoryRequire++#endif++-- method Repository::require_private+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n  process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "typelib_dir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Private directory where to find the requested typelib", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "GI namespace to use, e.g. \"Gtk\"", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "version", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Version of namespace, may be %NULL for latest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GIRepository", name = "RepositoryLoadFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Set of %GIRepositoryLoadFlags, may be 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Typelib"}))+-- throws : True+-- Skip return : False++foreign import ccall "g_irepository_require_private" g_irepository_require_private :: +    Ptr Repository ->                       -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"})+    CString ->                              -- typelib_dir : TBasicType TUTF8+    CString ->                              -- namespace_ : TBasicType TUTF8+    CString ->                              -- version : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface (Name {namespace = "GIRepository", name = "RepositoryLoadFlags"})+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GIRepository.Typelib.Typelib)++{- |+Force the namespace /@namespace_@/ to be loaded if it isn\'t already.+If /@namespace_@/ is not loaded, this function will search for a+\".typelib\" file within the private directory only. In addition, a+version /@version@/ of namespace should be specified.  If /@version@/ is+not specified, the latest will be used.+-}+repositoryRequirePrivate ::+    (B.CallStack.HasCallStack, MonadIO m, IsRepository a) =>+    a+    {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton+  process-global default 'GI.GIRepository.Objects.Repository.Repository' -}+    -> T.Text+    {- ^ /@typelibDir@/: Private directory where to find the requested typelib -}+    -> T.Text+    {- ^ /@namespace_@/: GI namespace to use, e.g. \"Gtk\" -}+    -> Maybe (T.Text)+    {- ^ /@version@/: Version of namespace, may be 'Nothing' for latest -}+    -> [GIRepository.Flags.RepositoryLoadFlags]+    {- ^ /@flags@/: Set of @/GIRepositoryLoadFlags/@, may be 0 -}+    -> m GIRepository.Typelib.Typelib+    {- ^ __Returns:__ a pointer to the 'GI.GIRepository.Structs.Typelib.Typelib' if successful, 'Nothing' otherwise /(Can throw 'Data.GI.Base.GError.GError')/ -}+repositoryRequirePrivate repository typelibDir namespace_ version flags = liftIO $ do+    repository' <- unsafeManagedPtrCastPtr repository+    typelibDir' <- textToCString typelibDir+    namespace_' <- textToCString namespace_+    maybeVersion <- case version of+        Nothing -> return nullPtr+        Just jVersion -> do+            jVersion' <- textToCString jVersion+            return jVersion'+    let flags' = gflagsToWord flags+    onException (do+        result <- propagateGError $ g_irepository_require_private repository' typelibDir' namespace_' maybeVersion flags'+        checkUnexpectedReturnNULL "repositoryRequirePrivate" result+        result' <- (newPtr GIRepository.Typelib.Typelib) result+        touchManagedPtr repository+        freeMem typelibDir'+        freeMem namespace_'+        freeMem maybeVersion+        return result'+     ) (do+        freeMem typelibDir'+        freeMem namespace_'+        freeMem maybeVersion+     )++#if ENABLE_OVERLOADING+data RepositoryRequirePrivateMethodInfo+instance (signature ~ (T.Text -> T.Text -> Maybe (T.Text) -> [GIRepository.Flags.RepositoryLoadFlags] -> m GIRepository.Typelib.Typelib), MonadIO m, IsRepository a) => O.MethodInfo RepositoryRequirePrivateMethodInfo a signature where+    overloadedMethod _ = repositoryRequirePrivate++#endif++-- method Repository::dump+-- method type : MemberFunction+-- Args : [Arg {argCName = "arg", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : True+-- Skip return : False++foreign import ccall "g_irepository_dump" g_irepository_dump :: +    CString ->                              -- arg : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{- |+/No description available in the introspection data./+-}+repositoryDump ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    -> m ()+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+repositoryDump arg = liftIO $ do+    arg' <- textToCString arg+    onException (do+        _ <- propagateGError $ g_irepository_dump arg'+        freeMem arg'+        return ()+     ) (do+        freeMem arg'+     )++#if ENABLE_OVERLOADING+#endif++-- method Repository::error_quark+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUInt32)+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_error_quark" g_irepository_error_quark :: +    IO Word32++{- |+/No description available in the introspection data./+-}+repositoryErrorQuark ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Word32+repositoryErrorQuark  = liftIO $ do+    result <- g_irepository_error_quark+    return result++#if ENABLE_OVERLOADING+#endif++-- method Repository::get_default+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Repository"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_get_default" g_irepository_get_default :: +    IO (Ptr Repository)++{- |+Returns the singleton process-global default 'GI.GIRepository.Objects.Repository.Repository'. It is+not currently supported to have multiple repositories in a+particular process, but this function is provided in the unlikely+eventuality that it would become possible, and as a convenience for+higher level language bindings to conform to the GObject method+call conventions.++All methods on 'GI.GIRepository.Objects.Repository.Repository' also accept 'Nothing' as an instance+parameter to mean this default repository, which is usually more+convenient for C.+-}+repositoryGetDefault ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Repository+    {- ^ __Returns:__ The global singleton 'GI.GIRepository.Objects.Repository.Repository' -}+repositoryGetDefault  = liftIO $ do+    result <- g_irepository_get_default+    checkUnexpectedReturnNULL "repositoryGetDefault" result+    result' <- (newObject Repository) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Repository::get_option_group+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GLib", name = "OptionGroup"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_get_option_group" g_irepository_get_option_group :: +    IO (Ptr GLib.OptionGroup.OptionGroup)++{- |+Obtain the option group for girepository, it\'s used+by the dumper and for programs that wants to provide+introspection information+-}+repositoryGetOptionGroup ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m GLib.OptionGroup.OptionGroup+    {- ^ __Returns:__ the option group -}+repositoryGetOptionGroup  = liftIO $ do+    result <- g_irepository_get_option_group+    checkUnexpectedReturnNULL "repositoryGetOptionGroup" result+    result' <- (wrapBoxed GLib.OptionGroup.OptionGroup) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Repository::get_search_path+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : Just (TGSList (TBasicType TFileName))+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_get_search_path" g_irepository_get_search_path :: +    IO (Ptr (GSList CString))++{- |+Returns the current search path 'GI.GIRepository.Objects.Repository.Repository' will use when loading+typelib files. The list is internal to 'GI.GIRepository.Objects.Repository.Repository' and should not+be freed, nor should its string elements.+-}+repositoryGetSearchPath ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m [[Char]]+    {- ^ __Returns:__ 'GI.GLib.Structs.SList.SList' of strings -}+repositoryGetSearchPath  = liftIO $ do+    result <- g_irepository_get_search_path+    result' <- unpackGSList result+    result'' <- mapM cstringToString result'+    return result''++#if ENABLE_OVERLOADING+#endif++-- method Repository::prepend_library_path+-- method type : MemberFunction+-- Args : [Arg {argCName = "directory", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_prepend_library_path" g_irepository_prepend_library_path :: +    CString ->                              -- directory : TBasicType TUTF8+    IO ()++{- |+/No description available in the introspection data./+-}+repositoryPrependLibraryPath ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    -> m ()+repositoryPrependLibraryPath directory = liftIO $ do+    directory' <- textToCString directory+    g_irepository_prepend_library_path directory'+    freeMem directory'+    return ()++#if ENABLE_OVERLOADING+#endif++-- method Repository::prepend_search_path+-- method type : MemberFunction+-- Args : [Arg {argCName = "directory", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "directory name to prepend to the typelib\n  search path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "g_irepository_prepend_search_path" g_irepository_prepend_search_path :: +    CString ->                              -- directory : TBasicType TFileName+    IO ()++{- |+Prepends /@directory@/ to the typelib search path.++See also: 'GI.GIRepository.Objects.Repository.repositoryGetSearchPath'.+-}+repositoryPrependSearchPath ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    [Char]+    {- ^ /@directory@/: directory name to prepend to the typelib+  search path -}+    -> m ()+repositoryPrependSearchPath directory = liftIO $ do+    directory' <- stringToCString directory+    g_irepository_prepend_search_path directory'+    freeMem directory'+    return ()++#if ENABLE_OVERLOADING+#endif++

@@ -0,0 +1,83 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GIRepository.Objects.Repository 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.ManagedPtr as B.ManagedPtr+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.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++newtype Repository = Repository (ManagedPtr Repository)+instance GObject Repository where+class (GObject o, O.IsDescendantOf Repository o) => IsRepository o+instance (GObject o, O.IsDescendantOf Repository o) => IsRepository o+instance O.HasParentTypes Repository+#if ENABLE_OVERLOADING+data RepositoryEnumerateVersionsMethodInfo+#endif+#if ENABLE_OVERLOADING+data RepositoryFindByErrorDomainMethodInfo+#endif+#if ENABLE_OVERLOADING+data RepositoryFindByGtypeMethodInfo+#endif+#if ENABLE_OVERLOADING+data RepositoryFindByNameMethodInfo+#endif+#if ENABLE_OVERLOADING+data RepositoryGetCPrefixMethodInfo+#endif+#if ENABLE_OVERLOADING+data RepositoryGetDependenciesMethodInfo+#endif+#if ENABLE_OVERLOADING+data RepositoryGetImmediateDependenciesMethodInfo+#endif+#if ENABLE_OVERLOADING+data RepositoryGetInfoMethodInfo+#endif+#if ENABLE_OVERLOADING+data RepositoryGetLoadedNamespacesMethodInfo+#endif+#if ENABLE_OVERLOADING+data RepositoryGetNInfosMethodInfo+#endif+#if ENABLE_OVERLOADING+data RepositoryGetObjectGtypeInterfacesMethodInfo+#endif+#if ENABLE_OVERLOADING+data RepositoryGetSharedLibraryMethodInfo+#endif+#if ENABLE_OVERLOADING+data RepositoryGetTypelibPathMethodInfo+#endif+#if ENABLE_OVERLOADING+data RepositoryGetVersionMethodInfo+#endif+#if ENABLE_OVERLOADING+data RepositoryIsRegisteredMethodInfo+#endif+#if ENABLE_OVERLOADING+data RepositoryLoadTypelibMethodInfo+#endif+#if ENABLE_OVERLOADING+data RepositoryRequireMethodInfo+#endif+#if ENABLE_OVERLOADING+data RepositoryRequirePrivateMethodInfo+#endif

@@ -0,0 +1,47 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GIRepository.Structs+    (     module GI.GIRepository.Structs.AttributeIter,+    module GI.GIRepository.Structs.BaseInfo ,+    module GI.GIRepository.Structs.Typelib  ,+    module GI.GIRepository.Structs.UnresolvedInfo,+++    ) where++import GI.GIRepository.Structs.AttributeIter+import GI.GIRepository.Structs.BaseInfo+import GI.GIRepository.Structs.Typelib+import GI.GIRepository.Structs.UnresolvedInfo++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.ManagedPtr as B.ManagedPtr+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.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+++

@@ -0,0 +1,89 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++An opaque structure used to iterate over attributes+in a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' struct.+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GIRepository.Structs.AttributeIter+    ( ++-- * Exported types+    AttributeIter(..)                       ,+    newZeroAttributeIter                    ,+    noAttributeIter                         ,+++    ) 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.ManagedPtr as B.ManagedPtr+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.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+++-- | Memory-managed wrapper type.+newtype AttributeIter = AttributeIter (ManagedPtr AttributeIter)+instance WrappedPtr AttributeIter where+    wrappedPtrCalloc = callocBytes 32+    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 32 >=> wrapPtr AttributeIter)+    wrappedPtrFree = Just ptr_to_g_free++-- | Construct a `AttributeIter` struct initialized to zero.+newZeroAttributeIter :: MonadIO m => m AttributeIter+newZeroAttributeIter = liftIO $ wrappedPtrCalloc >>= wrapPtr AttributeIter++instance tag ~ 'AttrSet => Constructible AttributeIter tag where+    new _ attrs = do+        o <- newZeroAttributeIter+        GI.Attributes.set o attrs+        return o+++-- | A convenience alias for `Nothing` :: `Maybe` `AttributeIter`.+noAttributeIter :: Maybe AttributeIter+noAttributeIter = Nothing+++#if ENABLE_OVERLOADING+instance O.HasAttributeList AttributeIter+type instance O.AttributeList AttributeIter = AttributeIterAttributeList+type AttributeIterAttributeList = ('[ ] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+type family ResolveAttributeIterMethod (t :: Symbol) (o :: *) :: * where+    ResolveAttributeIterMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveAttributeIterMethod t AttributeIter, O.MethodInfo info AttributeIter p) => OL.IsLabel t (AttributeIter -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++

@@ -0,0 +1,26 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GIRepository.Structs.AttributeIter 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.ManagedPtr as B.ManagedPtr+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.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++newtype AttributeIter = AttributeIter (ManagedPtr AttributeIter)+instance WrappedPtr AttributeIter where

@@ -0,0 +1,591 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++GIBaseInfo is the common base struct of all other *Info structs+accessible through the 'GI.GIRepository.Objects.Repository.Repository' API.+All other structs can be casted to a 'GI.GIRepository.Structs.BaseInfo.BaseInfo', for instance:+\<example>+\<title>Casting a @/GIFunctionInfo/@ to 'GI.GIRepository.Structs.BaseInfo.BaseInfo'\<\/title>+\<programlisting>+   GIFunctionInfo *function_info = ...;+   GIBaseInfo *info = (GIBaseInfo*)function_info;+\<\/programlisting>+\<\/example>+Most 'GI.GIRepository.Objects.Repository.Repository' APIs returning a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' is actually creating a new struct, in other+words, @/g_base_info_unref()/@ has to be called when done accessing the data.+GIBaseInfos are normally accessed by calling either+'GI.GIRepository.Objects.Repository.repositoryFindByName', 'GI.GIRepository.Objects.Repository.repositoryFindByGtype' or 'GI.GIRepository.Objects.Repository.repositoryGetInfo'.++\<example>+\<title>Getting the Button of the Gtk typelib\<\/title>+\<programlisting>+   GIBaseInfo *button_info = g_irepository_find_by_name(NULL, \"Gtk\", \"Button\");+   ... use button_info ...+   g_base_info_unref(button_info);+\<\/programlisting>+\<\/example>++\<refsect1 id=\"gi-gibaseinfo.struct-hierarchy\" role=\"struct_hierarchy\">+\<title role=\"struct_hierarchy.title\">Struct hierarchy\<\/title>+\<synopsis>+  GIBaseInfo+   +----\<link linkend=\"gi-GIArgInfo\">GIArgInfo\<\/link>+   +----\<link linkend=\"gi-GICallableInfo\">GICallableInfo\<\/link>+   +----\<link linkend=\"gi-GIConstantInfo\">GIConstantInfo\<\/link>+   +----\<link linkend=\"gi-GIFieldInfo\">GIFieldInfo\<\/link>+   +----\<link linkend=\"gi-GIPropertyInfo\">GIPropertyInfo\<\/link>+   +----\<link linkend=\"gi-GIRegisteredTypeInfo\">GIRegisteredTypeInfo\<\/link>+   +----\<link linkend=\"gi-GITypeInfo\">GITypeInfo\<\/link>+\<\/synopsis>+\<\/refsect1>+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GIRepository.Structs.BaseInfo+    ( ++-- * Exported types+    BaseInfo(..)                            ,+    newZeroBaseInfo                         ,+    noBaseInfo                              ,+++ -- * Methods+-- ** equal #method:equal#++#if ENABLE_OVERLOADING+    BaseInfoEqualMethodInfo                 ,+#endif+    baseInfoEqual                           ,+++-- ** getAttribute #method:getAttribute#++#if ENABLE_OVERLOADING+    BaseInfoGetAttributeMethodInfo          ,+#endif+    baseInfoGetAttribute                    ,+++-- ** getContainer #method:getContainer#++#if ENABLE_OVERLOADING+    BaseInfoGetContainerMethodInfo          ,+#endif+    baseInfoGetContainer                    ,+++-- ** getName #method:getName#++#if ENABLE_OVERLOADING+    BaseInfoGetNameMethodInfo               ,+#endif+    baseInfoGetName                         ,+++-- ** getNamespace #method:getNamespace#++#if ENABLE_OVERLOADING+    BaseInfoGetNamespaceMethodInfo          ,+#endif+    baseInfoGetNamespace                    ,+++-- ** getType #method:getType#++#if ENABLE_OVERLOADING+    BaseInfoGetTypeMethodInfo               ,+#endif+    baseInfoGetType                         ,+++-- ** getTypelib #method:getTypelib#++#if ENABLE_OVERLOADING+    BaseInfoGetTypelibMethodInfo            ,+#endif+    baseInfoGetTypelib                      ,+++-- ** isDeprecated #method:isDeprecated#++#if ENABLE_OVERLOADING+    BaseInfoIsDeprecatedMethodInfo          ,+#endif+    baseInfoIsDeprecated                    ,+++-- ** iterateAttributes #method:iterateAttributes#++#if ENABLE_OVERLOADING+    BaseInfoIterateAttributesMethodInfo     ,+#endif+    baseInfoIterateAttributes               ,+++++    ) 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.ManagedPtr as B.ManagedPtr+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.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.GIRepository.Enums as GIRepository.Enums+import {-# SOURCE #-} qualified GI.GIRepository.Structs.AttributeIter as GIRepository.AttributeIter+import {-# SOURCE #-} qualified GI.GIRepository.Structs.Typelib as GIRepository.Typelib++-- | Memory-managed wrapper type.+newtype BaseInfo = BaseInfo (ManagedPtr BaseInfo)+foreign import ccall "g_base_info_gtype_get_type" c_g_base_info_gtype_get_type :: +    IO GType++instance BoxedObject BaseInfo where+    boxedType _ = c_g_base_info_gtype_get_type++-- | Construct a `BaseInfo` struct initialized to zero.+newZeroBaseInfo :: MonadIO m => m BaseInfo+newZeroBaseInfo = liftIO $ callocBoxedBytes 72 >>= wrapBoxed BaseInfo++instance tag ~ 'AttrSet => Constructible BaseInfo tag where+    new _ attrs = do+        o <- newZeroBaseInfo+        GI.Attributes.set o attrs+        return o+++-- | A convenience alias for `Nothing` :: `Maybe` `BaseInfo`.+noBaseInfo :: Maybe BaseInfo+noBaseInfo = Nothing+++#if ENABLE_OVERLOADING+instance O.HasAttributeList BaseInfo+type instance O.AttributeList BaseInfo = BaseInfoAttributeList+type BaseInfoAttributeList = ('[ ] :: [(Symbol, *)])+#endif++-- method BaseInfo::equal+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "info1", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info2", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_base_info_equal" g_base_info_equal :: +    Ptr BaseInfo ->                         -- info1 : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Ptr BaseInfo ->                         -- info2 : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+Compare two 'GI.GIRepository.Structs.BaseInfo.BaseInfo'.++Using pointer comparison is not practical since many functions return+different instances of 'GI.GIRepository.Structs.BaseInfo.BaseInfo' that refers to the same part of the+TypeLib; use this function instead to do 'GI.GIRepository.Structs.BaseInfo.BaseInfo' comparisons.+-}+baseInfoEqual ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    BaseInfo+    {- ^ /@info1@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -}+    -> BaseInfo+    {- ^ /@info2@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if and only if /@info1@/ equals /@info2@/. -}+baseInfoEqual info1 info2 = liftIO $ do+    info1' <- unsafeManagedPtrGetPtr info1+    info2' <- unsafeManagedPtrGetPtr info2+    result <- g_base_info_equal info1' info2'+    let result' = (/= 0) result+    touchManagedPtr info1+    touchManagedPtr info2+    return result'++#if ENABLE_OVERLOADING+data BaseInfoEqualMethodInfo+instance (signature ~ (BaseInfo -> m Bool), MonadIO m) => O.MethodInfo BaseInfoEqualMethodInfo BaseInfo signature where+    overloadedMethod _ = baseInfoEqual++#endif++-- method BaseInfo::get_attribute+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", 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 "a freeform string naming an attribute", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_base_info_get_attribute" g_base_info_get_attribute :: +    Ptr BaseInfo ->                         -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    CString ->                              -- name : TBasicType TUTF8+    IO CString++{- |+Retrieve an arbitrary attribute associated with this node.+-}+baseInfoGetAttribute ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    BaseInfo+    {- ^ /@info@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -}+    -> T.Text+    {- ^ /@name@/: a freeform string naming an attribute -}+    -> m T.Text+    {- ^ __Returns:__ The value of the attribute, or 'Nothing' if no such attribute exists -}+baseInfoGetAttribute info name = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    name' <- textToCString name+    result <- g_base_info_get_attribute info' name'+    checkUnexpectedReturnNULL "baseInfoGetAttribute" result+    result' <- cstringToText result+    touchManagedPtr info+    freeMem name'+    return result'++#if ENABLE_OVERLOADING+data BaseInfoGetAttributeMethodInfo+instance (signature ~ (T.Text -> m T.Text), MonadIO m) => O.MethodInfo BaseInfoGetAttributeMethodInfo BaseInfo signature where+    overloadedMethod _ = baseInfoGetAttribute++#endif++-- method BaseInfo::get_container+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_base_info_get_container" g_base_info_get_container :: +    Ptr BaseInfo ->                         -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr BaseInfo)++{- |+Obtain the container of the /@info@/. The container is the parent+GIBaseInfo. For instance, the parent of a @/GIFunctionInfo/@ is an+@/GIObjectInfo/@ or @/GIInterfaceInfo/@.+-}+baseInfoGetContainer ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    BaseInfo+    {- ^ /@info@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -}+    -> m BaseInfo+    {- ^ __Returns:__ the container -}+baseInfoGetContainer info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_base_info_get_container info'+    checkUnexpectedReturnNULL "baseInfoGetContainer" result+    result' <- (newBoxed BaseInfo) result+    touchManagedPtr info+    return result'++#if ENABLE_OVERLOADING+data BaseInfoGetContainerMethodInfo+instance (signature ~ (m BaseInfo), MonadIO m) => O.MethodInfo BaseInfoGetContainerMethodInfo BaseInfo signature where+    overloadedMethod _ = baseInfoGetContainer++#endif++-- method BaseInfo::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_base_info_get_name" g_base_info_get_name :: +    Ptr BaseInfo ->                         -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CString++{- |+Obtain the name of the /@info@/. What the name represents depends on+the 'GI.GIRepository.Enums.InfoType' of the /@info@/. For instance for @/GIFunctionInfo/@ it is+the name of the function.+-}+baseInfoGetName ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    BaseInfo+    {- ^ /@info@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -}+    -> m T.Text+    {- ^ __Returns:__ the name of /@info@/ or 'Nothing' if it lacks a name. -}+baseInfoGetName info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_base_info_get_name info'+    checkUnexpectedReturnNULL "baseInfoGetName" result+    result' <- cstringToText result+    touchManagedPtr info+    return result'++#if ENABLE_OVERLOADING+data BaseInfoGetNameMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo BaseInfoGetNameMethodInfo BaseInfo signature where+    overloadedMethod _ = baseInfoGetName++#endif++-- method BaseInfo::get_namespace+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_base_info_get_namespace" g_base_info_get_namespace :: +    Ptr BaseInfo ->                         -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CString++{- |+Obtain the namespace of /@info@/.+-}+baseInfoGetNamespace ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    BaseInfo+    {- ^ /@info@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -}+    -> m T.Text+    {- ^ __Returns:__ the namespace -}+baseInfoGetNamespace info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_base_info_get_namespace info'+    checkUnexpectedReturnNULL "baseInfoGetNamespace" result+    result' <- cstringToText result+    touchManagedPtr info+    return result'++#if ENABLE_OVERLOADING+data BaseInfoGetNamespaceMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo BaseInfoGetNamespaceMethodInfo BaseInfo signature where+    overloadedMethod _ = baseInfoGetNamespace++#endif++-- method BaseInfo::get_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "InfoType"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_base_info_get_type" g_base_info_get_type :: +    Ptr BaseInfo ->                         -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CUInt++{- |+Obtain the info type of the GIBaseInfo.+-}+baseInfoGetType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    BaseInfo+    {- ^ /@info@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -}+    -> m GIRepository.Enums.InfoType+    {- ^ __Returns:__ the info type of /@info@/ -}+baseInfoGetType info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_base_info_get_type info'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr info+    return result'++#if ENABLE_OVERLOADING+data BaseInfoGetTypeMethodInfo+instance (signature ~ (m GIRepository.Enums.InfoType), MonadIO m) => O.MethodInfo BaseInfoGetTypeMethodInfo BaseInfo signature where+    overloadedMethod _ = baseInfoGetType++#endif++-- method BaseInfo::get_typelib+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Typelib"}))+-- throws : False+-- Skip return : False++foreign import ccall "g_base_info_get_typelib" g_base_info_get_typelib :: +    Ptr BaseInfo ->                         -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO (Ptr GIRepository.Typelib.Typelib)++{- |+Obtain the typelib this /@info@/ belongs to+-}+baseInfoGetTypelib ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    BaseInfo+    {- ^ /@info@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -}+    -> m GIRepository.Typelib.Typelib+    {- ^ __Returns:__ the typelib. -}+baseInfoGetTypelib info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_base_info_get_typelib info'+    checkUnexpectedReturnNULL "baseInfoGetTypelib" result+    result' <- (newPtr GIRepository.Typelib.Typelib) result+    touchManagedPtr info+    return result'++#if ENABLE_OVERLOADING+data BaseInfoGetTypelibMethodInfo+instance (signature ~ (m GIRepository.Typelib.Typelib), MonadIO m) => O.MethodInfo BaseInfoGetTypelibMethodInfo BaseInfo signature where+    overloadedMethod _ = baseInfoGetTypelib++#endif++-- method BaseInfo::is_deprecated+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_base_info_is_deprecated" g_base_info_is_deprecated :: +    Ptr BaseInfo ->                         -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    IO CInt++{- |+Obtain whether the /@info@/ is represents a metadata which is+deprecated or not.+-}+baseInfoIsDeprecated ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    BaseInfo+    {- ^ /@info@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if deprecated -}+baseInfoIsDeprecated info = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    result <- g_base_info_is_deprecated info'+    let result' = (/= 0) result+    touchManagedPtr info+    return result'++#if ENABLE_OVERLOADING+data BaseInfoIsDeprecatedMethodInfo+instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo BaseInfoIsDeprecatedMethodInfo BaseInfo signature where+    overloadedMethod _ = baseInfoIsDeprecated++#endif++-- method BaseInfo::iterate_attributes+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iterator", argType = TInterface (Name {namespace = "GIRepository", name = "AttributeIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIAttributeIter structure, must be initialized; see below", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Returned name, must not be freed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Returned name, must not be freed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "g_base_info_iterate_attributes" g_base_info_iterate_attributes :: +    Ptr BaseInfo ->                         -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})+    Ptr GIRepository.AttributeIter.AttributeIter -> -- iterator : TInterface (Name {namespace = "GIRepository", name = "AttributeIter"})+    Ptr CString ->                          -- name : TBasicType TUTF8+    Ptr CString ->                          -- value : TBasicType TUTF8+    IO CInt++{- |+Iterate over all attributes associated with this node.  The iterator+structure is typically stack allocated, and must have its first+member initialized to 'Nothing'.  Attributes are arbitrary namespaced key–value+pairs which can be attached to almost any item.  They are intended for use+by software higher in the toolchain than bindings, and are distinct from+normal GIR annotations.++Both the /@name@/ and /@value@/ should be treated as constants+and must not be freed.++\<example>+\<title>Iterating over attributes\<\/title>+\<programlisting>+void+print_attributes (GIBaseInfo *info)+{+  GIAttributeIter iter = { 0, };+  char *name;+  char *value;+  while (g_base_info_iterate_attributes (info, &iter, &name, &value))+    {+      g_print (\"attribute name: @/s/@ value: @/s/@\", name, value);+    }+}+\<\/programlisting>+\<\/example>+-}+baseInfoIterateAttributes ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    BaseInfo+    {- ^ /@info@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -}+    -> GIRepository.AttributeIter.AttributeIter+    {- ^ /@iterator@/: a 'GI.GIRepository.Structs.AttributeIter.AttributeIter' structure, must be initialized; see below -}+    -> m ((Bool, T.Text, T.Text))+    {- ^ __Returns:__ 'True' if there are more attributes -}+baseInfoIterateAttributes info iterator = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    iterator' <- unsafeManagedPtrGetPtr iterator+    name <- allocMem :: IO (Ptr CString)+    value <- allocMem :: IO (Ptr CString)+    result <- g_base_info_iterate_attributes info' iterator' name value+    let result' = (/= 0) result+    name' <- peek name+    name'' <- cstringToText name'+    value' <- peek value+    value'' <- cstringToText value'+    touchManagedPtr info+    touchManagedPtr iterator+    freeMem name+    freeMem value+    return (result', name'', value'')++#if ENABLE_OVERLOADING+data BaseInfoIterateAttributesMethodInfo+instance (signature ~ (GIRepository.AttributeIter.AttributeIter -> m ((Bool, T.Text, T.Text))), MonadIO m) => O.MethodInfo BaseInfoIterateAttributesMethodInfo BaseInfo signature where+    overloadedMethod _ = baseInfoIterateAttributes++#endif++#if ENABLE_OVERLOADING+type family ResolveBaseInfoMethod (t :: Symbol) (o :: *) :: * where+    ResolveBaseInfoMethod "equal" o = BaseInfoEqualMethodInfo+    ResolveBaseInfoMethod "isDeprecated" o = BaseInfoIsDeprecatedMethodInfo+    ResolveBaseInfoMethod "iterateAttributes" o = BaseInfoIterateAttributesMethodInfo+    ResolveBaseInfoMethod "getAttribute" o = BaseInfoGetAttributeMethodInfo+    ResolveBaseInfoMethod "getContainer" o = BaseInfoGetContainerMethodInfo+    ResolveBaseInfoMethod "getName" o = BaseInfoGetNameMethodInfo+    ResolveBaseInfoMethod "getNamespace" o = BaseInfoGetNamespaceMethodInfo+    ResolveBaseInfoMethod "getType" o = BaseInfoGetTypeMethodInfo+    ResolveBaseInfoMethod "getTypelib" o = BaseInfoGetTypelibMethodInfo+    ResolveBaseInfoMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveBaseInfoMethod t BaseInfo, O.MethodInfo info BaseInfo p) => OL.IsLabel t (BaseInfo -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++