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

    A 'GI.Gio.Objects.SimpleAction.SimpleAction' is the obvious simple implementation of the 'GI.Gio.Interfaces.Action.Action'
    interface. This is the easiest way to create an action for purposes of
    adding it to a 'GI.Gio.Objects.SimpleActionGroup.SimpleActionGroup'.

    See also @/GtkAction/@.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.SimpleAction
        (

    -- * Exported types
        SimpleAction(..)                        ,
        IsSimpleAction                          ,
        toSimpleAction                          ,
        noSimpleAction                          ,

     -- * Methods
    -- ** new #method:new#

        simpleActionNew                         ,

    -- ** newStateful #method:newStateful#

        simpleActionNewStateful                 ,

    -- ** setEnabled #method:setEnabled#

    #if ENABLE_OVERLOADING
        SimpleActionSetEnabledMethodInfo        ,
    #endif
        simpleActionSetEnabled                  ,

    -- ** setState #method:setState#

    #if ENABLE_OVERLOADING
        SimpleActionSetStateMethodInfo          ,
    #endif
        simpleActionSetState                    ,

    -- ** setStateHint #method:setStateHint#

    #if ENABLE_OVERLOADING
        SimpleActionSetStateHintMethodInfo      ,
    #endif
        simpleActionSetStateHint                ,

     -- * Properties
    -- ** enabled #attr:enabled#
    {- | If /@action@/ is currently enabled.

    If the action is disabled then calls to 'GI.Gio.Interfaces.Action.actionActivate' and
    'GI.Gio.Interfaces.Action.actionChangeState' have no effect.

    /Since: 2.28/
    -}
    #if ENABLE_OVERLOADING
        SimpleActionEnabledPropertyInfo         ,
    #endif
        constructSimpleActionEnabled            ,
        getSimpleActionEnabled                  ,
        setSimpleActionEnabled                  ,
    #if ENABLE_OVERLOADING
        simpleActionEnabled                     ,
    #endif

    -- ** name #attr:name#
    {- | The name of the action. This is mostly meaningful for identifying
    the action once it has been added to a 'GI.Gio.Objects.SimpleActionGroup.SimpleActionGroup'.

    /Since: 2.28/
    -}
    #if ENABLE_OVERLOADING
        SimpleActionNamePropertyInfo            ,
    #endif
        constructSimpleActionName               ,
        getSimpleActionName                     ,
    #if ENABLE_OVERLOADING
        simpleActionName                        ,
    #endif

    -- ** parameterType #attr:parameterType#
    {- | The type of the parameter that must be given when activating the
    action.

    /Since: 2.28/
    -}
    #if ENABLE_OVERLOADING
        SimpleActionParameterTypePropertyInfo   ,
    #endif
        constructSimpleActionParameterType      ,
        getSimpleActionParameterType            ,
    #if ENABLE_OVERLOADING
        simpleActionParameterType               ,
    #endif

    -- ** state #attr:state#
    {- | The state of the action, or 'Nothing' if the action is stateless.

    /Since: 2.28/
    -}
    #if ENABLE_OVERLOADING
        SimpleActionStatePropertyInfo           ,
    #endif
        constructSimpleActionState              ,
        getSimpleActionState                    ,
        setSimpleActionState                    ,
    #if ENABLE_OVERLOADING
        simpleActionState                       ,
    #endif

    -- ** stateType #attr:stateType#
    {- | The 'GI.GLib.Structs.VariantType.VariantType' of the state that the action has, or 'Nothing' if the
    action is stateless.

    /Since: 2.28/
    -}
    #if ENABLE_OVERLOADING
        SimpleActionStateTypePropertyInfo       ,
    #endif
        getSimpleActionStateType                ,
    #if ENABLE_OVERLOADING
        simpleActionStateType                   ,
    #endif

     -- * Signals
    -- ** activate #signal:activate#

        C_SimpleActionActivateCallback          ,
        SimpleActionActivateCallback            ,
    #if ENABLE_OVERLOADING
        SimpleActionActivateSignalInfo          ,
    #endif
        afterSimpleActionActivate               ,
        genClosure_SimpleActionActivate         ,
        mk_SimpleActionActivateCallback         ,
        noSimpleActionActivateCallback          ,
        onSimpleActionActivate                  ,
        wrap_SimpleActionActivateCallback       ,

    -- ** changeState #signal:changeState#

        C_SimpleActionChangeStateCallback       ,
        SimpleActionChangeStateCallback         ,
    #if ENABLE_OVERLOADING
        SimpleActionChangeStateSignalInfo       ,
    #endif
        afterSimpleActionChangeState            ,
        genClosure_SimpleActionChangeState      ,
        mk_SimpleActionChangeStateCallback      ,
        noSimpleActionChangeStateCallback       ,
        onSimpleActionChangeState               ,
        wrap_SimpleActionChangeStateCallback    ,

        ) 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
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.Action as Gio.Action

    -- | Memory-managed wrapper type.
    newtype SimpleAction = SimpleAction (ManagedPtr SimpleAction)
    foreign import ccall "g_simple_action_get_type"
        c_g_simple_action_get_type :: IO GType

    instance GObject SimpleAction where
        gobjectType _ = c_g_simple_action_get_type

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

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

    -- | A convenience alias for `Nothing` :: `Maybe` `SimpleAction`.
    noSimpleAction :: Maybe SimpleAction
    noSimpleAction = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveSimpleActionMethod (t :: Symbol) (o :: *) :: * where
        ResolveSimpleActionMethod "activate" o = Gio.Action.ActionActivateMethodInfo
        ResolveSimpleActionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveSimpleActionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveSimpleActionMethod "changeState" o = Gio.Action.ActionChangeStateMethodInfo
        ResolveSimpleActionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveSimpleActionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveSimpleActionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveSimpleActionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveSimpleActionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveSimpleActionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveSimpleActionMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveSimpleActionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveSimpleActionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveSimpleActionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveSimpleActionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveSimpleActionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveSimpleActionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveSimpleActionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveSimpleActionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveSimpleActionMethod "getEnabled" o = Gio.Action.ActionGetEnabledMethodInfo
        ResolveSimpleActionMethod "getName" o = Gio.Action.ActionGetNameMethodInfo
        ResolveSimpleActionMethod "getParameterType" o = Gio.Action.ActionGetParameterTypeMethodInfo
        ResolveSimpleActionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveSimpleActionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveSimpleActionMethod "getState" o = Gio.Action.ActionGetStateMethodInfo
        ResolveSimpleActionMethod "getStateHint" o = Gio.Action.ActionGetStateHintMethodInfo
        ResolveSimpleActionMethod "getStateType" o = Gio.Action.ActionGetStateTypeMethodInfo
        ResolveSimpleActionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveSimpleActionMethod "setEnabled" o = SimpleActionSetEnabledMethodInfo
        ResolveSimpleActionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveSimpleActionMethod "setState" o = SimpleActionSetStateMethodInfo
        ResolveSimpleActionMethod "setStateHint" o = SimpleActionSetStateHintMethodInfo
        ResolveSimpleActionMethod l o = O.MethodResolutionFailed l o

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

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

    -- signal SimpleAction::activate
    {- |
    Indicates that the action was just activated.

    /@parameter@/ will always be of the expected type, i.e. the parameter type
    specified when the action was created. If an incorrect type is given when
    activating the action, this signal is not emitted.

    Since GLib 2.40, if no handler is connected to this signal then the
    default behaviour for boolean-stated actions with a 'Nothing' parameter
    type is to toggle them via the 'GI.Gio.Objects.SimpleAction.SimpleAction'::@/change-state/@ signal.
    For stateful actions where the state type is equal to the parameter
    type, the default is to forward them directly to
    'GI.Gio.Objects.SimpleAction.SimpleAction'::@/change-state/@.  This should allow almost all users
    of 'GI.Gio.Objects.SimpleAction.SimpleAction' to connect only one handler or the other.

    /Since: 2.28/
    -}
    type SimpleActionActivateCallback =
        Maybe GVariant
        {- ^ /@parameter@/: the parameter to the activation, or 'Nothing' if it has
      no parameter -}
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `SimpleActionActivateCallback`@.
    noSimpleActionActivateCallback :: Maybe SimpleActionActivateCallback
    noSimpleActionActivateCallback = Nothing

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

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

    -- | Wrap the callback into a `Closure`.
    genClosure_SimpleActionActivate :: SimpleActionActivateCallback -> IO Closure
    genClosure_SimpleActionActivate cb = do
        let cb' = wrap_SimpleActionActivateCallback cb
        mk_SimpleActionActivateCallback cb' >>= newCClosure

    -- | Wrap a `SimpleActionActivateCallback` into a `C_SimpleActionActivateCallback`.
    wrap_SimpleActionActivateCallback ::
        SimpleActionActivateCallback ->
        C_SimpleActionActivateCallback
    wrap_SimpleActionActivateCallback _cb _ parameter _ = do
        maybeParameter <-
            if parameter == nullPtr
            then return Nothing
            else do
                parameter' <- B.GVariant.newGVariantFromPtr parameter
                return $ Just parameter'
        _cb  maybeParameter

    {- |
    Connect a signal handler for the “@activate@” 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' simpleAction #activate callback
    @
    -}
    onSimpleActionActivate :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionActivateCallback -> m SignalHandlerId
    onSimpleActionActivate obj cb = liftIO $ do
        let cb' = wrap_SimpleActionActivateCallback cb
        cb'' <- mk_SimpleActionActivateCallback cb'
        connectSignalFunPtr obj "activate" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@activate@” 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' simpleAction #activate callback
    @
    -}
    afterSimpleActionActivate :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionActivateCallback -> m SignalHandlerId
    afterSimpleActionActivate obj cb = liftIO $ do
        let cb' = wrap_SimpleActionActivateCallback cb
        cb'' <- mk_SimpleActionActivateCallback cb'
        connectSignalFunPtr obj "activate" cb'' SignalConnectAfter

    -- signal SimpleAction::change-state
    {- |
    Indicates that the action just received a request to change its
    state.

    /@value@/ will always be of the correct state type, i.e. the type of the
    initial state passed to 'GI.Gio.Objects.SimpleAction.simpleActionNewStateful'. If an incorrect
    type is given when requesting to change the state, this signal is not
    emitted.

    If no handler is connected to this signal then the default
    behaviour is to call 'GI.Gio.Objects.SimpleAction.simpleActionSetState' to set the state
    to the requested value. If you connect a signal handler then no
    default action is taken. If the state should change then you must
    call 'GI.Gio.Objects.SimpleAction.simpleActionSetState' from the handler.

    An example of a \'change-state\' handler:

    === /C code/
    >
    >static void
    >change_volume_state (GSimpleAction *action,
    >                     GVariant      *value,
    >                     gpointer       user_data)
    >{
    >  gint requested;
    >
    >  requested = g_variant_get_int32 (value);
    >
    >  // Volume only goes from 0 to 10
    >  if (0 <= requested && requested <= 10)
    >    g_simple_action_set_state (action, value);
    >}

    The handler need not set the state to the requested value.
    It could set it to any value at all, or take some other action.

    /Since: 2.30/
    -}
    type SimpleActionChangeStateCallback =
        Maybe GVariant
        {- ^ /@value@/: the requested value for the state -}
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `SimpleActionChangeStateCallback`@.
    noSimpleActionChangeStateCallback :: Maybe SimpleActionChangeStateCallback
    noSimpleActionChangeStateCallback = Nothing

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

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

    -- | Wrap the callback into a `Closure`.
    genClosure_SimpleActionChangeState :: SimpleActionChangeStateCallback -> IO Closure
    genClosure_SimpleActionChangeState cb = do
        let cb' = wrap_SimpleActionChangeStateCallback cb
        mk_SimpleActionChangeStateCallback cb' >>= newCClosure

    -- | Wrap a `SimpleActionChangeStateCallback` into a `C_SimpleActionChangeStateCallback`.
    wrap_SimpleActionChangeStateCallback ::
        SimpleActionChangeStateCallback ->
        C_SimpleActionChangeStateCallback
    wrap_SimpleActionChangeStateCallback _cb _ value _ = do
        maybeValue <-
            if value == nullPtr
            then return Nothing
            else do
                value' <- B.GVariant.newGVariantFromPtr value
                return $ Just value'
        _cb  maybeValue

    {- |
    Connect a signal handler for the “@change-state@” 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' simpleAction #changeState callback
    @
    -}
    onSimpleActionChangeState :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionChangeStateCallback -> m SignalHandlerId
    onSimpleActionChangeState obj cb = liftIO $ do
        let cb' = wrap_SimpleActionChangeStateCallback cb
        cb'' <- mk_SimpleActionChangeStateCallback cb'
        connectSignalFunPtr obj "change-state" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@change-state@” 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' simpleAction #changeState callback
    @
    -}
    afterSimpleActionChangeState :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionChangeStateCallback -> m SignalHandlerId
    afterSimpleActionChangeState obj cb = liftIO $ do
        let cb' = wrap_SimpleActionChangeStateCallback cb
        cb'' <- mk_SimpleActionChangeStateCallback cb'
        connectSignalFunPtr obj "change-state" cb'' SignalConnectAfter

    --- XXX Duplicated object with different types:
      --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "enabled", propType = TBasicType TBoolean, propFlags = [PropertyReadable,PropertyWritable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "If @action is currently enabled.\n\nIf the action is disabled then calls to g_action_activate() and\ng_action_change_state() have no effect.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
      --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "enabled", propType = TBasicType TBoolean, propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "If @action is currently enabled.\n\nIf the action is disabled then calls to g_action_activate() and\ng_action_change_state() have no effect.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
    --- XXX Duplicated object with different types:
      --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The name of the action. This is mostly meaningful for identifying\nthe action once it has been added to a #GSimpleActionGroup.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
      --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The name of the action.  This is mostly meaningful for identifying\nthe action once it has been added to a #GActionGroup. It is immutable.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
    --- XXX Duplicated object with different types:
      --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "parameter-type", propType = TInterface (Name {namespace = "GLib", name = "VariantType"}), propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The type of the parameter that must be given when activating the\naction.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
      --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "parameter-type", propType = TInterface (Name {namespace = "GLib", name = "VariantType"}), propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The type of the parameter that must be given when activating the\naction. This is immutable, and may be %NULL if no parameter is needed when\nactivating the action.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
    --- XXX Duplicated object with different types:
      --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "state", propType = TVariant, propFlags = [PropertyReadable,PropertyWritable,PropertyConstruct], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The state of the action, or %NULL if the action is stateless.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
      --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "state", propType = TVariant, propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The state of the action, or %NULL if the action is stateless.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
    --- XXX Duplicated object with different types:
      --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "state-type", propType = TInterface (Name {namespace = "GLib", name = "VariantType"}), propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The #GVariantType of the state that the action has, or %NULL if the\naction is stateless.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
      --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "state-type", propType = TInterface (Name {namespace = "GLib", name = "VariantType"}), propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The #GVariantType of the state that the action has, or %NULL if the\naction is stateless. This is immutable.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
    -- VVV Prop "enabled"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Just False)

    {- |
    Get the value of the “@enabled@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' simpleAction #enabled
    @
    -}
    getSimpleActionEnabled :: (MonadIO m, IsSimpleAction o) => o -> m Bool
    getSimpleActionEnabled obj = liftIO $ getObjectPropertyBool obj "enabled"

    {- |
    Set the value of the “@enabled@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' simpleAction [ #enabled 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setSimpleActionEnabled :: (MonadIO m, IsSimpleAction o) => o -> Bool -> m ()
    setSimpleActionEnabled obj val = liftIO $ setObjectPropertyBool obj "enabled" val

    {- |
    Construct a `GValueConstruct` with valid value for the “@enabled@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructSimpleActionEnabled :: (IsSimpleAction o) => Bool -> IO (GValueConstruct o)
    constructSimpleActionEnabled val = constructObjectPropertyBool "enabled" val

    #if ENABLE_OVERLOADING
    data SimpleActionEnabledPropertyInfo
    instance AttrInfo SimpleActionEnabledPropertyInfo where
        type AttrAllowedOps SimpleActionEnabledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint SimpleActionEnabledPropertyInfo = (~) Bool
        type AttrBaseTypeConstraint SimpleActionEnabledPropertyInfo = IsSimpleAction
        type AttrGetType SimpleActionEnabledPropertyInfo = Bool
        type AttrLabel SimpleActionEnabledPropertyInfo = "enabled"
        type AttrOrigin SimpleActionEnabledPropertyInfo = SimpleAction
        attrGet _ = getSimpleActionEnabled
        attrSet _ = setSimpleActionEnabled
        attrConstruct _ = constructSimpleActionEnabled
        attrClear _ = undefined
    #endif

    -- VVV Prop "name"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    {- |
    Get the value of the “@name@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' simpleAction #name
    @
    -}
    getSimpleActionName :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe T.Text)
    getSimpleActionName obj = liftIO $ getObjectPropertyString obj "name"

    {- |
    Construct a `GValueConstruct` with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructSimpleActionName :: (IsSimpleAction o) => T.Text -> IO (GValueConstruct o)
    constructSimpleActionName val = constructObjectPropertyString "name" (Just val)

    #if ENABLE_OVERLOADING
    data SimpleActionNamePropertyInfo
    instance AttrInfo SimpleActionNamePropertyInfo where
        type AttrAllowedOps SimpleActionNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint SimpleActionNamePropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint SimpleActionNamePropertyInfo = IsSimpleAction
        type AttrGetType SimpleActionNamePropertyInfo = (Maybe T.Text)
        type AttrLabel SimpleActionNamePropertyInfo = "name"
        type AttrOrigin SimpleActionNamePropertyInfo = SimpleAction
        attrGet _ = getSimpleActionName
        attrSet _ = undefined
        attrConstruct _ = constructSimpleActionName
        attrClear _ = undefined
    #endif

    -- VVV Prop "parameter-type"
       -- Type: TInterface (Name {namespace = "GLib", name = "VariantType"})
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    {- |
    Get the value of the “@parameter-type@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' simpleAction #parameterType
    @
    -}
    getSimpleActionParameterType :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe GLib.VariantType.VariantType)
    getSimpleActionParameterType obj = liftIO $ getObjectPropertyBoxed obj "parameter-type" GLib.VariantType.VariantType

    {- |
    Construct a `GValueConstruct` with valid value for the “@parameter-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructSimpleActionParameterType :: (IsSimpleAction o) => GLib.VariantType.VariantType -> IO (GValueConstruct o)
    constructSimpleActionParameterType val = constructObjectPropertyBoxed "parameter-type" (Just val)

    #if ENABLE_OVERLOADING
    data SimpleActionParameterTypePropertyInfo
    instance AttrInfo SimpleActionParameterTypePropertyInfo where
        type AttrAllowedOps SimpleActionParameterTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint SimpleActionParameterTypePropertyInfo = (~) GLib.VariantType.VariantType
        type AttrBaseTypeConstraint SimpleActionParameterTypePropertyInfo = IsSimpleAction
        type AttrGetType SimpleActionParameterTypePropertyInfo = (Maybe GLib.VariantType.VariantType)
        type AttrLabel SimpleActionParameterTypePropertyInfo = "parameter-type"
        type AttrOrigin SimpleActionParameterTypePropertyInfo = SimpleAction
        attrGet _ = getSimpleActionParameterType
        attrSet _ = undefined
        attrConstruct _ = constructSimpleActionParameterType
        attrClear _ = undefined
    #endif

    -- VVV Prop "state"
       -- Type: TVariant
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
       -- Nullable: (Nothing,Just False)

    {- |
    Get the value of the “@state@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' simpleAction #state
    @
    -}
    getSimpleActionState :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe GVariant)
    getSimpleActionState obj = liftIO $ getObjectPropertyVariant obj "state"

    {- |
    Set the value of the “@state@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' simpleAction [ #state 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setSimpleActionState :: (MonadIO m, IsSimpleAction o) => o -> GVariant -> m ()
    setSimpleActionState obj val = liftIO $ setObjectPropertyVariant obj "state" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@state@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructSimpleActionState :: (IsSimpleAction o) => GVariant -> IO (GValueConstruct o)
    constructSimpleActionState val = constructObjectPropertyVariant "state" (Just val)

    #if ENABLE_OVERLOADING
    data SimpleActionStatePropertyInfo
    instance AttrInfo SimpleActionStatePropertyInfo where
        type AttrAllowedOps SimpleActionStatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint SimpleActionStatePropertyInfo = (~) GVariant
        type AttrBaseTypeConstraint SimpleActionStatePropertyInfo = IsSimpleAction
        type AttrGetType SimpleActionStatePropertyInfo = (Maybe GVariant)
        type AttrLabel SimpleActionStatePropertyInfo = "state"
        type AttrOrigin SimpleActionStatePropertyInfo = SimpleAction
        attrGet _ = getSimpleActionState
        attrSet _ = setSimpleActionState
        attrConstruct _ = constructSimpleActionState
        attrClear _ = undefined
    #endif

    -- VVV Prop "state-type"
       -- Type: TInterface (Name {namespace = "GLib", name = "VariantType"})
       -- Flags: [PropertyReadable]
       -- Nullable: (Nothing,Nothing)

    {- |
    Get the value of the “@state-type@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' simpleAction #stateType
    @
    -}
    getSimpleActionStateType :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe GLib.VariantType.VariantType)
    getSimpleActionStateType obj = liftIO $ getObjectPropertyBoxed obj "state-type" GLib.VariantType.VariantType

    #if ENABLE_OVERLOADING
    data SimpleActionStateTypePropertyInfo
    instance AttrInfo SimpleActionStateTypePropertyInfo where
        type AttrAllowedOps SimpleActionStateTypePropertyInfo = '[ 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint SimpleActionStateTypePropertyInfo = (~) ()
        type AttrBaseTypeConstraint SimpleActionStateTypePropertyInfo = IsSimpleAction
        type AttrGetType SimpleActionStateTypePropertyInfo = (Maybe GLib.VariantType.VariantType)
        type AttrLabel SimpleActionStateTypePropertyInfo = "state-type"
        type AttrOrigin SimpleActionStateTypePropertyInfo = SimpleAction
        attrGet _ = getSimpleActionStateType
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList SimpleAction
    type instance O.AttributeList SimpleAction = SimpleActionAttributeList
    type SimpleActionAttributeList = ('[ '("enabled", SimpleActionEnabledPropertyInfo), '("name", SimpleActionNamePropertyInfo), '("parameterType", SimpleActionParameterTypePropertyInfo), '("state", SimpleActionStatePropertyInfo), '("stateType", SimpleActionStateTypePropertyInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    simpleActionEnabled :: AttrLabelProxy "enabled"
    simpleActionEnabled = AttrLabelProxy

    simpleActionName :: AttrLabelProxy "name"
    simpleActionName = AttrLabelProxy

    simpleActionParameterType :: AttrLabelProxy "parameterType"
    simpleActionParameterType = AttrLabelProxy

    simpleActionState :: AttrLabelProxy "state"
    simpleActionState = AttrLabelProxy

    simpleActionStateType :: AttrLabelProxy "stateType"
    simpleActionStateType = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    data SimpleActionActivateSignalInfo
    instance SignalInfo SimpleActionActivateSignalInfo where
        type HaskellCallbackType SimpleActionActivateSignalInfo = SimpleActionActivateCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_SimpleActionActivateCallback cb
            cb'' <- mk_SimpleActionActivateCallback cb'
            connectSignalFunPtr obj "activate" cb'' connectMode

    data SimpleActionChangeStateSignalInfo
    instance SignalInfo SimpleActionChangeStateSignalInfo where
        type HaskellCallbackType SimpleActionChangeStateSignalInfo = SimpleActionChangeStateCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_SimpleActionChangeStateCallback cb
            cb'' <- mk_SimpleActionChangeStateCallback cb'
            connectSignalFunPtr obj "change-state" cb'' connectMode

    type instance O.SignalList SimpleAction = SimpleActionSignalList
    type SimpleActionSignalList = ('[ '("activate", SimpleActionActivateSignalInfo), '("changeState", SimpleActionChangeStateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

    #endif

    -- method SimpleAction::new
    -- method type : Constructor
    -- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the action", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameter_type", argType = TInterface (Name {namespace = "GLib", name = "VariantType"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the type of parameter that will be passed to\n  handlers for the #GSimpleAction::activate signal, or %NULL for no parameter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "SimpleAction"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_simple_action_new" g_simple_action_new ::
        CString ->                              -- name : TBasicType TUTF8
        Ptr GLib.VariantType.VariantType ->     -- parameter_type : TInterface (Name {namespace = "GLib", name = "VariantType"})
        IO (Ptr SimpleAction)

    {- |
    Creates a new action.

    The created action is stateless. See 'GI.Gio.Objects.SimpleAction.simpleActionNewStateful' to create
    an action that has state.

    /Since: 2.28/
    -}
    simpleActionNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        {- ^ /@name@/: the name of the action -}
        -> Maybe (GLib.VariantType.VariantType)
        {- ^ /@parameterType@/: the type of parameter that will be passed to
      handlers for the 'GI.Gio.Objects.SimpleAction.SimpleAction'::@/activate/@ signal, or 'Nothing' for no parameter -}
        -> m SimpleAction
        {- ^ __Returns:__ a new 'GI.Gio.Objects.SimpleAction.SimpleAction' -}
    simpleActionNew name parameterType = liftIO $ do
        name' <- textToCString name
        maybeParameterType <- case parameterType of
            Nothing -> return nullPtr
            Just jParameterType -> do
                jParameterType' <- unsafeManagedPtrGetPtr jParameterType
                return jParameterType'
        result <- g_simple_action_new name' maybeParameterType
        checkUnexpectedReturnNULL "simpleActionNew" result
        result' <- (wrapObject SimpleAction) result
        whenJust parameterType touchManagedPtr
        freeMem name'
        return result'

    #if ENABLE_OVERLOADING
    #endif

    -- method SimpleAction::new_stateful
    -- method type : Constructor
    -- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the action", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameter_type", argType = TInterface (Name {namespace = "GLib", name = "VariantType"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the type of the parameter that will be passed to\n  handlers for the #GSimpleAction::activate signal, or %NULL for no parameter", 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 initial state of the action", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "SimpleAction"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_simple_action_new_stateful" g_simple_action_new_stateful ::
        CString ->                              -- name : TBasicType TUTF8
        Ptr GLib.VariantType.VariantType ->     -- parameter_type : TInterface (Name {namespace = "GLib", name = "VariantType"})
        Ptr GVariant ->                         -- state : TVariant
        IO (Ptr SimpleAction)

    {- |
    Creates a new stateful action.

    All future state values must have the same 'GI.GLib.Structs.VariantType.VariantType' as the initial
    /@state@/.

    If the /@state@/ 'GVariant' is floating, it is consumed.

    /Since: 2.28/
    -}
    simpleActionNewStateful ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        {- ^ /@name@/: the name of the action -}
        -> Maybe (GLib.VariantType.VariantType)
        {- ^ /@parameterType@/: the type of the parameter that will be passed to
      handlers for the 'GI.Gio.Objects.SimpleAction.SimpleAction'::@/activate/@ signal, or 'Nothing' for no parameter -}
        -> GVariant
        {- ^ /@state@/: the initial state of the action -}
        -> m SimpleAction
        {- ^ __Returns:__ a new 'GI.Gio.Objects.SimpleAction.SimpleAction' -}
    simpleActionNewStateful name parameterType state = liftIO $ do
        name' <- textToCString name
        maybeParameterType <- case parameterType of
            Nothing -> return nullPtr
            Just jParameterType -> do
                jParameterType' <- unsafeManagedPtrGetPtr jParameterType
                return jParameterType'
        state' <- unsafeManagedPtrGetPtr state
        result <- g_simple_action_new_stateful name' maybeParameterType state'
        checkUnexpectedReturnNULL "simpleActionNewStateful" result
        result' <- (wrapObject SimpleAction) result
        whenJust parameterType touchManagedPtr
        touchManagedPtr state
        freeMem name'
        return result'

    #if ENABLE_OVERLOADING
    #endif

    -- method SimpleAction::set_enabled
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "simple", argType = TInterface (Name {namespace = "Gio", name = "SimpleAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSimpleAction", 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 the action is 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_simple_action_set_enabled" g_simple_action_set_enabled ::
        Ptr SimpleAction ->                     -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAction"})
        CInt ->                                 -- enabled : TBasicType TBoolean
        IO ()

    {- |
    Sets the action as enabled or not.

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

    This should only be called by the implementor of the action.  Users
    of the action should not attempt to modify its enabled flag.

    /Since: 2.28/
    -}
    simpleActionSetEnabled ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAction a) =>
        a
        {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAction.SimpleAction' -}
        -> Bool
        {- ^ /@enabled@/: whether the action is enabled -}
        -> m ()
    simpleActionSetEnabled simple enabled = liftIO $ do
        simple' <- unsafeManagedPtrCastPtr simple
        let enabled' = (fromIntegral . fromEnum) enabled
        g_simple_action_set_enabled simple' enabled'
        touchManagedPtr simple
        return ()

    #if ENABLE_OVERLOADING
    data SimpleActionSetEnabledMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsSimpleAction a) => O.MethodInfo SimpleActionSetEnabledMethodInfo a signature where
        overloadedMethod _ = simpleActionSetEnabled

    #endif

    -- method SimpleAction::set_state
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "simple", argType = TInterface (Name {namespace = "Gio", name = "SimpleAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSimpleAction", 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 #GVariant for the 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_simple_action_set_state" g_simple_action_set_state ::
        Ptr SimpleAction ->                     -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAction"})
        Ptr GVariant ->                         -- value : TVariant
        IO ()

    {- |
    Sets the state of the action.

    This directly updates the \'state\' property to the given value.

    This should only be called by the implementor of the action.  Users
    of the action should not attempt to directly modify the \'state\'
    property.  Instead, they should call 'GI.Gio.Interfaces.Action.actionChangeState' to
    request the change.

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

    /Since: 2.30/
    -}
    simpleActionSetState ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAction a) =>
        a
        {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAction.SimpleAction' -}
        -> GVariant
        {- ^ /@value@/: the new 'GVariant' for the state -}
        -> m ()
    simpleActionSetState simple value = liftIO $ do
        simple' <- unsafeManagedPtrCastPtr simple
        value' <- unsafeManagedPtrGetPtr value
        g_simple_action_set_state simple' value'
        touchManagedPtr simple
        touchManagedPtr value
        return ()

    #if ENABLE_OVERLOADING
    data SimpleActionSetStateMethodInfo
    instance (signature ~ (GVariant -> m ()), MonadIO m, IsSimpleAction a) => O.MethodInfo SimpleActionSetStateMethodInfo a signature where
        overloadedMethod _ = simpleActionSetState

    #endif

    -- method SimpleAction::set_state_hint
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "simple", argType = TInterface (Name {namespace = "Gio", name = "SimpleAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSimpleAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state_hint", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GVariant representing the state hint", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_simple_action_set_state_hint" g_simple_action_set_state_hint ::
        Ptr SimpleAction ->                     -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAction"})
        Ptr GVariant ->                         -- state_hint : TVariant
        IO ()

    {- |
    Sets the state hint for the action.

    See 'GI.Gio.Interfaces.Action.actionGetStateHint' for more information about
    action state hints.

    /Since: 2.44/
    -}
    simpleActionSetStateHint ::
        (B.CallStack.HasCallStack, MonadIO m, IsSimpleAction a) =>
        a
        {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAction.SimpleAction' -}
        -> Maybe (GVariant)
        {- ^ /@stateHint@/: a 'GVariant' representing the state hint -}
        -> m ()
    simpleActionSetStateHint simple stateHint = liftIO $ do
        simple' <- unsafeManagedPtrCastPtr simple
        maybeStateHint <- case stateHint of
            Nothing -> return nullPtr
            Just jStateHint -> do
                jStateHint' <- unsafeManagedPtrGetPtr jStateHint
                return jStateHint'
        g_simple_action_set_state_hint simple' maybeStateHint
        touchManagedPtr simple
        whenJust stateHint touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data SimpleActionSetStateHintMethodInfo
    instance (signature ~ (Maybe (GVariant) -> m ()), MonadIO m, IsSimpleAction a) => O.MethodInfo SimpleActionSetStateHintMethodInfo a signature where
        overloadedMethod _ = simpleActionSetStateHint

    #endif