    {- |
    Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    License    : LGPL-2.1
    Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

    'GI.Gio.Interfaces.ActionGroup.ActionGroup' represents a group of actions. Actions can be used to
    expose functionality in a structured way, either from one part of a
    program to another, or to the outside world. Action groups are often
    used together with a 'GI.Gio.Objects.MenuModel.MenuModel' that provides additional
    representation data for displaying the actions to the user, e.g. in
    a menu.

    The main way to interact with the actions in a GActionGroup is to
    activate them with 'GI.Gio.Interfaces.ActionGroup.actionGroupActivateAction'. Activating an
    action may require a 'GVariant' parameter. The required type of the
    parameter can be inquired with 'GI.Gio.Interfaces.ActionGroup.actionGroupGetActionParameterType'.
    Actions may be disabled, see 'GI.Gio.Interfaces.ActionGroup.actionGroupGetActionEnabled'.
    Activating a disabled action has no effect.

    Actions may optionally have a state in the form of a 'GVariant'. The
    current state of an action can be inquired with
    'GI.Gio.Interfaces.ActionGroup.actionGroupGetActionState'. Activating a stateful action may
    change its state, but it is also possible to set the state by calling
    'GI.Gio.Interfaces.ActionGroup.actionGroupChangeActionState'.

    As typical example, consider a text editing application which has an
    option to change the current font to \'bold\'. A good way to represent
    this would be a stateful action, with a boolean state. Activating the
    action would toggle the state.

    Each action in the group has a unique name (which is a string).  All
    method calls, except 'GI.Gio.Interfaces.ActionGroup.actionGroupListActions' take the name of
    an action as an argument.

    The 'GI.Gio.Interfaces.ActionGroup.ActionGroup' API is meant to be the \'public\' API to the action
    group.  The calls here are exactly the interaction that \'external
    forces\' (eg: UI, incoming D-Bus messages, etc.) are supposed to have
    with actions.  \'Internal\' APIs (ie: ones meant only to be accessed by
    the action group implementation) are found on subclasses.  This is
    why you will find - for example - 'GI.Gio.Interfaces.ActionGroup.actionGroupGetActionEnabled'
    but not an equivalent @/set()/@ call.

    Signals are emitted on the action group in response to state changes
    on individual actions.

    Implementations of 'GI.Gio.Interfaces.ActionGroup.ActionGroup' should provide implementations for
    the virtual functions 'GI.Gio.Interfaces.ActionGroup.actionGroupListActions' and
    'GI.Gio.Interfaces.ActionGroup.actionGroupQueryAction'.  The other virtual functions should
    not be implemented - their \"wrappers\" are actually implemented with
    calls to 'GI.Gio.Interfaces.ActionGroup.actionGroupQueryAction'.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Interfaces.ActionGroup
        (

    -- * Exported types
        ActionGroup(..)                         ,
        noActionGroup                           ,
        IsActionGroup                           ,
        toActionGroup                           ,

     -- * Methods
    -- ** actionAdded #method:actionAdded#

    #if ENABLE_OVERLOADING
        ActionGroupActionAddedMethodInfo        ,
    #endif
        actionGroupActionAdded                  ,

    -- ** actionEnabledChanged #method:actionEnabledChanged#

    #if ENABLE_OVERLOADING
        ActionGroupActionEnabledChangedMethodInfo,
    #endif
        actionGroupActionEnabledChanged         ,

    -- ** actionRemoved #method:actionRemoved#

    #if ENABLE_OVERLOADING
        ActionGroupActionRemovedMethodInfo      ,
    #endif
        actionGroupActionRemoved                ,

    -- ** actionStateChanged #method:actionStateChanged#

    #if ENABLE_OVERLOADING
        ActionGroupActionStateChangedMethodInfo ,
    #endif
        actionGroupActionStateChanged           ,

    -- ** activateAction #method:activateAction#

    #if ENABLE_OVERLOADING
        ActionGroupActivateActionMethodInfo     ,
    #endif
        actionGroupActivateAction               ,

    -- ** changeActionState #method:changeActionState#

    #if ENABLE_OVERLOADING
        ActionGroupChangeActionStateMethodInfo  ,
    #endif
        actionGroupChangeActionState            ,

    -- ** getActionEnabled #method:getActionEnabled#

    #if ENABLE_OVERLOADING
        ActionGroupGetActionEnabledMethodInfo   ,
    #endif
        actionGroupGetActionEnabled             ,

    -- ** getActionParameterType #method:getActionParameterType#

    #if ENABLE_OVERLOADING
        ActionGroupGetActionParameterTypeMethodInfo,
    #endif
        actionGroupGetActionParameterType       ,

    -- ** getActionState #method:getActionState#

    #if ENABLE_OVERLOADING
        ActionGroupGetActionStateMethodInfo     ,
    #endif
        actionGroupGetActionState               ,

    -- ** getActionStateHint #method:getActionStateHint#

    #if ENABLE_OVERLOADING
        ActionGroupGetActionStateHintMethodInfo ,
    #endif
        actionGroupGetActionStateHint           ,

    -- ** getActionStateType #method:getActionStateType#

    #if ENABLE_OVERLOADING
        ActionGroupGetActionStateTypeMethodInfo ,
    #endif
        actionGroupGetActionStateType           ,

    -- ** hasAction #method:hasAction#

    #if ENABLE_OVERLOADING
        ActionGroupHasActionMethodInfo          ,
    #endif
        actionGroupHasAction                    ,

    -- ** listActions #method:listActions#

    #if ENABLE_OVERLOADING
        ActionGroupListActionsMethodInfo        ,
    #endif
        actionGroupListActions                  ,

    -- ** queryAction #method:queryAction#

    #if ENABLE_OVERLOADING
        ActionGroupQueryActionMethodInfo        ,
    #endif
        actionGroupQueryAction                  ,

     -- * Signals
    -- ** actionAdded #signal:actionAdded#

        ActionGroupActionAddedCallback          ,
    #if ENABLE_OVERLOADING
        ActionGroupActionAddedSignalInfo        ,
    #endif
        C_ActionGroupActionAddedCallback        ,
        afterActionGroupActionAdded             ,
        genClosure_ActionGroupActionAdded       ,
        mk_ActionGroupActionAddedCallback       ,
        noActionGroupActionAddedCallback        ,
        onActionGroupActionAdded                ,
        wrap_ActionGroupActionAddedCallback     ,

    -- ** actionEnabledChanged #signal:actionEnabledChanged#

        ActionGroupActionEnabledChangedCallback ,
    #if ENABLE_OVERLOADING
        ActionGroupActionEnabledChangedSignalInfo,
    #endif
        C_ActionGroupActionEnabledChangedCallback,
        afterActionGroupActionEnabledChanged    ,
        genClosure_ActionGroupActionEnabledChanged,
        mk_ActionGroupActionEnabledChangedCallback,
        noActionGroupActionEnabledChangedCallback,
        onActionGroupActionEnabledChanged       ,
        wrap_ActionGroupActionEnabledChangedCallback,

    -- ** actionRemoved #signal:actionRemoved#

        ActionGroupActionRemovedCallback        ,
    #if ENABLE_OVERLOADING
        ActionGroupActionRemovedSignalInfo      ,
    #endif
        C_ActionGroupActionRemovedCallback      ,
        afterActionGroupActionRemoved           ,
        genClosure_ActionGroupActionRemoved     ,
        mk_ActionGroupActionRemovedCallback     ,
        noActionGroupActionRemovedCallback      ,
        onActionGroupActionRemoved              ,
        wrap_ActionGroupActionRemovedCallback   ,

    -- ** actionStateChanged #signal:actionStateChanged#

        ActionGroupActionStateChangedCallback   ,
    #if ENABLE_OVERLOADING
        ActionGroupActionStateChangedSignalInfo ,
    #endif
        C_ActionGroupActionStateChangedCallback ,
        afterActionGroupActionStateChanged      ,
        genClosure_ActionGroupActionStateChanged,
        mk_ActionGroupActionStateChangedCallback,
        noActionGroupActionStateChangedCallback ,
        onActionGroupActionStateChanged         ,
        wrap_ActionGroupActionStateChangedCallback,

        ) 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.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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    import qualified GI.GLib.Structs.VariantType as GLib.VariantType
    import qualified GI.GObject.Objects.Object as GObject.Object

    -- interface ActionGroup
    -- | Memory-managed wrapper type.
    newtype ActionGroup = ActionGroup (ManagedPtr ActionGroup)
    -- | A convenience alias for `Nothing` :: `Maybe` `ActionGroup`.
    noActionGroup :: Maybe ActionGroup
    noActionGroup = Nothing

    -- signal ActionGroup::action-added
    {- |
    Signals that a new action was just added to the group.
    This signal is emitted after the action has been added
    and is now visible.

    /Since: 2.28/
    -}
    type ActionGroupActionAddedCallback =
        T.Text
        {- ^ /@actionName@/: the name of the action in /@actionGroup@/ -}
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `ActionGroupActionAddedCallback`@.
    noActionGroupActionAddedCallback :: Maybe ActionGroupActionAddedCallback
    noActionGroupActionAddedCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_ActionGroupActionAddedCallback =
        Ptr () ->                               -- object
        CString ->
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_ActionGroupActionAddedCallback`.
    foreign import ccall "wrapper"
        mk_ActionGroupActionAddedCallback :: C_ActionGroupActionAddedCallback -> IO (FunPtr C_ActionGroupActionAddedCallback)

    -- | Wrap the callback into a `Closure`.
    genClosure_ActionGroupActionAdded :: ActionGroupActionAddedCallback -> IO Closure
    genClosure_ActionGroupActionAdded cb = do
        let cb' = wrap_ActionGroupActionAddedCallback cb
        mk_ActionGroupActionAddedCallback cb' >>= newCClosure

    -- | Wrap a `ActionGroupActionAddedCallback` into a `C_ActionGroupActionAddedCallback`.
    wrap_ActionGroupActionAddedCallback ::
        ActionGroupActionAddedCallback ->
        C_ActionGroupActionAddedCallback
    wrap_ActionGroupActionAddedCallback _cb _ actionName _ = do
        actionName' <- cstringToText actionName
        _cb  actionName'

    {- |
    Connect a signal handler for the “@action-added@” signal, to be run before the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.on' actionGroup #actionAdded callback
    @
    -}
    onActionGroupActionAdded :: (IsActionGroup a, MonadIO m) => a -> ActionGroupActionAddedCallback -> m SignalHandlerId
    onActionGroupActionAdded obj cb = liftIO $ do
        let cb' = wrap_ActionGroupActionAddedCallback cb
        cb'' <- mk_ActionGroupActionAddedCallback cb'
        connectSignalFunPtr obj "action-added" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@action-added@” signal, to be run after the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.after' actionGroup #actionAdded callback
    @
    -}
    afterActionGroupActionAdded :: (IsActionGroup a, MonadIO m) => a -> ActionGroupActionAddedCallback -> m SignalHandlerId
    afterActionGroupActionAdded obj cb = liftIO $ do
        let cb' = wrap_ActionGroupActionAddedCallback cb
        cb'' <- mk_ActionGroupActionAddedCallback cb'
        connectSignalFunPtr obj "action-added" cb'' SignalConnectAfter

    -- signal ActionGroup::action-enabled-changed
    {- |
    Signals that the enabled status of the named action has changed.

    /Since: 2.28/
    -}
    type ActionGroupActionEnabledChangedCallback =
        T.Text
        {- ^ /@actionName@/: the name of the action in /@actionGroup@/ -}
        -> Bool
        {- ^ /@enabled@/: whether the action is enabled or not -}
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `ActionGroupActionEnabledChangedCallback`@.
    noActionGroupActionEnabledChangedCallback :: Maybe ActionGroupActionEnabledChangedCallback
    noActionGroupActionEnabledChangedCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_ActionGroupActionEnabledChangedCallback =
        Ptr () ->                               -- object
        CString ->
        CInt ->
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_ActionGroupActionEnabledChangedCallback`.
    foreign import ccall "wrapper"
        mk_ActionGroupActionEnabledChangedCallback :: C_ActionGroupActionEnabledChangedCallback -> IO (FunPtr C_ActionGroupActionEnabledChangedCallback)

    -- | Wrap the callback into a `Closure`.
    genClosure_ActionGroupActionEnabledChanged :: ActionGroupActionEnabledChangedCallback -> IO Closure
    genClosure_ActionGroupActionEnabledChanged cb = do
        let cb' = wrap_ActionGroupActionEnabledChangedCallback cb
        mk_ActionGroupActionEnabledChangedCallback cb' >>= newCClosure

    -- | Wrap a `ActionGroupActionEnabledChangedCallback` into a `C_ActionGroupActionEnabledChangedCallback`.
    wrap_ActionGroupActionEnabledChangedCallback ::
        ActionGroupActionEnabledChangedCallback ->
        C_ActionGroupActionEnabledChangedCallback
    wrap_ActionGroupActionEnabledChangedCallback _cb _ actionName enabled _ = do
        actionName' <- cstringToText actionName
        let enabled' = (/= 0) enabled
        _cb  actionName' enabled'

    {- |
    Connect a signal handler for the “@action-enabled-changed@” signal, to be run before the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.on' actionGroup #actionEnabledChanged callback
    @
    -}
    onActionGroupActionEnabledChanged :: (IsActionGroup a, MonadIO m) => a -> ActionGroupActionEnabledChangedCallback -> m SignalHandlerId
    onActionGroupActionEnabledChanged obj cb = liftIO $ do
        let cb' = wrap_ActionGroupActionEnabledChangedCallback cb
        cb'' <- mk_ActionGroupActionEnabledChangedCallback cb'
        connectSignalFunPtr obj "action-enabled-changed" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@action-enabled-changed@” signal, to be run after the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.after' actionGroup #actionEnabledChanged callback
    @
    -}
    afterActionGroupActionEnabledChanged :: (IsActionGroup a, MonadIO m) => a -> ActionGroupActionEnabledChangedCallback -> m SignalHandlerId
    afterActionGroupActionEnabledChanged obj cb = liftIO $ do
        let cb' = wrap_ActionGroupActionEnabledChangedCallback cb
        cb'' <- mk_ActionGroupActionEnabledChangedCallback cb'
        connectSignalFunPtr obj "action-enabled-changed" cb'' SignalConnectAfter

    -- signal ActionGroup::action-removed
    {- |
    Signals that an action is just about to be removed from the group.
    This signal is emitted before the action is removed, so the action
    is still visible and can be queried from the signal handler.

    /Since: 2.28/
    -}
    type ActionGroupActionRemovedCallback =
        T.Text
        {- ^ /@actionName@/: the name of the action in /@actionGroup@/ -}
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `ActionGroupActionRemovedCallback`@.
    noActionGroupActionRemovedCallback :: Maybe ActionGroupActionRemovedCallback
    noActionGroupActionRemovedCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_ActionGroupActionRemovedCallback =
        Ptr () ->                               -- object
        CString ->
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_ActionGroupActionRemovedCallback`.
    foreign import ccall "wrapper"
        mk_ActionGroupActionRemovedCallback :: C_ActionGroupActionRemovedCallback -> IO (FunPtr C_ActionGroupActionRemovedCallback)

    -- | Wrap the callback into a `Closure`.
    genClosure_ActionGroupActionRemoved :: ActionGroupActionRemovedCallback -> IO Closure
    genClosure_ActionGroupActionRemoved cb = do
        let cb' = wrap_ActionGroupActionRemovedCallback cb
        mk_ActionGroupActionRemovedCallback cb' >>= newCClosure

    -- | Wrap a `ActionGroupActionRemovedCallback` into a `C_ActionGroupActionRemovedCallback`.
    wrap_ActionGroupActionRemovedCallback ::
        ActionGroupActionRemovedCallback ->
        C_ActionGroupActionRemovedCallback
    wrap_ActionGroupActionRemovedCallback _cb _ actionName _ = do
        actionName' <- cstringToText actionName
        _cb  actionName'

    {- |
    Connect a signal handler for the “@action-removed@” signal, to be run before the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.on' actionGroup #actionRemoved callback
    @
    -}
    onActionGroupActionRemoved :: (IsActionGroup a, MonadIO m) => a -> ActionGroupActionRemovedCallback -> m SignalHandlerId
    onActionGroupActionRemoved obj cb = liftIO $ do
        let cb' = wrap_ActionGroupActionRemovedCallback cb
        cb'' <- mk_ActionGroupActionRemovedCallback cb'
        connectSignalFunPtr obj "action-removed" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@action-removed@” signal, to be run after the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.after' actionGroup #actionRemoved callback
    @
    -}
    afterActionGroupActionRemoved :: (IsActionGroup a, MonadIO m) => a -> ActionGroupActionRemovedCallback -> m SignalHandlerId
    afterActionGroupActionRemoved obj cb = liftIO $ do
        let cb' = wrap_ActionGroupActionRemovedCallback cb
        cb'' <- mk_ActionGroupActionRemovedCallback cb'
        connectSignalFunPtr obj "action-removed" cb'' SignalConnectAfter

    -- signal ActionGroup::action-state-changed
    {- |
    Signals that the state of the named action has changed.

    /Since: 2.28/
    -}
    type ActionGroupActionStateChangedCallback =
        T.Text
        {- ^ /@actionName@/: the name of the action in /@actionGroup@/ -}
        -> GVariant
        {- ^ /@value@/: the new value of the state -}
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `ActionGroupActionStateChangedCallback`@.
    noActionGroupActionStateChangedCallback :: Maybe ActionGroupActionStateChangedCallback
    noActionGroupActionStateChangedCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_ActionGroupActionStateChangedCallback =
        Ptr () ->                               -- object
        CString ->
        Ptr GVariant ->
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_ActionGroupActionStateChangedCallback`.
    foreign import ccall "wrapper"
        mk_ActionGroupActionStateChangedCallback :: C_ActionGroupActionStateChangedCallback -> IO (FunPtr C_ActionGroupActionStateChangedCallback)

    -- | Wrap the callback into a `Closure`.
    genClosure_ActionGroupActionStateChanged :: ActionGroupActionStateChangedCallback -> IO Closure
    genClosure_ActionGroupActionStateChanged cb = do
        let cb' = wrap_ActionGroupActionStateChangedCallback cb
        mk_ActionGroupActionStateChangedCallback cb' >>= newCClosure

    -- | Wrap a `ActionGroupActionStateChangedCallback` into a `C_ActionGroupActionStateChangedCallback`.
    wrap_ActionGroupActionStateChangedCallback ::
        ActionGroupActionStateChangedCallback ->
        C_ActionGroupActionStateChangedCallback
    wrap_ActionGroupActionStateChangedCallback _cb _ actionName value _ = do
        actionName' <- cstringToText actionName
        value' <- B.GVariant.newGVariantFromPtr value
        _cb  actionName' value'

    {- |
    Connect a signal handler for the “@action-state-changed@” signal, to be run before the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.on' actionGroup #actionStateChanged callback
    @
    -}
    onActionGroupActionStateChanged :: (IsActionGroup a, MonadIO m) => a -> ActionGroupActionStateChangedCallback -> m SignalHandlerId
    onActionGroupActionStateChanged obj cb = liftIO $ do
        let cb' = wrap_ActionGroupActionStateChangedCallback cb
        cb'' <- mk_ActionGroupActionStateChangedCallback cb'
        connectSignalFunPtr obj "action-state-changed" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@action-state-changed@” signal, to be run after the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.after' actionGroup #actionStateChanged callback
    @
    -}
    afterActionGroupActionStateChanged :: (IsActionGroup a, MonadIO m) => a -> ActionGroupActionStateChangedCallback -> m SignalHandlerId
    afterActionGroupActionStateChanged obj cb = liftIO $ do
        let cb' = wrap_ActionGroupActionStateChangedCallback cb
        cb'' <- mk_ActionGroupActionStateChangedCallback cb'
        connectSignalFunPtr obj "action-state-changed" cb'' SignalConnectAfter

    #if ENABLE_OVERLOADING
    data ActionGroupActionAddedSignalInfo
    instance SignalInfo ActionGroupActionAddedSignalInfo where
        type HaskellCallbackType ActionGroupActionAddedSignalInfo = ActionGroupActionAddedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_ActionGroupActionAddedCallback cb
            cb'' <- mk_ActionGroupActionAddedCallback cb'
            connectSignalFunPtr obj "action-added" cb'' connectMode

    data ActionGroupActionEnabledChangedSignalInfo
    instance SignalInfo ActionGroupActionEnabledChangedSignalInfo where
        type HaskellCallbackType ActionGroupActionEnabledChangedSignalInfo = ActionGroupActionEnabledChangedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_ActionGroupActionEnabledChangedCallback cb
            cb'' <- mk_ActionGroupActionEnabledChangedCallback cb'
            connectSignalFunPtr obj "action-enabled-changed" cb'' connectMode

    data ActionGroupActionRemovedSignalInfo
    instance SignalInfo ActionGroupActionRemovedSignalInfo where
        type HaskellCallbackType ActionGroupActionRemovedSignalInfo = ActionGroupActionRemovedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_ActionGroupActionRemovedCallback cb
            cb'' <- mk_ActionGroupActionRemovedCallback cb'
            connectSignalFunPtr obj "action-removed" cb'' connectMode

    data ActionGroupActionStateChangedSignalInfo
    instance SignalInfo ActionGroupActionStateChangedSignalInfo where
        type HaskellCallbackType ActionGroupActionStateChangedSignalInfo = ActionGroupActionStateChangedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_ActionGroupActionStateChangedCallback cb
            cb'' <- mk_ActionGroupActionStateChangedCallback cb'
            connectSignalFunPtr obj "action-state-changed" cb'' connectMode

    type instance O.SignalList ActionGroup = ActionGroupSignalList
    type ActionGroupSignalList = ('[ '("actionAdded", ActionGroupActionAddedSignalInfo), '("actionEnabledChanged", ActionGroupActionEnabledChangedSignalInfo), '("actionRemoved", ActionGroupActionRemovedSignalInfo), '("actionStateChanged", ActionGroupActionStateChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

    #endif

    foreign import ccall "g_action_group_get_type"
        c_g_action_group_get_type :: IO GType

    instance GObject ActionGroup where
        gobjectType _ = c_g_action_group_get_type

    -- | Type class for types which can be safely cast to `ActionGroup`, for instance with `toActionGroup`.
    class GObject o => IsActionGroup o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError ActionGroup a) =>
        IsActionGroup a
    #endif
    instance IsActionGroup ActionGroup
    instance GObject.Object.IsObject ActionGroup

    -- | Cast to `ActionGroup`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toActionGroup :: (MonadIO m, IsActionGroup o) => o -> m ActionGroup
    toActionGroup = liftIO . unsafeCastTo ActionGroup

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList ActionGroup
    type instance O.AttributeList ActionGroup = ActionGroupAttributeList
    type ActionGroupAttributeList = ('[ ] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    #endif

    #if ENABLE_OVERLOADING
    type family ResolveActionGroupMethod (t :: Symbol) (o :: *) :: * where
        ResolveActionGroupMethod "actionAdded" o = ActionGroupActionAddedMethodInfo
        ResolveActionGroupMethod "actionEnabledChanged" o = ActionGroupActionEnabledChangedMethodInfo
        ResolveActionGroupMethod "actionRemoved" o = ActionGroupActionRemovedMethodInfo
        ResolveActionGroupMethod "actionStateChanged" o = ActionGroupActionStateChangedMethodInfo
        ResolveActionGroupMethod "activateAction" o = ActionGroupActivateActionMethodInfo
        ResolveActionGroupMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveActionGroupMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveActionGroupMethod "changeActionState" o = ActionGroupChangeActionStateMethodInfo
        ResolveActionGroupMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveActionGroupMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveActionGroupMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveActionGroupMethod "hasAction" o = ActionGroupHasActionMethodInfo
        ResolveActionGroupMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveActionGroupMethod "listActions" o = ActionGroupListActionsMethodInfo
        ResolveActionGroupMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveActionGroupMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveActionGroupMethod "queryAction" o = ActionGroupQueryActionMethodInfo
        ResolveActionGroupMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveActionGroupMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveActionGroupMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveActionGroupMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveActionGroupMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveActionGroupMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveActionGroupMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveActionGroupMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveActionGroupMethod "getActionEnabled" o = ActionGroupGetActionEnabledMethodInfo
        ResolveActionGroupMethod "getActionParameterType" o = ActionGroupGetActionParameterTypeMethodInfo
        ResolveActionGroupMethod "getActionState" o = ActionGroupGetActionStateMethodInfo
        ResolveActionGroupMethod "getActionStateHint" o = ActionGroupGetActionStateHintMethodInfo
        ResolveActionGroupMethod "getActionStateType" o = ActionGroupGetActionStateTypeMethodInfo
        ResolveActionGroupMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveActionGroupMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveActionGroupMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveActionGroupMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveActionGroupMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveActionGroupMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveActionGroupMethod t ActionGroup, O.MethodInfo info ActionGroup p) => O.IsLabelProxy t (ActionGroup -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveActionGroupMethod t ActionGroup, O.MethodInfo info ActionGroup p) => O.IsLabel t (ActionGroup -> 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

    #endif

    -- method ActionGroup::action_added
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "action_group", argType = TInterface (Name {namespace = "Gio", name = "ActionGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GActionGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of an action in the group", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_action_group_action_added" g_action_group_action_added ::
        Ptr ActionGroup ->                      -- action_group : TInterface (Name {namespace = "Gio", name = "ActionGroup"})
        CString ->                              -- action_name : TBasicType TUTF8
        IO ()

    {- |
    Emits the 'GI.Gio.Interfaces.ActionGroup.ActionGroup'::@/action-added/@ signal on /@actionGroup@/.

    This function should only be called by 'GI.Gio.Interfaces.ActionGroup.ActionGroup' implementations.

    /Since: 2.28/
    -}
    actionGroupActionAdded ::
        (B.CallStack.HasCallStack, MonadIO m, IsActionGroup a) =>
        a
        {- ^ /@actionGroup@/: a 'GI.Gio.Interfaces.ActionGroup.ActionGroup' -}
        -> T.Text
        {- ^ /@actionName@/: the name of an action in the group -}
        -> m ()
    actionGroupActionAdded actionGroup actionName = liftIO $ do
        actionGroup' <- unsafeManagedPtrCastPtr actionGroup
        actionName' <- textToCString actionName
        g_action_group_action_added actionGroup' actionName'
        touchManagedPtr actionGroup
        freeMem actionName'
        return ()

    #if ENABLE_OVERLOADING
    data ActionGroupActionAddedMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m, IsActionGroup a) => O.MethodInfo ActionGroupActionAddedMethodInfo a signature where
        overloadedMethod _ = actionGroupActionAdded

    #endif

    -- method ActionGroup::action_enabled_changed
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "action_group", argType = TInterface (Name {namespace = "Gio", name = "ActionGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GActionGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of an action in the group", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether or not the action is now enabled", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_action_group_action_enabled_changed" g_action_group_action_enabled_changed ::
        Ptr ActionGroup ->                      -- action_group : TInterface (Name {namespace = "Gio", name = "ActionGroup"})
        CString ->                              -- action_name : TBasicType TUTF8
        CInt ->                                 -- enabled : TBasicType TBoolean
        IO ()

    {- |
    Emits the 'GI.Gio.Interfaces.ActionGroup.ActionGroup'::@/action-enabled-changed/@ signal on /@actionGroup@/.

    This function should only be called by 'GI.Gio.Interfaces.ActionGroup.ActionGroup' implementations.

    /Since: 2.28/
    -}
    actionGroupActionEnabledChanged ::
        (B.CallStack.HasCallStack, MonadIO m, IsActionGroup a) =>
        a
        {- ^ /@actionGroup@/: a 'GI.Gio.Interfaces.ActionGroup.ActionGroup' -}
        -> T.Text
        {- ^ /@actionName@/: the name of an action in the group -}
        -> Bool
        {- ^ /@enabled@/: whether or not the action is now enabled -}
        -> m ()
    actionGroupActionEnabledChanged actionGroup actionName enabled = liftIO $ do
        actionGroup' <- unsafeManagedPtrCastPtr actionGroup
        actionName' <- textToCString actionName
        let enabled' = (fromIntegral . fromEnum) enabled
        g_action_group_action_enabled_changed actionGroup' actionName' enabled'
        touchManagedPtr actionGroup
        freeMem actionName'
        return ()

    #if ENABLE_OVERLOADING
    data ActionGroupActionEnabledChangedMethodInfo
    instance (signature ~ (T.Text -> Bool -> m ()), MonadIO m, IsActionGroup a) => O.MethodInfo ActionGroupActionEnabledChangedMethodInfo a signature where
        overloadedMethod _ = actionGroupActionEnabledChanged

    #endif

    -- method ActionGroup::action_removed
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "action_group", argType = TInterface (Name {namespace = "Gio", name = "ActionGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GActionGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of an action in the group", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_action_group_action_removed" g_action_group_action_removed ::
        Ptr ActionGroup ->                      -- action_group : TInterface (Name {namespace = "Gio", name = "ActionGroup"})
        CString ->                              -- action_name : TBasicType TUTF8
        IO ()

    {- |
    Emits the 'GI.Gio.Interfaces.ActionGroup.ActionGroup'::@/action-removed/@ signal on /@actionGroup@/.

    This function should only be called by 'GI.Gio.Interfaces.ActionGroup.ActionGroup' implementations.

    /Since: 2.28/
    -}
    actionGroupActionRemoved ::
        (B.CallStack.HasCallStack, MonadIO m, IsActionGroup a) =>
        a
        {- ^ /@actionGroup@/: a 'GI.Gio.Interfaces.ActionGroup.ActionGroup' -}
        -> T.Text
        {- ^ /@actionName@/: the name of an action in the group -}
        -> m ()
    actionGroupActionRemoved actionGroup actionName = liftIO $ do
        actionGroup' <- unsafeManagedPtrCastPtr actionGroup
        actionName' <- textToCString actionName
        g_action_group_action_removed actionGroup' actionName'
        touchManagedPtr actionGroup
        freeMem actionName'
        return ()

    #if ENABLE_OVERLOADING
    data ActionGroupActionRemovedMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m, IsActionGroup a) => O.MethodInfo ActionGroupActionRemovedMethodInfo a signature where
        overloadedMethod _ = actionGroupActionRemoved

    #endif

    -- method ActionGroup::action_state_changed
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "action_group", argType = TInterface (Name {namespace = "Gio", name = "ActionGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GActionGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of an action in the group", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new state of the named action", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_action_group_action_state_changed" g_action_group_action_state_changed ::
        Ptr ActionGroup ->                      -- action_group : TInterface (Name {namespace = "Gio", name = "ActionGroup"})
        CString ->                              -- action_name : TBasicType TUTF8
        Ptr GVariant ->                         -- state : TVariant
        IO ()

    {- |
    Emits the 'GI.Gio.Interfaces.ActionGroup.ActionGroup'::@/action-state-changed/@ signal on /@actionGroup@/.

    This function should only be called by 'GI.Gio.Interfaces.ActionGroup.ActionGroup' implementations.

    /Since: 2.28/
    -}
    actionGroupActionStateChanged ::
        (B.CallStack.HasCallStack, MonadIO m, IsActionGroup a) =>
        a
        {- ^ /@actionGroup@/: a 'GI.Gio.Interfaces.ActionGroup.ActionGroup' -}
        -> T.Text
        {- ^ /@actionName@/: the name of an action in the group -}
        -> GVariant
        {- ^ /@state@/: the new state of the named action -}
        -> m ()
    actionGroupActionStateChanged actionGroup actionName state = liftIO $ do
        actionGroup' <- unsafeManagedPtrCastPtr actionGroup
        actionName' <- textToCString actionName
        state' <- unsafeManagedPtrGetPtr state
        g_action_group_action_state_changed actionGroup' actionName' state'
        touchManagedPtr actionGroup
        touchManagedPtr state
        freeMem actionName'
        return ()

    #if ENABLE_OVERLOADING
    data ActionGroupActionStateChangedMethodInfo
    instance (signature ~ (T.Text -> GVariant -> m ()), MonadIO m, IsActionGroup a) => O.MethodInfo ActionGroupActionStateChangedMethodInfo a signature where
        overloadedMethod _ = actionGroupActionStateChanged

    #endif

    -- method ActionGroup::activate_action
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "action_group", argType = TInterface (Name {namespace = "Gio", name = "ActionGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GActionGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the action to activate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameter", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "parameters to the activation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_action_group_activate_action" g_action_group_activate_action ::
        Ptr ActionGroup ->                      -- action_group : TInterface (Name {namespace = "Gio", name = "ActionGroup"})
        CString ->                              -- action_name : TBasicType TUTF8
        Ptr GVariant ->                         -- parameter : TVariant
        IO ()

    {- |
    Activate the named action within /@actionGroup@/.

    If the action is expecting a parameter, then the correct type of
    parameter must be given as /@parameter@/.  If the action is expecting no
    parameters then /@parameter@/ must be 'Nothing'.  See
    'GI.Gio.Interfaces.ActionGroup.actionGroupGetActionParameterType'.

    /Since: 2.28/
    -}
    actionGroupActivateAction ::
        (B.CallStack.HasCallStack, MonadIO m, IsActionGroup a) =>
        a
        {- ^ /@actionGroup@/: a 'GI.Gio.Interfaces.ActionGroup.ActionGroup' -}
        -> T.Text
        {- ^ /@actionName@/: the name of the action to activate -}
        -> Maybe (GVariant)
        {- ^ /@parameter@/: parameters to the activation -}
        -> m ()
    actionGroupActivateAction actionGroup actionName parameter = liftIO $ do
        actionGroup' <- unsafeManagedPtrCastPtr actionGroup
        actionName' <- textToCString actionName
        maybeParameter <- case parameter of
            Nothing -> return nullPtr
            Just jParameter -> do
                jParameter' <- unsafeManagedPtrGetPtr jParameter
                return jParameter'
        g_action_group_activate_action actionGroup' actionName' maybeParameter
        touchManagedPtr actionGroup
        whenJust parameter touchManagedPtr
        freeMem actionName'
        return ()

    #if ENABLE_OVERLOADING
    data ActionGroupActivateActionMethodInfo
    instance (signature ~ (T.Text -> Maybe (GVariant) -> m ()), MonadIO m, IsActionGroup a) => O.MethodInfo ActionGroupActivateActionMethodInfo a signature where
        overloadedMethod _ = actionGroupActivateAction

    #endif

    -- method ActionGroup::change_action_state
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "action_group", argType = TInterface (Name {namespace = "Gio", name = "ActionGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GActionGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the action to request the change on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new state", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_action_group_change_action_state" g_action_group_change_action_state ::
        Ptr ActionGroup ->                      -- action_group : TInterface (Name {namespace = "Gio", name = "ActionGroup"})
        CString ->                              -- action_name : TBasicType TUTF8
        Ptr GVariant ->                         -- value : TVariant
        IO ()

    {- |
    Request for the state of the named action within /@actionGroup@/ to be
    changed to /@value@/.

    The action must be stateful and /@value@/ must be of the correct type.
    See 'GI.Gio.Interfaces.ActionGroup.actionGroupGetActionStateType'.

    This call merely requests a change.  The action may refuse to change
    its state or may change its state to something other than /@value@/.
    See 'GI.Gio.Interfaces.ActionGroup.actionGroupGetActionStateHint'.

    If the /@value@/ GVariant is floating, it is consumed.

    /Since: 2.28/
    -}
    actionGroupChangeActionState ::
        (B.CallStack.HasCallStack, MonadIO m, IsActionGroup a) =>
        a
        {- ^ /@actionGroup@/: a 'GI.Gio.Interfaces.ActionGroup.ActionGroup' -}
        -> T.Text
        {- ^ /@actionName@/: the name of the action to request the change on -}
        -> GVariant
        {- ^ /@value@/: the new state -}
        -> m ()
    actionGroupChangeActionState actionGroup actionName value = liftIO $ do
        actionGroup' <- unsafeManagedPtrCastPtr actionGroup
        actionName' <- textToCString actionName
        value' <- unsafeManagedPtrGetPtr value
        g_action_group_change_action_state actionGroup' actionName' value'
        touchManagedPtr actionGroup
        touchManagedPtr value
        freeMem actionName'
        return ()

    #if ENABLE_OVERLOADING
    data ActionGroupChangeActionStateMethodInfo
    instance (signature ~ (T.Text -> GVariant -> m ()), MonadIO m, IsActionGroup a) => O.MethodInfo ActionGroupChangeActionStateMethodInfo a signature where
        overloadedMethod _ = actionGroupChangeActionState

    #endif

    -- method ActionGroup::get_action_enabled
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "action_group", argType = TInterface (Name {namespace = "Gio", name = "ActionGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GActionGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the action to query", 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_action_group_get_action_enabled" g_action_group_get_action_enabled ::
        Ptr ActionGroup ->                      -- action_group : TInterface (Name {namespace = "Gio", name = "ActionGroup"})
        CString ->                              -- action_name : TBasicType TUTF8
        IO CInt

    {- |
    Checks if the named action within /@actionGroup@/ is currently enabled.

    An action must be enabled in order to be activated or in order to
    have its state changed from outside callers.

    /Since: 2.28/
    -}
    actionGroupGetActionEnabled ::
        (B.CallStack.HasCallStack, MonadIO m, IsActionGroup a) =>
        a
        {- ^ /@actionGroup@/: a 'GI.Gio.Interfaces.ActionGroup.ActionGroup' -}
        -> T.Text
        {- ^ /@actionName@/: the name of the action to query -}
        -> m Bool
        {- ^ __Returns:__ whether or not the action is currently enabled -}
    actionGroupGetActionEnabled actionGroup actionName = liftIO $ do
        actionGroup' <- unsafeManagedPtrCastPtr actionGroup
        actionName' <- textToCString actionName
        result <- g_action_group_get_action_enabled actionGroup' actionName'
        let result' = (/= 0) result
        touchManagedPtr actionGroup
        freeMem actionName'
        return result'

    #if ENABLE_OVERLOADING
    data ActionGroupGetActionEnabledMethodInfo
    instance (signature ~ (T.Text -> m Bool), MonadIO m, IsActionGroup a) => O.MethodInfo ActionGroupGetActionEnabledMethodInfo a signature where
        overloadedMethod _ = actionGroupGetActionEnabled

    #endif

    -- method ActionGroup::get_action_parameter_type
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "action_group", argType = TInterface (Name {namespace = "Gio", name = "ActionGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GActionGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the action to query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "VariantType"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_action_group_get_action_parameter_type" g_action_group_get_action_parameter_type ::
        Ptr ActionGroup ->                      -- action_group : TInterface (Name {namespace = "Gio", name = "ActionGroup"})
        CString ->                              -- action_name : TBasicType TUTF8
        IO (Ptr GLib.VariantType.VariantType)

    {- |
    Queries the type of the parameter that must be given when activating
    the named action within /@actionGroup@/.

    When activating the action using 'GI.Gio.Interfaces.ActionGroup.actionGroupActivateAction',
    the 'GVariant' given to that function must be of the type returned
    by this function.

    In the case that this function returns 'Nothing', you must not give any
    'GVariant', but 'Nothing' instead.

    The parameter type of a particular action will never change but it is
    possible for an action to be removed and for a new action to be added
    with the same name but a different parameter type.

    /Since: 2.28/
    -}
    actionGroupGetActionParameterType ::
        (B.CallStack.HasCallStack, MonadIO m, IsActionGroup a) =>
        a
        {- ^ /@actionGroup@/: a 'GI.Gio.Interfaces.ActionGroup.ActionGroup' -}
        -> T.Text
        {- ^ /@actionName@/: the name of the action to query -}
        -> m (Maybe GLib.VariantType.VariantType)
        {- ^ __Returns:__ the parameter type -}
    actionGroupGetActionParameterType actionGroup actionName = liftIO $ do
        actionGroup' <- unsafeManagedPtrCastPtr actionGroup
        actionName' <- textToCString actionName
        result <- g_action_group_get_action_parameter_type actionGroup' actionName'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newBoxed GLib.VariantType.VariantType) result'
            return result''
        touchManagedPtr actionGroup
        freeMem actionName'
        return maybeResult

    #if ENABLE_OVERLOADING
    data ActionGroupGetActionParameterTypeMethodInfo
    instance (signature ~ (T.Text -> m (Maybe GLib.VariantType.VariantType)), MonadIO m, IsActionGroup a) => O.MethodInfo ActionGroupGetActionParameterTypeMethodInfo a signature where
        overloadedMethod _ = actionGroupGetActionParameterType

    #endif

    -- method ActionGroup::get_action_state
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "action_group", argType = TInterface (Name {namespace = "Gio", name = "ActionGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GActionGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the action to query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just TVariant
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_action_group_get_action_state" g_action_group_get_action_state ::
        Ptr ActionGroup ->                      -- action_group : TInterface (Name {namespace = "Gio", name = "ActionGroup"})
        CString ->                              -- action_name : TBasicType TUTF8
        IO (Ptr GVariant)

    {- |
    Queries the current state of the named action within /@actionGroup@/.

    If the action is not stateful then 'Nothing' will be returned.  If the
    action is stateful then the type of the return value is the type
    given by 'GI.Gio.Interfaces.ActionGroup.actionGroupGetActionStateType'.

    The return value (if non-'Nothing') should be freed with
    'GI.GLib.Structs.Variant.variantUnref' when it is no longer required.

    /Since: 2.28/
    -}
    actionGroupGetActionState ::
        (B.CallStack.HasCallStack, MonadIO m, IsActionGroup a) =>
        a
        {- ^ /@actionGroup@/: a 'GI.Gio.Interfaces.ActionGroup.ActionGroup' -}
        -> T.Text
        {- ^ /@actionName@/: the name of the action to query -}
        -> m (Maybe GVariant)
        {- ^ __Returns:__ the current state of the action -}
    actionGroupGetActionState actionGroup actionName = liftIO $ do
        actionGroup' <- unsafeManagedPtrCastPtr actionGroup
        actionName' <- textToCString actionName
        result <- g_action_group_get_action_state actionGroup' actionName'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- B.GVariant.wrapGVariantPtr result'
            return result''
        touchManagedPtr actionGroup
        freeMem actionName'
        return maybeResult

    #if ENABLE_OVERLOADING
    data ActionGroupGetActionStateMethodInfo
    instance (signature ~ (T.Text -> m (Maybe GVariant)), MonadIO m, IsActionGroup a) => O.MethodInfo ActionGroupGetActionStateMethodInfo a signature where
        overloadedMethod _ = actionGroupGetActionState

    #endif

    -- method ActionGroup::get_action_state_hint
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "action_group", argType = TInterface (Name {namespace = "Gio", name = "ActionGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GActionGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the action to query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just TVariant
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_action_group_get_action_state_hint" g_action_group_get_action_state_hint ::
        Ptr ActionGroup ->                      -- action_group : TInterface (Name {namespace = "Gio", name = "ActionGroup"})
        CString ->                              -- action_name : TBasicType TUTF8
        IO (Ptr GVariant)

    {- |
    Requests a hint about the valid range of values for the state of the
    named action within /@actionGroup@/.

    If 'Nothing' is returned it either means that the action is not stateful
    or that there is no hint about the valid range of values for the
    state of the action.

    If a 'GVariant' array is returned then each item in the array is a
    possible value for the state.  If a 'GVariant' pair (ie: two-tuple) is
    returned then the tuple specifies the inclusive lower and upper bound
    of valid values for the state.

    In any case, the information is merely a hint.  It may be possible to
    have a state value outside of the hinted range and setting a value
    within the range may fail.

    The return value (if non-'Nothing') should be freed with
    'GI.GLib.Structs.Variant.variantUnref' when it is no longer required.

    /Since: 2.28/
    -}
    actionGroupGetActionStateHint ::
        (B.CallStack.HasCallStack, MonadIO m, IsActionGroup a) =>
        a
        {- ^ /@actionGroup@/: a 'GI.Gio.Interfaces.ActionGroup.ActionGroup' -}
        -> T.Text
        {- ^ /@actionName@/: the name of the action to query -}
        -> m (Maybe GVariant)
        {- ^ __Returns:__ the state range hint -}
    actionGroupGetActionStateHint actionGroup actionName = liftIO $ do
        actionGroup' <- unsafeManagedPtrCastPtr actionGroup
        actionName' <- textToCString actionName
        result <- g_action_group_get_action_state_hint actionGroup' actionName'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- B.GVariant.wrapGVariantPtr result'
            return result''
        touchManagedPtr actionGroup
        freeMem actionName'
        return maybeResult

    #if ENABLE_OVERLOADING
    data ActionGroupGetActionStateHintMethodInfo
    instance (signature ~ (T.Text -> m (Maybe GVariant)), MonadIO m, IsActionGroup a) => O.MethodInfo ActionGroupGetActionStateHintMethodInfo a signature where
        overloadedMethod _ = actionGroupGetActionStateHint

    #endif

    -- method ActionGroup::get_action_state_type
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "action_group", argType = TInterface (Name {namespace = "Gio", name = "ActionGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GActionGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the action to query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "VariantType"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_action_group_get_action_state_type" g_action_group_get_action_state_type ::
        Ptr ActionGroup ->                      -- action_group : TInterface (Name {namespace = "Gio", name = "ActionGroup"})
        CString ->                              -- action_name : TBasicType TUTF8
        IO (Ptr GLib.VariantType.VariantType)

    {- |
    Queries the type of the state of the named action within
    /@actionGroup@/.

    If the action is stateful then this function returns the
    'GI.GLib.Structs.VariantType.VariantType' of the state.  All calls to
    'GI.Gio.Interfaces.ActionGroup.actionGroupChangeActionState' must give a 'GVariant' of this
    type and 'GI.Gio.Interfaces.ActionGroup.actionGroupGetActionState' will return a 'GVariant'
    of the same type.

    If the action is not stateful then this function will return 'Nothing'.
    In that case, 'GI.Gio.Interfaces.ActionGroup.actionGroupGetActionState' will return 'Nothing'
    and you must not call 'GI.Gio.Interfaces.ActionGroup.actionGroupChangeActionState'.

    The state type of a particular action will never change but it is
    possible for an action to be removed and for a new action to be added
    with the same name but a different state type.

    /Since: 2.28/
    -}
    actionGroupGetActionStateType ::
        (B.CallStack.HasCallStack, MonadIO m, IsActionGroup a) =>
        a
        {- ^ /@actionGroup@/: a 'GI.Gio.Interfaces.ActionGroup.ActionGroup' -}
        -> T.Text
        {- ^ /@actionName@/: the name of the action to query -}
        -> m (Maybe GLib.VariantType.VariantType)
        {- ^ __Returns:__ the state type, if the action is stateful -}
    actionGroupGetActionStateType actionGroup actionName = liftIO $ do
        actionGroup' <- unsafeManagedPtrCastPtr actionGroup
        actionName' <- textToCString actionName
        result <- g_action_group_get_action_state_type actionGroup' actionName'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newBoxed GLib.VariantType.VariantType) result'
            return result''
        touchManagedPtr actionGroup
        freeMem actionName'
        return maybeResult

    #if ENABLE_OVERLOADING
    data ActionGroupGetActionStateTypeMethodInfo
    instance (signature ~ (T.Text -> m (Maybe GLib.VariantType.VariantType)), MonadIO m, IsActionGroup a) => O.MethodInfo ActionGroupGetActionStateTypeMethodInfo a signature where
        overloadedMethod _ = actionGroupGetActionStateType

    #endif

    -- method ActionGroup::has_action
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "action_group", argType = TInterface (Name {namespace = "Gio", name = "ActionGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GActionGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the action to check for", 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_action_group_has_action" g_action_group_has_action ::
        Ptr ActionGroup ->                      -- action_group : TInterface (Name {namespace = "Gio", name = "ActionGroup"})
        CString ->                              -- action_name : TBasicType TUTF8
        IO CInt

    {- |
    Checks if the named action exists within /@actionGroup@/.

    /Since: 2.28/
    -}
    actionGroupHasAction ::
        (B.CallStack.HasCallStack, MonadIO m, IsActionGroup a) =>
        a
        {- ^ /@actionGroup@/: a 'GI.Gio.Interfaces.ActionGroup.ActionGroup' -}
        -> T.Text
        {- ^ /@actionName@/: the name of the action to check for -}
        -> m Bool
        {- ^ __Returns:__ whether the named action exists -}
    actionGroupHasAction actionGroup actionName = liftIO $ do
        actionGroup' <- unsafeManagedPtrCastPtr actionGroup
        actionName' <- textToCString actionName
        result <- g_action_group_has_action actionGroup' actionName'
        let result' = (/= 0) result
        touchManagedPtr actionGroup
        freeMem actionName'
        return result'

    #if ENABLE_OVERLOADING
    data ActionGroupHasActionMethodInfo
    instance (signature ~ (T.Text -> m Bool), MonadIO m, IsActionGroup a) => O.MethodInfo ActionGroupHasActionMethodInfo a signature where
        overloadedMethod _ = actionGroupHasAction

    #endif

    -- method ActionGroup::list_actions
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "action_group", argType = TInterface (Name {namespace = "Gio", name = "ActionGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GActionGroup", 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_action_group_list_actions" g_action_group_list_actions ::
        Ptr ActionGroup ->                      -- action_group : TInterface (Name {namespace = "Gio", name = "ActionGroup"})
        IO (Ptr CString)

    {- |
    Lists the actions contained within /@actionGroup@/.

    The caller is responsible for freeing the list with 'GI.GLib.Functions.strfreev' when
    it is no longer required.

    /Since: 2.28/
    -}
    actionGroupListActions ::
        (B.CallStack.HasCallStack, MonadIO m, IsActionGroup a) =>
        a
        {- ^ /@actionGroup@/: a 'GI.Gio.Interfaces.ActionGroup.ActionGroup' -}
        -> m [T.Text]
        {- ^ __Returns:__ a 'Nothing'-terminated array of the names of the
    actions in the group -}
    actionGroupListActions actionGroup = liftIO $ do
        actionGroup' <- unsafeManagedPtrCastPtr actionGroup
        result <- g_action_group_list_actions actionGroup'
        checkUnexpectedReturnNULL "actionGroupListActions" result
        result' <- unpackZeroTerminatedUTF8CArray result
        mapZeroTerminatedCArray freeMem result
        freeMem result
        touchManagedPtr actionGroup
        return result'

    #if ENABLE_OVERLOADING
    data ActionGroupListActionsMethodInfo
    instance (signature ~ (m [T.Text]), MonadIO m, IsActionGroup a) => O.MethodInfo ActionGroupListActionsMethodInfo a signature where
        overloadedMethod _ = actionGroupListActions

    #endif

    -- method ActionGroup::query_action
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "action_group", argType = TInterface (Name {namespace = "Gio", name = "ActionGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GActionGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of an action in the group", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if the action is presently enabled", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "parameter_type", argType = TInterface (Name {namespace = "GLib", name = "VariantType"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the parameter type, or %NULL if none needed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "state_type", argType = TInterface (Name {namespace = "GLib", name = "VariantType"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the state type, or %NULL if stateless", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "state_hint", argType = TVariant, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the state hint, or %NULL if none", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "state", argType = TVariant, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the current state, or %NULL if stateless", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_action_group_query_action" g_action_group_query_action ::
        Ptr ActionGroup ->                      -- action_group : TInterface (Name {namespace = "Gio", name = "ActionGroup"})
        CString ->                              -- action_name : TBasicType TUTF8
        Ptr CInt ->                             -- enabled : TBasicType TBoolean
        Ptr (Ptr GLib.VariantType.VariantType) -> -- parameter_type : TInterface (Name {namespace = "GLib", name = "VariantType"})
        Ptr (Ptr GLib.VariantType.VariantType) -> -- state_type : TInterface (Name {namespace = "GLib", name = "VariantType"})
        Ptr (Ptr GVariant) ->                   -- state_hint : TVariant
        Ptr (Ptr GVariant) ->                   -- state : TVariant
        IO CInt

    {- |
    Queries all aspects of the named action within an /@actionGroup@/.

    This function acquires the information available from
    'GI.Gio.Interfaces.ActionGroup.actionGroupHasAction', 'GI.Gio.Interfaces.ActionGroup.actionGroupGetActionEnabled',
    'GI.Gio.Interfaces.ActionGroup.actionGroupGetActionParameterType',
    'GI.Gio.Interfaces.ActionGroup.actionGroupGetActionStateType',
    'GI.Gio.Interfaces.ActionGroup.actionGroupGetActionStateHint' and
    'GI.Gio.Interfaces.ActionGroup.actionGroupGetActionState' with a single function call.

    This provides two main benefits.

    The first is the improvement in efficiency that comes with not having
    to perform repeated lookups of the action in order to discover
    different things about it.  The second is that implementing
    'GI.Gio.Interfaces.ActionGroup.ActionGroup' can now be done by only overriding this one virtual
    function.

    The interface provides a default implementation of this function that
    calls the individual functions, as required, to fetch the
    information.  The interface also provides default implementations of
    those functions that call this function.  All implementations,
    therefore, must override either this function or all of the others.

    If the action exists, 'True' is returned and any of the requested
    fields (as indicated by having a non-'Nothing' reference passed in) are
    filled.  If the action doesn\'t exist, 'False' is returned and the
    fields may or may not have been modified.

    /Since: 2.32/
    -}
    actionGroupQueryAction ::
        (B.CallStack.HasCallStack, MonadIO m, IsActionGroup a) =>
        a
        {- ^ /@actionGroup@/: a 'GI.Gio.Interfaces.ActionGroup.ActionGroup' -}
        -> T.Text
        {- ^ /@actionName@/: the name of an action in the group -}
        -> m ((Bool, Bool, GLib.VariantType.VariantType, GLib.VariantType.VariantType, GVariant, GVariant))
        {- ^ __Returns:__ 'True' if the action exists, else 'False' -}
    actionGroupQueryAction actionGroup actionName = liftIO $ do
        actionGroup' <- unsafeManagedPtrCastPtr actionGroup
        actionName' <- textToCString actionName
        enabled <- allocMem :: IO (Ptr CInt)
        parameterType <- allocMem :: IO (Ptr (Ptr GLib.VariantType.VariantType))
        stateType <- allocMem :: IO (Ptr (Ptr GLib.VariantType.VariantType))
        stateHint <- allocMem :: IO (Ptr (Ptr GVariant))
        state <- allocMem :: IO (Ptr (Ptr GVariant))
        result <- g_action_group_query_action actionGroup' actionName' enabled parameterType stateType stateHint state
        let result' = (/= 0) result
        enabled' <- peek enabled
        let enabled'' = (/= 0) enabled'
        parameterType' <- peek parameterType
        parameterType'' <- (wrapBoxed GLib.VariantType.VariantType) parameterType'
        stateType' <- peek stateType
        stateType'' <- (wrapBoxed GLib.VariantType.VariantType) stateType'
        stateHint' <- peek stateHint
        stateHint'' <- B.GVariant.wrapGVariantPtr stateHint'
        state' <- peek state
        state'' <- B.GVariant.wrapGVariantPtr state'
        touchManagedPtr actionGroup
        freeMem actionName'
        freeMem enabled
        freeMem parameterType
        freeMem stateType
        freeMem stateHint
        freeMem state
        return (result', enabled'', parameterType'', stateType'', stateHint'', state'')

    #if ENABLE_OVERLOADING
    data ActionGroupQueryActionMethodInfo
    instance (signature ~ (T.Text -> m ((Bool, Bool, GLib.VariantType.VariantType, GLib.VariantType.VariantType, GVariant, GVariant))), MonadIO m, IsActionGroup a) => O.MethodInfo ActionGroupQueryActionMethodInfo a signature where
        overloadedMethod _ = actionGroupQueryAction

    #endif