    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A t'GI.Gio.Objects.SimpleAction.SimpleAction' is the obvious simple implementation of the t'GI.Gio.Interfaces.Action.Action'
    -- interface. This is the easiest way to create an action for purposes of
    -- adding it to a t'GI.Gio.Objects.SimpleActionGroup.SimpleActionGroup'.
    --
    -- See also @/GtkAction/@.

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

    module GI.Gio.Objects.SimpleAction
        (

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

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

    #if defined(ENABLE_OVERLOADING)
        ResolveSimpleActionMethod               ,
    #endif

    -- ** new #method:new#

        simpleActionNew                         ,

    -- ** newStateful #method:newStateful#

        simpleActionNewStateful                 ,

    -- ** setEnabled #method:setEnabled#

    #if defined(ENABLE_OVERLOADING)
        SimpleActionSetEnabledMethodInfo        ,
    #endif
        simpleActionSetEnabled                  ,

    -- ** setState #method:setState#

    #if defined(ENABLE_OVERLOADING)
        SimpleActionSetStateMethodInfo          ,
    #endif
        simpleActionSetState                    ,

    -- ** setStateHint #method:setStateHint#

    #if defined(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 defined(ENABLE_OVERLOADING)
        SimpleActionEnabledPropertyInfo         ,
    #endif
        constructSimpleActionEnabled            ,
        getSimpleActionEnabled                  ,
        setSimpleActionEnabled                  ,
    #if defined(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 t'GI.Gio.Objects.SimpleActionGroup.SimpleActionGroup'.
    --
    -- /Since: 2.28/

    #if defined(ENABLE_OVERLOADING)
        SimpleActionNamePropertyInfo            ,
    #endif
        constructSimpleActionName               ,
        getSimpleActionName                     ,
    #if defined(ENABLE_OVERLOADING)
        simpleActionName                        ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        SimpleActionParameterTypePropertyInfo   ,
    #endif
        constructSimpleActionParameterType      ,
        getSimpleActionParameterType            ,
    #if defined(ENABLE_OVERLOADING)
        simpleActionParameterType               ,
    #endif

    -- ** state #attr:state#
    -- | The state of the action, or 'P.Nothing' if the action is stateless.
    --
    -- /Since: 2.28/

    #if defined(ENABLE_OVERLOADING)
        SimpleActionStatePropertyInfo           ,
    #endif
        constructSimpleActionState              ,
        getSimpleActionState                    ,
        setSimpleActionState                    ,
    #if defined(ENABLE_OVERLOADING)
        simpleActionState                       ,
    #endif

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

    #if defined(ENABLE_OVERLOADING)
        SimpleActionStateTypePropertyInfo       ,
    #endif
        getSimpleActionStateType                ,
    #if defined(ENABLE_OVERLOADING)
        simpleActionStateType                   ,
    #endif

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

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

    -- ** changeState #signal:changeState#

        C_SimpleActionChangeStateCallback       ,
        SimpleActionChangeStateCallback         ,
    #if defined(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.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL

    import qualified 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 (SP.ManagedPtr SimpleAction)
        deriving (SimpleAction -> SimpleAction -> Bool
    (SimpleAction -> SimpleAction -> Bool)
    -> (SimpleAction -> SimpleAction -> Bool) -> Eq SimpleAction
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: SimpleAction -> SimpleAction -> Bool
    $c/= :: SimpleAction -> SimpleAction -> Bool
    == :: SimpleAction -> SimpleAction -> Bool
    $c== :: SimpleAction -> SimpleAction -> Bool
    Eq)

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

    foreign import ccall "g_simple_action_get_type"
        c_g_simple_action_get_type :: IO B.Types.GType

    instance B.Types.TypedObject SimpleAction where
        glibType :: IO GType
    glibType = IO GType
    c_g_simple_action_get_type

    instance B.Types.GObject SimpleAction

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

        fromGValue :: GValue -> IO SimpleAction
    fromGValue gv :: GValue
    gv = do
            Ptr SimpleAction
    ptr <- GValue -> IO (Ptr SimpleAction)
    forall b. GObject b => GValue -> IO (Ptr b)
    B.GValue.get_object GValue
    gv :: IO (Ptr SimpleAction)
            (ManagedPtr SimpleAction -> SimpleAction)
    -> Ptr SimpleAction -> IO SimpleAction
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    B.ManagedPtr.newObject ManagedPtr SimpleAction -> SimpleAction
    SimpleAction Ptr SimpleAction
    ptr

    -- | Type class for types which can be safely cast to `SimpleAction`, for instance with `toSimpleAction`.
    class (SP.GObject o, O.IsDescendantOf SimpleAction o) => IsSimpleAction o
    instance (SP.GObject o, O.IsDescendantOf SimpleAction o) => IsSimpleAction o

    instance O.HasParentTypes SimpleAction
    type instance O.ParentTypes SimpleAction = '[GObject.Object.Object, Gio.Action.Action]

    -- | 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 :: o -> m SimpleAction
    toSimpleAction = IO SimpleAction -> m SimpleAction
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SimpleAction -> m SimpleAction)
    -> (o -> IO SimpleAction) -> o -> m SimpleAction
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (ManagedPtr SimpleAction -> SimpleAction) -> o -> IO SimpleAction
    forall o o'.
    (HasCallStack, ManagedPtrNewtype o, TypedObject o,
     ManagedPtrNewtype o', TypedObject o') =>
    (ManagedPtr o' -> o') -> o -> IO o'
    unsafeCastTo ManagedPtr SimpleAction -> SimpleAction
    SimpleAction

    #if defined(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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        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) => OL.IsLabel t (SimpleAction -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod @info
    #else
        fromLabel _ = O.overloadedMethod @info
    #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 'P.Nothing' parameter
    -- type is to toggle them via the [changeState]("GI.Gio.Objects.SimpleAction#g:signal:changeState") signal.
    -- For stateful actions where the state type is equal to the parameter
    -- type, the default is to forward them directly to
    -- [changeState]("GI.Gio.Objects.SimpleAction#g:signal:changeState").  This should allow almost all users
    -- of t'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 'P.Nothing' if it has
        --   no parameter
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `SimpleActionActivateCallback`@.
    noSimpleActionActivateCallback :: Maybe SimpleActionActivateCallback
    noSimpleActionActivateCallback :: Maybe SimpleActionActivateCallback
    noSimpleActionActivateCallback = Maybe SimpleActionActivateCallback
    forall a. Maybe a
    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 `GClosure`.
    genClosure_SimpleActionActivate :: MonadIO m => SimpleActionActivateCallback -> m (GClosure C_SimpleActionActivateCallback)
    genClosure_SimpleActionActivate :: SimpleActionActivateCallback
    -> m (GClosure C_SimpleActionActivateCallback)
    genClosure_SimpleActionActivate cb :: SimpleActionActivateCallback
    cb = IO (GClosure C_SimpleActionActivateCallback)
    -> m (GClosure C_SimpleActionActivateCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_SimpleActionActivateCallback)
     -> m (GClosure C_SimpleActionActivateCallback))
    -> IO (GClosure C_SimpleActionActivateCallback)
    -> m (GClosure C_SimpleActionActivateCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_SimpleActionActivateCallback
    cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
    wrap_SimpleActionActivateCallback SimpleActionActivateCallback
    cb
        C_SimpleActionActivateCallback
    -> IO (FunPtr C_SimpleActionActivateCallback)
    mk_SimpleActionActivateCallback C_SimpleActionActivateCallback
    cb' IO (FunPtr C_SimpleActionActivateCallback)
    -> (FunPtr C_SimpleActionActivateCallback
        -> IO (GClosure C_SimpleActionActivateCallback))
    -> IO (GClosure C_SimpleActionActivateCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_SimpleActionActivateCallback
    -> IO (GClosure C_SimpleActionActivateCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `SimpleActionActivateCallback` into a `C_SimpleActionActivateCallback`.
    wrap_SimpleActionActivateCallback ::
        SimpleActionActivateCallback ->
        C_SimpleActionActivateCallback
    wrap_SimpleActionActivateCallback :: SimpleActionActivateCallback -> C_SimpleActionActivateCallback
    wrap_SimpleActionActivateCallback _cb :: SimpleActionActivateCallback
    _cb _ parameter :: Ptr GVariant
    parameter _ = do
        Maybe GVariant
    maybeParameter <-
            if Ptr GVariant
    parameter Ptr GVariant -> Ptr GVariant -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr GVariant
    forall a. Ptr a
    nullPtr
            then Maybe GVariant -> IO (Maybe GVariant)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe GVariant
    forall a. Maybe a
    Nothing
            else do
                GVariant
    parameter' <- Ptr GVariant -> IO GVariant
    B.GVariant.newGVariantFromPtr Ptr GVariant
    parameter
                Maybe GVariant -> IO (Maybe GVariant)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe GVariant -> IO (Maybe GVariant))
    -> Maybe GVariant -> IO (Maybe GVariant)
    forall a b. (a -> b) -> a -> b
    $ GVariant -> Maybe GVariant
    forall a. a -> Maybe a
    Just GVariant
    parameter'
        SimpleActionActivateCallback
    _cb  Maybe GVariant
    maybeParameter

    -- | Connect a signal handler for the [activate](#signal: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 :: a -> SimpleActionActivateCallback -> m SignalHandlerId
    onSimpleActionActivate obj :: a
    obj cb :: SimpleActionActivateCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_SimpleActionActivateCallback
    cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
    wrap_SimpleActionActivateCallback SimpleActionActivateCallback
    cb
        FunPtr C_SimpleActionActivateCallback
    cb'' <- C_SimpleActionActivateCallback
    -> IO (FunPtr C_SimpleActionActivateCallback)
    mk_SimpleActionActivateCallback C_SimpleActionActivateCallback
    cb'
        a
    -> Text
    -> FunPtr C_SimpleActionActivateCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "activate" FunPtr C_SimpleActionActivateCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [activate](#signal: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 :: a -> SimpleActionActivateCallback -> m SignalHandlerId
    afterSimpleActionActivate obj :: a
    obj cb :: SimpleActionActivateCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_SimpleActionActivateCallback
    cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
    wrap_SimpleActionActivateCallback SimpleActionActivateCallback
    cb
        FunPtr C_SimpleActionActivateCallback
    cb'' <- C_SimpleActionActivateCallback
    -> IO (FunPtr C_SimpleActionActivateCallback)
    mk_SimpleActionActivateCallback C_SimpleActionActivateCallback
    cb'
        a
    -> Text
    -> FunPtr C_SimpleActionActivateCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "activate" FunPtr C_SimpleActionActivateCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

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

    #endif

    -- 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 :: Maybe SimpleActionActivateCallback
    noSimpleActionChangeStateCallback = Maybe SimpleActionActivateCallback
    forall a. Maybe a
    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 `GClosure`.
    genClosure_SimpleActionChangeState :: MonadIO m => SimpleActionChangeStateCallback -> m (GClosure C_SimpleActionChangeStateCallback)
    genClosure_SimpleActionChangeState :: SimpleActionActivateCallback
    -> m (GClosure C_SimpleActionActivateCallback)
    genClosure_SimpleActionChangeState cb :: SimpleActionActivateCallback
    cb = IO (GClosure C_SimpleActionActivateCallback)
    -> m (GClosure C_SimpleActionActivateCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_SimpleActionActivateCallback)
     -> m (GClosure C_SimpleActionActivateCallback))
    -> IO (GClosure C_SimpleActionActivateCallback)
    -> m (GClosure C_SimpleActionActivateCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_SimpleActionActivateCallback
    cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
    wrap_SimpleActionChangeStateCallback SimpleActionActivateCallback
    cb
        C_SimpleActionActivateCallback
    -> IO (FunPtr C_SimpleActionActivateCallback)
    mk_SimpleActionChangeStateCallback C_SimpleActionActivateCallback
    cb' IO (FunPtr C_SimpleActionActivateCallback)
    -> (FunPtr C_SimpleActionActivateCallback
        -> IO (GClosure C_SimpleActionActivateCallback))
    -> IO (GClosure C_SimpleActionActivateCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_SimpleActionActivateCallback
    -> IO (GClosure C_SimpleActionActivateCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `SimpleActionChangeStateCallback` into a `C_SimpleActionChangeStateCallback`.
    wrap_SimpleActionChangeStateCallback ::
        SimpleActionChangeStateCallback ->
        C_SimpleActionChangeStateCallback
    wrap_SimpleActionChangeStateCallback :: SimpleActionActivateCallback -> C_SimpleActionActivateCallback
    wrap_SimpleActionChangeStateCallback _cb :: SimpleActionActivateCallback
    _cb _ value :: Ptr GVariant
    value _ = do
        Maybe GVariant
    maybeValue <-
            if Ptr GVariant
    value Ptr GVariant -> Ptr GVariant -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr GVariant
    forall a. Ptr a
    nullPtr
            then Maybe GVariant -> IO (Maybe GVariant)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe GVariant
    forall a. Maybe a
    Nothing
            else do
                GVariant
    value' <- Ptr GVariant -> IO GVariant
    B.GVariant.newGVariantFromPtr Ptr GVariant
    value
                Maybe GVariant -> IO (Maybe GVariant)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe GVariant -> IO (Maybe GVariant))
    -> Maybe GVariant -> IO (Maybe GVariant)
    forall a b. (a -> b) -> a -> b
    $ GVariant -> Maybe GVariant
    forall a. a -> Maybe a
    Just GVariant
    value'
        SimpleActionActivateCallback
    _cb  Maybe GVariant
    maybeValue

    -- | Connect a signal handler for the [changeState](#signal:changeState) 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 :: a -> SimpleActionActivateCallback -> m SignalHandlerId
    onSimpleActionChangeState obj :: a
    obj cb :: SimpleActionActivateCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_SimpleActionActivateCallback
    cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
    wrap_SimpleActionChangeStateCallback SimpleActionActivateCallback
    cb
        FunPtr C_SimpleActionActivateCallback
    cb'' <- C_SimpleActionActivateCallback
    -> IO (FunPtr C_SimpleActionActivateCallback)
    mk_SimpleActionChangeStateCallback C_SimpleActionActivateCallback
    cb'
        a
    -> Text
    -> FunPtr C_SimpleActionActivateCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "change-state" FunPtr C_SimpleActionActivateCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [changeState](#signal:changeState) 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 :: a -> SimpleActionActivateCallback -> m SignalHandlerId
    afterSimpleActionChangeState obj :: a
    obj cb :: SimpleActionActivateCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_SimpleActionActivateCallback
    cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
    wrap_SimpleActionChangeStateCallback SimpleActionActivateCallback
    cb
        FunPtr C_SimpleActionActivateCallback
    cb'' <- C_SimpleActionActivateCallback
    -> IO (FunPtr C_SimpleActionActivateCallback)
    mk_SimpleActionChangeStateCallback C_SimpleActionActivateCallback
    cb'
        a
    -> Text
    -> FunPtr C_SimpleActionActivateCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "change-state" FunPtr C_SimpleActionActivateCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data SimpleActionChangeStateSignalInfo
    instance SignalInfo SimpleActionChangeStateSignalInfo where
        type HaskellCallbackType SimpleActionChangeStateSignalInfo = SimpleActionChangeStateCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_SimpleActionChangeStateCallback cb
            cb'' <- mk_SimpleActionChangeStateCallback cb'
            connectSignalFunPtr obj "change-state" cb'' connectMode detail

    #endif

    --- XXX Duplicated object with different types:
      --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "enabled", propType = TBasicType TBoolean, propFlags = [PropertyReadable,PropertyWritable], propReadNullable = Nothing, propWriteNullable = Just False, 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 = Just False, 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 = Just False, 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 = Just True, 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 = Just False, 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 = Just True, 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 :: o -> m Bool
    getSimpleActionEnabled obj :: o
    obj = IO Bool -> m Bool
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Bool
    forall a. GObject a => a -> String -> IO Bool
    B.Properties.getObjectPropertyBool o
    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 :: o -> Bool -> m ()
    setSimpleActionEnabled obj :: o
    obj val :: Bool
    val = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> Bool -> IO ()
    forall a. GObject a => a -> String -> Bool -> IO ()
    B.Properties.setObjectPropertyBool o
    obj "enabled" Bool
    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, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
    constructSimpleActionEnabled :: Bool -> m (GValueConstruct o)
    constructSimpleActionEnabled val :: Bool
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Bool -> IO (GValueConstruct o)
    forall o. String -> Bool -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBool "enabled" Bool
    val

    #if defined(ENABLE_OVERLOADING)
    data SimpleActionEnabledPropertyInfo
    instance AttrInfo SimpleActionEnabledPropertyInfo where
        type AttrAllowedOps SimpleActionEnabledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrBaseTypeConstraint SimpleActionEnabledPropertyInfo = IsSimpleAction
        type AttrSetTypeConstraint SimpleActionEnabledPropertyInfo = (~) Bool
        type AttrTransferTypeConstraint SimpleActionEnabledPropertyInfo = (~) Bool
        type AttrTransferType SimpleActionEnabledPropertyInfo = Bool
        type AttrGetType SimpleActionEnabledPropertyInfo = Bool
        type AttrLabel SimpleActionEnabledPropertyInfo = "enabled"
        type AttrOrigin SimpleActionEnabledPropertyInfo = SimpleAction
        attrGet = getSimpleActionEnabled
        attrSet = setSimpleActionEnabled
        attrTransfer _ v = do
            return v
        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 :: o -> m (Maybe Text)
    getSimpleActionName obj :: o
    obj = IO (Maybe Text) -> m (Maybe Text)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO (Maybe Text)
    forall a. GObject a => a -> String -> IO (Maybe Text)
    B.Properties.getObjectPropertyString o
    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, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
    constructSimpleActionName :: Text -> m (GValueConstruct o)
    constructSimpleActionName val :: Text
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe Text -> IO (GValueConstruct o)
    forall o. String -> Maybe Text -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyString "name" (Text -> Maybe Text
    forall a. a -> Maybe a
    P.Just Text
    val)

    #if defined(ENABLE_OVERLOADING)
    data SimpleActionNamePropertyInfo
    instance AttrInfo SimpleActionNamePropertyInfo where
        type AttrAllowedOps SimpleActionNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint SimpleActionNamePropertyInfo = IsSimpleAction
        type AttrSetTypeConstraint SimpleActionNamePropertyInfo = (~) T.Text
        type AttrTransferTypeConstraint SimpleActionNamePropertyInfo = (~) T.Text
        type AttrTransferType SimpleActionNamePropertyInfo = T.Text
        type AttrGetType SimpleActionNamePropertyInfo = (Maybe T.Text)
        type AttrLabel SimpleActionNamePropertyInfo = "name"
        type AttrOrigin SimpleActionNamePropertyInfo = SimpleAction
        attrGet = getSimpleActionName
        attrSet = undefined
        attrTransfer _ v = do
            return v
        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 :: o -> m (Maybe VariantType)
    getSimpleActionParameterType obj :: o
    obj = IO (Maybe VariantType) -> m (Maybe VariantType)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe VariantType) -> m (Maybe VariantType))
    -> IO (Maybe VariantType) -> m (Maybe VariantType)
    forall a b. (a -> b) -> a -> b
    $ o
    -> String
    -> (ManagedPtr VariantType -> VariantType)
    -> IO (Maybe VariantType)
    forall a b.
    (GObject a, GBoxed b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyBoxed o
    obj "parameter-type" ManagedPtr VariantType -> VariantType
    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, MIO.MonadIO m) => GLib.VariantType.VariantType -> m (GValueConstruct o)
    constructSimpleActionParameterType :: VariantType -> m (GValueConstruct o)
    constructSimpleActionParameterType val :: VariantType
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe VariantType -> IO (GValueConstruct o)
    forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBoxed "parameter-type" (VariantType -> Maybe VariantType
    forall a. a -> Maybe a
    P.Just VariantType
    val)

    #if defined(ENABLE_OVERLOADING)
    data SimpleActionParameterTypePropertyInfo
    instance AttrInfo SimpleActionParameterTypePropertyInfo where
        type AttrAllowedOps SimpleActionParameterTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint SimpleActionParameterTypePropertyInfo = IsSimpleAction
        type AttrSetTypeConstraint SimpleActionParameterTypePropertyInfo = (~) GLib.VariantType.VariantType
        type AttrTransferTypeConstraint SimpleActionParameterTypePropertyInfo = (~) GLib.VariantType.VariantType
        type AttrTransferType SimpleActionParameterTypePropertyInfo = GLib.VariantType.VariantType
        type AttrGetType SimpleActionParameterTypePropertyInfo = (Maybe GLib.VariantType.VariantType)
        type AttrLabel SimpleActionParameterTypePropertyInfo = "parameter-type"
        type AttrOrigin SimpleActionParameterTypePropertyInfo = SimpleAction
        attrGet = getSimpleActionParameterType
        attrSet = undefined
        attrTransfer _ v = do
            return v
        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 :: o -> m (Maybe GVariant)
    getSimpleActionState obj :: o
    obj = IO (Maybe GVariant) -> m (Maybe GVariant)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe GVariant) -> m (Maybe GVariant))
    -> IO (Maybe GVariant) -> m (Maybe GVariant)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO (Maybe GVariant)
    forall a. GObject a => a -> String -> IO (Maybe GVariant)
    B.Properties.getObjectPropertyVariant o
    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 :: o -> GVariant -> m ()
    setSimpleActionState obj :: o
    obj val :: GVariant
    val = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ o -> String -> SimpleActionActivateCallback
    forall a. GObject a => a -> String -> SimpleActionActivateCallback
    B.Properties.setObjectPropertyVariant o
    obj "state" (GVariant -> Maybe GVariant
    forall a. a -> Maybe a
    Just GVariant
    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, MIO.MonadIO m) => GVariant -> m (GValueConstruct o)
    constructSimpleActionState :: GVariant -> m (GValueConstruct o)
    constructSimpleActionState val :: GVariant
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe GVariant -> IO (GValueConstruct o)
    forall o. String -> Maybe GVariant -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyVariant "state" (GVariant -> Maybe GVariant
    forall a. a -> Maybe a
    P.Just GVariant
    val)

    #if defined(ENABLE_OVERLOADING)
    data SimpleActionStatePropertyInfo
    instance AttrInfo SimpleActionStatePropertyInfo where
        type AttrAllowedOps SimpleActionStatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrBaseTypeConstraint SimpleActionStatePropertyInfo = IsSimpleAction
        type AttrSetTypeConstraint SimpleActionStatePropertyInfo = (~) GVariant
        type AttrTransferTypeConstraint SimpleActionStatePropertyInfo = (~) GVariant
        type AttrTransferType SimpleActionStatePropertyInfo = GVariant
        type AttrGetType SimpleActionStatePropertyInfo = (Maybe GVariant)
        type AttrLabel SimpleActionStatePropertyInfo = "state"
        type AttrOrigin SimpleActionStatePropertyInfo = SimpleAction
        attrGet = getSimpleActionState
        attrSet = setSimpleActionState
        attrTransfer _ v = do
            return v
        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 :: o -> m (Maybe VariantType)
    getSimpleActionStateType obj :: o
    obj = IO (Maybe VariantType) -> m (Maybe VariantType)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe VariantType) -> m (Maybe VariantType))
    -> IO (Maybe VariantType) -> m (Maybe VariantType)
    forall a b. (a -> b) -> a -> b
    $ o
    -> String
    -> (ManagedPtr VariantType -> VariantType)
    -> IO (Maybe VariantType)
    forall a b.
    (GObject a, GBoxed b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyBoxed o
    obj "state-type" ManagedPtr VariantType -> VariantType
    GLib.VariantType.VariantType

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

    #if defined(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 defined(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 defined(ENABLE_OVERLOADING)
    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 [activate]("GI.Gio.Objects.SimpleAction#g:signal:activate") signal, or 'P.Nothing' for no parameter
        -> m SimpleAction
        -- ^ __Returns:__ a new t'GI.Gio.Objects.SimpleAction.SimpleAction'
    simpleActionNew :: Text -> Maybe VariantType -> m SimpleAction
    simpleActionNew name :: Text
    name parameterType :: Maybe VariantType
    parameterType = IO SimpleAction -> m SimpleAction
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SimpleAction -> m SimpleAction)
    -> IO SimpleAction -> m SimpleAction
    forall a b. (a -> b) -> a -> b
    $ do
        CString
    name' <- Text -> IO CString
    textToCString Text
    name
        Ptr VariantType
    maybeParameterType <- case Maybe VariantType
    parameterType of
            Nothing -> Ptr VariantType -> IO (Ptr VariantType)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr VariantType
    forall a. Ptr a
    nullPtr
            Just jParameterType :: VariantType
    jParameterType -> do
                Ptr VariantType
    jParameterType' <- VariantType -> IO (Ptr VariantType)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr VariantType
    jParameterType
                Ptr VariantType -> IO (Ptr VariantType)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr VariantType
    jParameterType'
        Ptr SimpleAction
    result <- CString -> Ptr VariantType -> IO (Ptr SimpleAction)
    g_simple_action_new CString
    name' Ptr VariantType
    maybeParameterType
        Text -> Ptr SimpleAction -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "simpleActionNew" Ptr SimpleAction
    result
        SimpleAction
    result' <- ((ManagedPtr SimpleAction -> SimpleAction)
    -> Ptr SimpleAction -> IO SimpleAction
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr SimpleAction -> SimpleAction
    SimpleAction) Ptr SimpleAction
    result
        Maybe VariantType -> (VariantType -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe VariantType
    parameterType VariantType -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    name'
        SimpleAction -> IO SimpleAction
    forall (m :: * -> *) a. Monad m => a -> m a
    return SimpleAction
    result'

    #if defined(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 t'GI.GLib.Structs.VariantType.VariantType' as the initial
    -- /@state@/.
    --
    -- If the /@state@/ t'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 [activate]("GI.Gio.Objects.SimpleAction#g:signal:activate") signal, or 'P.Nothing' for no parameter
        -> GVariant
        -- ^ /@state@/: the initial state of the action
        -> m SimpleAction
        -- ^ __Returns:__ a new t'GI.Gio.Objects.SimpleAction.SimpleAction'
    simpleActionNewStateful :: Text -> Maybe VariantType -> GVariant -> m SimpleAction
    simpleActionNewStateful name :: Text
    name parameterType :: Maybe VariantType
    parameterType state :: GVariant
    state = IO SimpleAction -> m SimpleAction
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SimpleAction -> m SimpleAction)
    -> IO SimpleAction -> m SimpleAction
    forall a b. (a -> b) -> a -> b
    $ do
        CString
    name' <- Text -> IO CString
    textToCString Text
    name
        Ptr VariantType
    maybeParameterType <- case Maybe VariantType
    parameterType of
            Nothing -> Ptr VariantType -> IO (Ptr VariantType)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr VariantType
    forall a. Ptr a
    nullPtr
            Just jParameterType :: VariantType
    jParameterType -> do
                Ptr VariantType
    jParameterType' <- VariantType -> IO (Ptr VariantType)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr VariantType
    jParameterType
                Ptr VariantType -> IO (Ptr VariantType)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr VariantType
    jParameterType'
        Ptr GVariant
    state' <- GVariant -> IO (Ptr GVariant)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr GVariant
    state
        Ptr SimpleAction
    result <- CString -> Ptr VariantType -> Ptr GVariant -> IO (Ptr SimpleAction)
    g_simple_action_new_stateful CString
    name' Ptr VariantType
    maybeParameterType Ptr GVariant
    state'
        Text -> Ptr SimpleAction -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "simpleActionNewStateful" Ptr SimpleAction
    result
        SimpleAction
    result' <- ((ManagedPtr SimpleAction -> SimpleAction)
    -> Ptr SimpleAction -> IO SimpleAction
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr SimpleAction -> SimpleAction
    SimpleAction) Ptr SimpleAction
    result
        Maybe VariantType -> (VariantType -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe VariantType
    parameterType VariantType -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        GVariant -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr GVariant
    state
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    name'
        SimpleAction -> IO SimpleAction
    forall (m :: * -> *) a. Monad m => a -> m a
    return SimpleAction
    result'

    #if defined(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 t'GI.Gio.Objects.SimpleAction.SimpleAction'
        -> Bool
        -- ^ /@enabled@/: whether the action is enabled
        -> m ()
    simpleActionSetEnabled :: a -> Bool -> m ()
    simpleActionSetEnabled simple :: a
    simple enabled :: Bool
    enabled = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr SimpleAction
    simple' <- a -> IO (Ptr SimpleAction)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    simple
        let enabled' :: CInt
    enabled' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    fromEnum) Bool
    enabled
        Ptr SimpleAction -> CInt -> IO ()
    g_simple_action_set_enabled Ptr SimpleAction
    simple' CInt
    enabled'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    simple
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(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 t'GI.Gio.Objects.SimpleAction.SimpleAction'
        -> GVariant
        -- ^ /@value@/: the new t'GVariant' for the state
        -> m ()
    simpleActionSetState :: a -> GVariant -> m ()
    simpleActionSetState simple :: a
    simple value :: GVariant
    value = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr SimpleAction
    simple' <- a -> IO (Ptr SimpleAction)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    simple
        Ptr GVariant
    value' <- GVariant -> IO (Ptr GVariant)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr GVariant
    value
        Ptr SimpleAction -> Ptr GVariant -> IO ()
    g_simple_action_set_state Ptr SimpleAction
    simple' Ptr GVariant
    value'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    simple
        GVariant -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr GVariant
    value
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(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 t'GI.Gio.Objects.SimpleAction.SimpleAction'
        -> Maybe (GVariant)
        -- ^ /@stateHint@/: a t'GVariant' representing the state hint
        -> m ()
    simpleActionSetStateHint :: a -> Maybe GVariant -> m ()
    simpleActionSetStateHint simple :: a
    simple stateHint :: Maybe GVariant
    stateHint = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr SimpleAction
    simple' <- a -> IO (Ptr SimpleAction)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    simple
        Ptr GVariant
    maybeStateHint <- case Maybe GVariant
    stateHint of
            Nothing -> Ptr GVariant -> IO (Ptr GVariant)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr GVariant
    forall a. Ptr a
    nullPtr
            Just jStateHint :: GVariant
    jStateHint -> do
                Ptr GVariant
    jStateHint' <- GVariant -> IO (Ptr GVariant)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr GVariant
    jStateHint
                Ptr GVariant -> IO (Ptr GVariant)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr GVariant
    jStateHint'
        Ptr SimpleAction -> Ptr GVariant -> IO ()
    g_simple_action_set_state_hint Ptr SimpleAction
    simple' Ptr GVariant
    maybeStateHint
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    simple
        Maybe GVariant -> (GVariant -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe GVariant
    stateHint GVariant -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

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

    #endif