{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.NM.Objects.VpnPluginOld
    ( 

-- * Exported types
    VpnPluginOld(..)                        ,
    IsVpnPluginOld                          ,
    toVpnPluginOld                          ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [disconnect]("GI.NM.Objects.VpnPluginOld#g:method:disconnect"), [failure]("GI.NM.Objects.VpnPluginOld#g:method:failure"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [init]("GI.Gio.Interfaces.Initable#g:method:init"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [secretsRequired]("GI.NM.Objects.VpnPluginOld#g:method:secretsRequired"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getConnection]("GI.NM.Objects.VpnPluginOld#g:method:getConnection"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getState]("GI.NM.Objects.VpnPluginOld#g:method:getState").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setIp4Config]("GI.NM.Objects.VpnPluginOld#g:method:setIp4Config"), [setLoginBanner]("GI.NM.Objects.VpnPluginOld#g:method:setLoginBanner"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setState]("GI.NM.Objects.VpnPluginOld#g:method:setState").

#if defined(ENABLE_OVERLOADING)
    ResolveVpnPluginOldMethod               ,
#endif

-- ** disconnect #method:disconnect#

#if defined(ENABLE_OVERLOADING)
    VpnPluginOldDisconnectMethodInfo        ,
#endif
    vpnPluginOldDisconnect                  ,


-- ** failure #method:failure#

#if defined(ENABLE_OVERLOADING)
    VpnPluginOldFailureMethodInfo           ,
#endif
    vpnPluginOldFailure                     ,


-- ** getConnection #method:getConnection#

#if defined(ENABLE_OVERLOADING)
    VpnPluginOldGetConnectionMethodInfo     ,
#endif
    vpnPluginOldGetConnection               ,


-- ** getSecretFlags #method:getSecretFlags#

    vpnPluginOldGetSecretFlags              ,


-- ** getState #method:getState#

#if defined(ENABLE_OVERLOADING)
    VpnPluginOldGetStateMethodInfo          ,
#endif
    vpnPluginOldGetState                    ,


-- ** readVpnDetails #method:readVpnDetails#

    vpnPluginOldReadVpnDetails              ,


-- ** secretsRequired #method:secretsRequired#

#if defined(ENABLE_OVERLOADING)
    VpnPluginOldSecretsRequiredMethodInfo   ,
#endif
    vpnPluginOldSecretsRequired             ,


-- ** setIp4Config #method:setIp4Config#

#if defined(ENABLE_OVERLOADING)
    VpnPluginOldSetIp4ConfigMethodInfo      ,
#endif
    vpnPluginOldSetIp4Config                ,


-- ** setLoginBanner #method:setLoginBanner#

#if defined(ENABLE_OVERLOADING)
    VpnPluginOldSetLoginBannerMethodInfo    ,
#endif
    vpnPluginOldSetLoginBanner              ,


-- ** setState #method:setState#

#if defined(ENABLE_OVERLOADING)
    VpnPluginOldSetStateMethodInfo          ,
#endif
    vpnPluginOldSetState                    ,




 -- * Properties


-- ** serviceName #attr:serviceName#
-- | The D-Bus service name of this plugin.

#if defined(ENABLE_OVERLOADING)
    VpnPluginOldServiceNamePropertyInfo     ,
#endif
    constructVpnPluginOldServiceName        ,
    getVpnPluginOldServiceName              ,
#if defined(ENABLE_OVERLOADING)
    vpnPluginOldServiceName                 ,
#endif


-- ** state #attr:state#
-- | The state of the plugin.

#if defined(ENABLE_OVERLOADING)
    VpnPluginOldStatePropertyInfo           ,
#endif
    constructVpnPluginOldState              ,
    getVpnPluginOldState                    ,
    setVpnPluginOldState                    ,
#if defined(ENABLE_OVERLOADING)
    vpnPluginOldState                       ,
#endif




 -- * Signals


-- ** config #signal:config#

    VpnPluginOldConfigCallback              ,
#if defined(ENABLE_OVERLOADING)
    VpnPluginOldConfigSignalInfo            ,
#endif
    afterVpnPluginOldConfig                 ,
    onVpnPluginOldConfig                    ,


-- ** failure #signal:failure#

    VpnPluginOldFailureCallback             ,
#if defined(ENABLE_OVERLOADING)
    VpnPluginOldFailureSignalInfo           ,
#endif
    afterVpnPluginOldFailure                ,
    onVpnPluginOldFailure                   ,


-- ** ip4Config #signal:ip4Config#

    VpnPluginOldIp4ConfigCallback           ,
#if defined(ENABLE_OVERLOADING)
    VpnPluginOldIp4ConfigSignalInfo         ,
#endif
    afterVpnPluginOldIp4Config              ,
    onVpnPluginOldIp4Config                 ,


-- ** ip6Config #signal:ip6Config#

    VpnPluginOldIp6ConfigCallback           ,
#if defined(ENABLE_OVERLOADING)
    VpnPluginOldIp6ConfigSignalInfo         ,
#endif
    afterVpnPluginOldIp6Config              ,
    onVpnPluginOldIp6Config                 ,


-- ** loginBanner #signal:loginBanner#

    VpnPluginOldLoginBannerCallback         ,
#if defined(ENABLE_OVERLOADING)
    VpnPluginOldLoginBannerSignalInfo       ,
#endif
    afterVpnPluginOldLoginBanner            ,
    onVpnPluginOldLoginBanner               ,


-- ** quit #signal:quit#

    VpnPluginOldQuitCallback                ,
#if defined(ENABLE_OVERLOADING)
    VpnPluginOldQuitSignalInfo              ,
#endif
    afterVpnPluginOldQuit                   ,
    onVpnPluginOldQuit                      ,


-- ** secretsRequired #signal:secretsRequired#

    VpnPluginOldSecretsRequiredCallback     ,
#if defined(ENABLE_OVERLOADING)
    VpnPluginOldSecretsRequiredSignalInfo   ,
#endif
    afterVpnPluginOldSecretsRequired        ,
    onVpnPluginOldSecretsRequired           ,


-- ** stateChanged #signal:stateChanged#

    VpnPluginOldStateChangedCallback        ,
#if defined(ENABLE_OVERLOADING)
    VpnPluginOldStateChangedSignalInfo      ,
#endif
    afterVpnPluginOldStateChanged           ,
    onVpnPluginOldStateChanged              ,




    ) 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.GHashTable as B.GHT
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.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.Initable as Gio.Initable
import qualified GI.Gio.Objects.DBusConnection as Gio.DBusConnection
import {-# SOURCE #-} qualified GI.NM.Enums as NM.Enums
import {-# SOURCE #-} qualified GI.NM.Flags as NM.Flags

#else
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.Initable as Gio.Initable
import qualified GI.Gio.Objects.DBusConnection as Gio.DBusConnection
import {-# SOURCE #-} qualified GI.NM.Enums as NM.Enums
import {-# SOURCE #-} qualified GI.NM.Flags as NM.Flags

#endif

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

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

foreign import ccall "nm_vpn_plugin_old_get_type"
    c_nm_vpn_plugin_old_get_type :: IO B.Types.GType

instance B.Types.TypedObject VpnPluginOld where
    glibType :: IO GType
glibType = IO GType
c_nm_vpn_plugin_old_get_type

instance B.Types.GObject VpnPluginOld

-- | Type class for types which can be safely cast to t'VpnPluginOld', for instance with `toVpnPluginOld`.
class (SP.GObject o, O.IsDescendantOf VpnPluginOld o) => IsVpnPluginOld o
instance (SP.GObject o, O.IsDescendantOf VpnPluginOld o) => IsVpnPluginOld o

instance O.HasParentTypes VpnPluginOld
type instance O.ParentTypes VpnPluginOld = '[GObject.Object.Object, Gio.Initable.Initable]

-- | Cast to t'VpnPluginOld', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'.
toVpnPluginOld :: (MIO.MonadIO m, IsVpnPluginOld o) => o -> m VpnPluginOld
toVpnPluginOld :: forall (m :: * -> *) o.
(MonadIO m, IsVpnPluginOld o) =>
o -> m VpnPluginOld
toVpnPluginOld = IO VpnPluginOld -> m VpnPluginOld
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO VpnPluginOld -> m VpnPluginOld)
-> (o -> IO VpnPluginOld) -> o -> m VpnPluginOld
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr VpnPluginOld -> VpnPluginOld) -> o -> IO VpnPluginOld
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr VpnPluginOld -> VpnPluginOld
VpnPluginOld

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

#if defined(ENABLE_OVERLOADING)
type family ResolveVpnPluginOldMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveVpnPluginOldMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveVpnPluginOldMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveVpnPluginOldMethod "disconnect" o = VpnPluginOldDisconnectMethodInfo
    ResolveVpnPluginOldMethod "failure" o = VpnPluginOldFailureMethodInfo
    ResolveVpnPluginOldMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveVpnPluginOldMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveVpnPluginOldMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveVpnPluginOldMethod "init" o = Gio.Initable.InitableInitMethodInfo
    ResolveVpnPluginOldMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveVpnPluginOldMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveVpnPluginOldMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveVpnPluginOldMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveVpnPluginOldMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveVpnPluginOldMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveVpnPluginOldMethod "secretsRequired" o = VpnPluginOldSecretsRequiredMethodInfo
    ResolveVpnPluginOldMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveVpnPluginOldMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveVpnPluginOldMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveVpnPluginOldMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveVpnPluginOldMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveVpnPluginOldMethod "getConnection" o = VpnPluginOldGetConnectionMethodInfo
    ResolveVpnPluginOldMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveVpnPluginOldMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveVpnPluginOldMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveVpnPluginOldMethod "getState" o = VpnPluginOldGetStateMethodInfo
    ResolveVpnPluginOldMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveVpnPluginOldMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveVpnPluginOldMethod "setIp4Config" o = VpnPluginOldSetIp4ConfigMethodInfo
    ResolveVpnPluginOldMethod "setLoginBanner" o = VpnPluginOldSetLoginBannerMethodInfo
    ResolveVpnPluginOldMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveVpnPluginOldMethod "setState" o = VpnPluginOldSetStateMethodInfo
    ResolveVpnPluginOldMethod l o = O.MethodResolutionFailed l o

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

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

#endif

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

#endif

-- signal VpnPluginOld::config
-- | /No description available in the introspection data./
type VpnPluginOldConfigCallback =
    GVariant
    -> IO ()

type C_VpnPluginOldConfigCallback =
    Ptr VpnPluginOld ->                     -- object
    Ptr GVariant ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_VpnPluginOldConfigCallback :: 
    GObject a => (a -> VpnPluginOldConfigCallback) ->
    C_VpnPluginOldConfigCallback
wrap_VpnPluginOldConfigCallback :: forall a.
GObject a =>
(a -> VpnPluginOldConfigCallback) -> C_VpnPluginOldConfigCallback
wrap_VpnPluginOldConfigCallback a -> VpnPluginOldConfigCallback
gi'cb Ptr VpnPluginOld
gi'selfPtr Ptr GVariant
object Ptr ()
_ = do
    GVariant
object' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
object
    Ptr VpnPluginOld -> (VpnPluginOld -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr VpnPluginOld
gi'selfPtr ((VpnPluginOld -> IO ()) -> IO ())
-> (VpnPluginOld -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \VpnPluginOld
gi'self -> a -> VpnPluginOldConfigCallback
gi'cb (VpnPluginOld -> a
forall a b. Coercible a b => a -> b
Coerce.coerce VpnPluginOld
gi'self)  GVariant
object'


-- | Connect a signal handler for the [config](#signal:config) 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' vpnPluginOld #config callback
-- @
-- 
-- 
onVpnPluginOldConfig :: (IsVpnPluginOld a, MonadIO m) => a -> ((?self :: a) => VpnPluginOldConfigCallback) -> m SignalHandlerId
onVpnPluginOldConfig :: forall a (m :: * -> *).
(IsVpnPluginOld a, MonadIO m) =>
a
-> ((?self::a) => VpnPluginOldConfigCallback) -> m SignalHandlerId
onVpnPluginOldConfig a
obj (?self::a) => VpnPluginOldConfigCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> VpnPluginOldConfigCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => VpnPluginOldConfigCallback
VpnPluginOldConfigCallback
cb
    let wrapped' :: C_VpnPluginOldConfigCallback
wrapped' = (a -> VpnPluginOldConfigCallback) -> C_VpnPluginOldConfigCallback
forall a.
GObject a =>
(a -> VpnPluginOldConfigCallback) -> C_VpnPluginOldConfigCallback
wrap_VpnPluginOldConfigCallback a -> VpnPluginOldConfigCallback
wrapped
    FunPtr C_VpnPluginOldConfigCallback
wrapped'' <- C_VpnPluginOldConfigCallback
-> IO (FunPtr C_VpnPluginOldConfigCallback)
mk_VpnPluginOldConfigCallback C_VpnPluginOldConfigCallback
wrapped'
    a
-> Text
-> FunPtr C_VpnPluginOldConfigCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"config" FunPtr C_VpnPluginOldConfigCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [config](#signal:config) 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' vpnPluginOld #config callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterVpnPluginOldConfig :: (IsVpnPluginOld a, MonadIO m) => a -> ((?self :: a) => VpnPluginOldConfigCallback) -> m SignalHandlerId
afterVpnPluginOldConfig :: forall a (m :: * -> *).
(IsVpnPluginOld a, MonadIO m) =>
a
-> ((?self::a) => VpnPluginOldConfigCallback) -> m SignalHandlerId
afterVpnPluginOldConfig a
obj (?self::a) => VpnPluginOldConfigCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> VpnPluginOldConfigCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => VpnPluginOldConfigCallback
VpnPluginOldConfigCallback
cb
    let wrapped' :: C_VpnPluginOldConfigCallback
wrapped' = (a -> VpnPluginOldConfigCallback) -> C_VpnPluginOldConfigCallback
forall a.
GObject a =>
(a -> VpnPluginOldConfigCallback) -> C_VpnPluginOldConfigCallback
wrap_VpnPluginOldConfigCallback a -> VpnPluginOldConfigCallback
wrapped
    FunPtr C_VpnPluginOldConfigCallback
wrapped'' <- C_VpnPluginOldConfigCallback
-> IO (FunPtr C_VpnPluginOldConfigCallback)
mk_VpnPluginOldConfigCallback C_VpnPluginOldConfigCallback
wrapped'
    a
-> Text
-> FunPtr C_VpnPluginOldConfigCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"config" FunPtr C_VpnPluginOldConfigCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VpnPluginOldConfigSignalInfo
instance SignalInfo VpnPluginOldConfigSignalInfo where
    type HaskellCallbackType VpnPluginOldConfigSignalInfo = VpnPluginOldConfigCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VpnPluginOldConfigCallback cb
        cb'' <- mk_VpnPluginOldConfigCallback cb'
        connectSignalFunPtr obj "config" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld::config"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#g:signal:config"})

#endif

-- signal VpnPluginOld::failure
-- | /No description available in the introspection data./
type VpnPluginOldFailureCallback =
    Word32
    -> IO ()

type C_VpnPluginOldFailureCallback =
    Ptr VpnPluginOld ->                     -- object
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_VpnPluginOldFailureCallback :: 
    GObject a => (a -> VpnPluginOldFailureCallback) ->
    C_VpnPluginOldFailureCallback
wrap_VpnPluginOldFailureCallback :: forall a.
GObject a =>
(a -> VpnPluginOldFailureCallback) -> C_VpnPluginOldFailureCallback
wrap_VpnPluginOldFailureCallback a -> VpnPluginOldFailureCallback
gi'cb Ptr VpnPluginOld
gi'selfPtr Word32
object Ptr ()
_ = do
    Ptr VpnPluginOld -> (VpnPluginOld -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr VpnPluginOld
gi'selfPtr ((VpnPluginOld -> IO ()) -> IO ())
-> (VpnPluginOld -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \VpnPluginOld
gi'self -> a -> VpnPluginOldFailureCallback
gi'cb (VpnPluginOld -> a
forall a b. Coercible a b => a -> b
Coerce.coerce VpnPluginOld
gi'self)  Word32
object


-- | Connect a signal handler for the [failure](#signal:failure) 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' vpnPluginOld #failure callback
-- @
-- 
-- 
onVpnPluginOldFailure :: (IsVpnPluginOld a, MonadIO m) => a -> ((?self :: a) => VpnPluginOldFailureCallback) -> m SignalHandlerId
onVpnPluginOldFailure :: forall a (m :: * -> *).
(IsVpnPluginOld a, MonadIO m) =>
a
-> ((?self::a) => VpnPluginOldFailureCallback) -> m SignalHandlerId
onVpnPluginOldFailure a
obj (?self::a) => VpnPluginOldFailureCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> VpnPluginOldFailureCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => VpnPluginOldFailureCallback
VpnPluginOldFailureCallback
cb
    let wrapped' :: C_VpnPluginOldFailureCallback
wrapped' = (a -> VpnPluginOldFailureCallback) -> C_VpnPluginOldFailureCallback
forall a.
GObject a =>
(a -> VpnPluginOldFailureCallback) -> C_VpnPluginOldFailureCallback
wrap_VpnPluginOldFailureCallback a -> VpnPluginOldFailureCallback
wrapped
    FunPtr C_VpnPluginOldFailureCallback
wrapped'' <- C_VpnPluginOldFailureCallback
-> IO (FunPtr C_VpnPluginOldFailureCallback)
mk_VpnPluginOldFailureCallback C_VpnPluginOldFailureCallback
wrapped'
    a
-> Text
-> FunPtr C_VpnPluginOldFailureCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"failure" FunPtr C_VpnPluginOldFailureCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [failure](#signal:failure) 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' vpnPluginOld #failure callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterVpnPluginOldFailure :: (IsVpnPluginOld a, MonadIO m) => a -> ((?self :: a) => VpnPluginOldFailureCallback) -> m SignalHandlerId
afterVpnPluginOldFailure :: forall a (m :: * -> *).
(IsVpnPluginOld a, MonadIO m) =>
a
-> ((?self::a) => VpnPluginOldFailureCallback) -> m SignalHandlerId
afterVpnPluginOldFailure a
obj (?self::a) => VpnPluginOldFailureCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> VpnPluginOldFailureCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => VpnPluginOldFailureCallback
VpnPluginOldFailureCallback
cb
    let wrapped' :: C_VpnPluginOldFailureCallback
wrapped' = (a -> VpnPluginOldFailureCallback) -> C_VpnPluginOldFailureCallback
forall a.
GObject a =>
(a -> VpnPluginOldFailureCallback) -> C_VpnPluginOldFailureCallback
wrap_VpnPluginOldFailureCallback a -> VpnPluginOldFailureCallback
wrapped
    FunPtr C_VpnPluginOldFailureCallback
wrapped'' <- C_VpnPluginOldFailureCallback
-> IO (FunPtr C_VpnPluginOldFailureCallback)
mk_VpnPluginOldFailureCallback C_VpnPluginOldFailureCallback
wrapped'
    a
-> Text
-> FunPtr C_VpnPluginOldFailureCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"failure" FunPtr C_VpnPluginOldFailureCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VpnPluginOldFailureSignalInfo
instance SignalInfo VpnPluginOldFailureSignalInfo where
    type HaskellCallbackType VpnPluginOldFailureSignalInfo = VpnPluginOldFailureCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VpnPluginOldFailureCallback cb
        cb'' <- mk_VpnPluginOldFailureCallback cb'
        connectSignalFunPtr obj "failure" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld::failure"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#g:signal:failure"})

#endif

-- signal VpnPluginOld::ip4-config
-- | /No description available in the introspection data./
type VpnPluginOldIp4ConfigCallback =
    GVariant
    -> IO ()

type C_VpnPluginOldIp4ConfigCallback =
    Ptr VpnPluginOld ->                     -- object
    Ptr GVariant ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_VpnPluginOldIp4ConfigCallback :: 
    GObject a => (a -> VpnPluginOldIp4ConfigCallback) ->
    C_VpnPluginOldIp4ConfigCallback
wrap_VpnPluginOldIp4ConfigCallback :: forall a.
GObject a =>
(a -> VpnPluginOldConfigCallback) -> C_VpnPluginOldConfigCallback
wrap_VpnPluginOldIp4ConfigCallback a -> VpnPluginOldConfigCallback
gi'cb Ptr VpnPluginOld
gi'selfPtr Ptr GVariant
object Ptr ()
_ = do
    GVariant
object' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
object
    Ptr VpnPluginOld -> (VpnPluginOld -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr VpnPluginOld
gi'selfPtr ((VpnPluginOld -> IO ()) -> IO ())
-> (VpnPluginOld -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \VpnPluginOld
gi'self -> a -> VpnPluginOldConfigCallback
gi'cb (VpnPluginOld -> a
forall a b. Coercible a b => a -> b
Coerce.coerce VpnPluginOld
gi'self)  GVariant
object'


-- | Connect a signal handler for the [ip4Config](#signal:ip4Config) 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' vpnPluginOld #ip4Config callback
-- @
-- 
-- 
onVpnPluginOldIp4Config :: (IsVpnPluginOld a, MonadIO m) => a -> ((?self :: a) => VpnPluginOldIp4ConfigCallback) -> m SignalHandlerId
onVpnPluginOldIp4Config :: forall a (m :: * -> *).
(IsVpnPluginOld a, MonadIO m) =>
a
-> ((?self::a) => VpnPluginOldConfigCallback) -> m SignalHandlerId
onVpnPluginOldIp4Config a
obj (?self::a) => VpnPluginOldConfigCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> VpnPluginOldConfigCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => VpnPluginOldConfigCallback
VpnPluginOldConfigCallback
cb
    let wrapped' :: C_VpnPluginOldConfigCallback
wrapped' = (a -> VpnPluginOldConfigCallback) -> C_VpnPluginOldConfigCallback
forall a.
GObject a =>
(a -> VpnPluginOldConfigCallback) -> C_VpnPluginOldConfigCallback
wrap_VpnPluginOldIp4ConfigCallback a -> VpnPluginOldConfigCallback
wrapped
    FunPtr C_VpnPluginOldConfigCallback
wrapped'' <- C_VpnPluginOldConfigCallback
-> IO (FunPtr C_VpnPluginOldConfigCallback)
mk_VpnPluginOldIp4ConfigCallback C_VpnPluginOldConfigCallback
wrapped'
    a
-> Text
-> FunPtr C_VpnPluginOldConfigCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"ip4-config" FunPtr C_VpnPluginOldConfigCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [ip4Config](#signal:ip4Config) 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' vpnPluginOld #ip4Config callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterVpnPluginOldIp4Config :: (IsVpnPluginOld a, MonadIO m) => a -> ((?self :: a) => VpnPluginOldIp4ConfigCallback) -> m SignalHandlerId
afterVpnPluginOldIp4Config :: forall a (m :: * -> *).
(IsVpnPluginOld a, MonadIO m) =>
a
-> ((?self::a) => VpnPluginOldConfigCallback) -> m SignalHandlerId
afterVpnPluginOldIp4Config a
obj (?self::a) => VpnPluginOldConfigCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> VpnPluginOldConfigCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => VpnPluginOldConfigCallback
VpnPluginOldConfigCallback
cb
    let wrapped' :: C_VpnPluginOldConfigCallback
wrapped' = (a -> VpnPluginOldConfigCallback) -> C_VpnPluginOldConfigCallback
forall a.
GObject a =>
(a -> VpnPluginOldConfigCallback) -> C_VpnPluginOldConfigCallback
wrap_VpnPluginOldIp4ConfigCallback a -> VpnPluginOldConfigCallback
wrapped
    FunPtr C_VpnPluginOldConfigCallback
wrapped'' <- C_VpnPluginOldConfigCallback
-> IO (FunPtr C_VpnPluginOldConfigCallback)
mk_VpnPluginOldIp4ConfigCallback C_VpnPluginOldConfigCallback
wrapped'
    a
-> Text
-> FunPtr C_VpnPluginOldConfigCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"ip4-config" FunPtr C_VpnPluginOldConfigCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VpnPluginOldIp4ConfigSignalInfo
instance SignalInfo VpnPluginOldIp4ConfigSignalInfo where
    type HaskellCallbackType VpnPluginOldIp4ConfigSignalInfo = VpnPluginOldIp4ConfigCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VpnPluginOldIp4ConfigCallback cb
        cb'' <- mk_VpnPluginOldIp4ConfigCallback cb'
        connectSignalFunPtr obj "ip4-config" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld::ip4-config"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#g:signal:ip4Config"})

#endif

-- signal VpnPluginOld::ip6-config
-- | /No description available in the introspection data./
type VpnPluginOldIp6ConfigCallback =
    GVariant
    -> IO ()

type C_VpnPluginOldIp6ConfigCallback =
    Ptr VpnPluginOld ->                     -- object
    Ptr GVariant ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_VpnPluginOldIp6ConfigCallback :: 
    GObject a => (a -> VpnPluginOldIp6ConfigCallback) ->
    C_VpnPluginOldIp6ConfigCallback
wrap_VpnPluginOldIp6ConfigCallback :: forall a.
GObject a =>
(a -> VpnPluginOldConfigCallback) -> C_VpnPluginOldConfigCallback
wrap_VpnPluginOldIp6ConfigCallback a -> VpnPluginOldConfigCallback
gi'cb Ptr VpnPluginOld
gi'selfPtr Ptr GVariant
object Ptr ()
_ = do
    GVariant
object' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
object
    Ptr VpnPluginOld -> (VpnPluginOld -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr VpnPluginOld
gi'selfPtr ((VpnPluginOld -> IO ()) -> IO ())
-> (VpnPluginOld -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \VpnPluginOld
gi'self -> a -> VpnPluginOldConfigCallback
gi'cb (VpnPluginOld -> a
forall a b. Coercible a b => a -> b
Coerce.coerce VpnPluginOld
gi'self)  GVariant
object'


-- | Connect a signal handler for the [ip6Config](#signal:ip6Config) 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' vpnPluginOld #ip6Config callback
-- @
-- 
-- 
onVpnPluginOldIp6Config :: (IsVpnPluginOld a, MonadIO m) => a -> ((?self :: a) => VpnPluginOldIp6ConfigCallback) -> m SignalHandlerId
onVpnPluginOldIp6Config :: forall a (m :: * -> *).
(IsVpnPluginOld a, MonadIO m) =>
a
-> ((?self::a) => VpnPluginOldConfigCallback) -> m SignalHandlerId
onVpnPluginOldIp6Config a
obj (?self::a) => VpnPluginOldConfigCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> VpnPluginOldConfigCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => VpnPluginOldConfigCallback
VpnPluginOldConfigCallback
cb
    let wrapped' :: C_VpnPluginOldConfigCallback
wrapped' = (a -> VpnPluginOldConfigCallback) -> C_VpnPluginOldConfigCallback
forall a.
GObject a =>
(a -> VpnPluginOldConfigCallback) -> C_VpnPluginOldConfigCallback
wrap_VpnPluginOldIp6ConfigCallback a -> VpnPluginOldConfigCallback
wrapped
    FunPtr C_VpnPluginOldConfigCallback
wrapped'' <- C_VpnPluginOldConfigCallback
-> IO (FunPtr C_VpnPluginOldConfigCallback)
mk_VpnPluginOldIp6ConfigCallback C_VpnPluginOldConfigCallback
wrapped'
    a
-> Text
-> FunPtr C_VpnPluginOldConfigCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"ip6-config" FunPtr C_VpnPluginOldConfigCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [ip6Config](#signal:ip6Config) 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' vpnPluginOld #ip6Config callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterVpnPluginOldIp6Config :: (IsVpnPluginOld a, MonadIO m) => a -> ((?self :: a) => VpnPluginOldIp6ConfigCallback) -> m SignalHandlerId
afterVpnPluginOldIp6Config :: forall a (m :: * -> *).
(IsVpnPluginOld a, MonadIO m) =>
a
-> ((?self::a) => VpnPluginOldConfigCallback) -> m SignalHandlerId
afterVpnPluginOldIp6Config a
obj (?self::a) => VpnPluginOldConfigCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> VpnPluginOldConfigCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => VpnPluginOldConfigCallback
VpnPluginOldConfigCallback
cb
    let wrapped' :: C_VpnPluginOldConfigCallback
wrapped' = (a -> VpnPluginOldConfigCallback) -> C_VpnPluginOldConfigCallback
forall a.
GObject a =>
(a -> VpnPluginOldConfigCallback) -> C_VpnPluginOldConfigCallback
wrap_VpnPluginOldIp6ConfigCallback a -> VpnPluginOldConfigCallback
wrapped
    FunPtr C_VpnPluginOldConfigCallback
wrapped'' <- C_VpnPluginOldConfigCallback
-> IO (FunPtr C_VpnPluginOldConfigCallback)
mk_VpnPluginOldIp6ConfigCallback C_VpnPluginOldConfigCallback
wrapped'
    a
-> Text
-> FunPtr C_VpnPluginOldConfigCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"ip6-config" FunPtr C_VpnPluginOldConfigCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VpnPluginOldIp6ConfigSignalInfo
instance SignalInfo VpnPluginOldIp6ConfigSignalInfo where
    type HaskellCallbackType VpnPluginOldIp6ConfigSignalInfo = VpnPluginOldIp6ConfigCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VpnPluginOldIp6ConfigCallback cb
        cb'' <- mk_VpnPluginOldIp6ConfigCallback cb'
        connectSignalFunPtr obj "ip6-config" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld::ip6-config"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#g:signal:ip6Config"})

#endif

-- signal VpnPluginOld::login-banner
-- | /No description available in the introspection data./
type VpnPluginOldLoginBannerCallback =
    T.Text
    -> IO ()

type C_VpnPluginOldLoginBannerCallback =
    Ptr VpnPluginOld ->                     -- object
    CString ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_VpnPluginOldLoginBannerCallback :: 
    GObject a => (a -> VpnPluginOldLoginBannerCallback) ->
    C_VpnPluginOldLoginBannerCallback
wrap_VpnPluginOldLoginBannerCallback :: forall a.
GObject a =>
(a -> VpnPluginOldLoginBannerCallback)
-> C_VpnPluginOldLoginBannerCallback
wrap_VpnPluginOldLoginBannerCallback a -> VpnPluginOldLoginBannerCallback
gi'cb Ptr VpnPluginOld
gi'selfPtr CString
object Ptr ()
_ = do
    Text
object' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
object
    Ptr VpnPluginOld -> (VpnPluginOld -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr VpnPluginOld
gi'selfPtr ((VpnPluginOld -> IO ()) -> IO ())
-> (VpnPluginOld -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \VpnPluginOld
gi'self -> a -> VpnPluginOldLoginBannerCallback
gi'cb (VpnPluginOld -> a
forall a b. Coercible a b => a -> b
Coerce.coerce VpnPluginOld
gi'self)  Text
object'


-- | Connect a signal handler for the [loginBanner](#signal:loginBanner) 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' vpnPluginOld #loginBanner callback
-- @
-- 
-- 
onVpnPluginOldLoginBanner :: (IsVpnPluginOld a, MonadIO m) => a -> ((?self :: a) => VpnPluginOldLoginBannerCallback) -> m SignalHandlerId
onVpnPluginOldLoginBanner :: forall a (m :: * -> *).
(IsVpnPluginOld a, MonadIO m) =>
a
-> ((?self::a) => VpnPluginOldLoginBannerCallback)
-> m SignalHandlerId
onVpnPluginOldLoginBanner a
obj (?self::a) => VpnPluginOldLoginBannerCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> VpnPluginOldLoginBannerCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => VpnPluginOldLoginBannerCallback
VpnPluginOldLoginBannerCallback
cb
    let wrapped' :: C_VpnPluginOldLoginBannerCallback
wrapped' = (a -> VpnPluginOldLoginBannerCallback)
-> C_VpnPluginOldLoginBannerCallback
forall a.
GObject a =>
(a -> VpnPluginOldLoginBannerCallback)
-> C_VpnPluginOldLoginBannerCallback
wrap_VpnPluginOldLoginBannerCallback a -> VpnPluginOldLoginBannerCallback
wrapped
    FunPtr C_VpnPluginOldLoginBannerCallback
wrapped'' <- C_VpnPluginOldLoginBannerCallback
-> IO (FunPtr C_VpnPluginOldLoginBannerCallback)
mk_VpnPluginOldLoginBannerCallback C_VpnPluginOldLoginBannerCallback
wrapped'
    a
-> Text
-> FunPtr C_VpnPluginOldLoginBannerCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"login-banner" FunPtr C_VpnPluginOldLoginBannerCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [loginBanner](#signal:loginBanner) 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' vpnPluginOld #loginBanner callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterVpnPluginOldLoginBanner :: (IsVpnPluginOld a, MonadIO m) => a -> ((?self :: a) => VpnPluginOldLoginBannerCallback) -> m SignalHandlerId
afterVpnPluginOldLoginBanner :: forall a (m :: * -> *).
(IsVpnPluginOld a, MonadIO m) =>
a
-> ((?self::a) => VpnPluginOldLoginBannerCallback)
-> m SignalHandlerId
afterVpnPluginOldLoginBanner a
obj (?self::a) => VpnPluginOldLoginBannerCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> VpnPluginOldLoginBannerCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => VpnPluginOldLoginBannerCallback
VpnPluginOldLoginBannerCallback
cb
    let wrapped' :: C_VpnPluginOldLoginBannerCallback
wrapped' = (a -> VpnPluginOldLoginBannerCallback)
-> C_VpnPluginOldLoginBannerCallback
forall a.
GObject a =>
(a -> VpnPluginOldLoginBannerCallback)
-> C_VpnPluginOldLoginBannerCallback
wrap_VpnPluginOldLoginBannerCallback a -> VpnPluginOldLoginBannerCallback
wrapped
    FunPtr C_VpnPluginOldLoginBannerCallback
wrapped'' <- C_VpnPluginOldLoginBannerCallback
-> IO (FunPtr C_VpnPluginOldLoginBannerCallback)
mk_VpnPluginOldLoginBannerCallback C_VpnPluginOldLoginBannerCallback
wrapped'
    a
-> Text
-> FunPtr C_VpnPluginOldLoginBannerCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"login-banner" FunPtr C_VpnPluginOldLoginBannerCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VpnPluginOldLoginBannerSignalInfo
instance SignalInfo VpnPluginOldLoginBannerSignalInfo where
    type HaskellCallbackType VpnPluginOldLoginBannerSignalInfo = VpnPluginOldLoginBannerCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VpnPluginOldLoginBannerCallback cb
        cb'' <- mk_VpnPluginOldLoginBannerCallback cb'
        connectSignalFunPtr obj "login-banner" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld::login-banner"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#g:signal:loginBanner"})

#endif

-- signal VpnPluginOld::quit
-- | /No description available in the introspection data./
type VpnPluginOldQuitCallback =
    IO ()

type C_VpnPluginOldQuitCallback =
    Ptr VpnPluginOld ->                     -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_VpnPluginOldQuitCallback :: 
    GObject a => (a -> VpnPluginOldQuitCallback) ->
    C_VpnPluginOldQuitCallback
wrap_VpnPluginOldQuitCallback :: forall a. GObject a => (a -> IO ()) -> C_VpnPluginOldQuitCallback
wrap_VpnPluginOldQuitCallback a -> IO ()
gi'cb Ptr VpnPluginOld
gi'selfPtr Ptr ()
_ = do
    Ptr VpnPluginOld -> (VpnPluginOld -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr VpnPluginOld
gi'selfPtr ((VpnPluginOld -> IO ()) -> IO ())
-> (VpnPluginOld -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \VpnPluginOld
gi'self -> a -> IO ()
gi'cb (VpnPluginOld -> a
forall a b. Coercible a b => a -> b
Coerce.coerce VpnPluginOld
gi'self) 


-- | Connect a signal handler for the [quit](#signal:quit) 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' vpnPluginOld #quit callback
-- @
-- 
-- 
onVpnPluginOldQuit :: (IsVpnPluginOld a, MonadIO m) => a -> ((?self :: a) => VpnPluginOldQuitCallback) -> m SignalHandlerId
onVpnPluginOldQuit :: forall a (m :: * -> *).
(IsVpnPluginOld a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onVpnPluginOldQuit a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_VpnPluginOldQuitCallback
wrapped' = (a -> IO ()) -> C_VpnPluginOldQuitCallback
forall a. GObject a => (a -> IO ()) -> C_VpnPluginOldQuitCallback
wrap_VpnPluginOldQuitCallback a -> IO ()
wrapped
    FunPtr C_VpnPluginOldQuitCallback
wrapped'' <- C_VpnPluginOldQuitCallback
-> IO (FunPtr C_VpnPluginOldQuitCallback)
mk_VpnPluginOldQuitCallback C_VpnPluginOldQuitCallback
wrapped'
    a
-> Text
-> FunPtr C_VpnPluginOldQuitCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"quit" FunPtr C_VpnPluginOldQuitCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [quit](#signal:quit) 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' vpnPluginOld #quit callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterVpnPluginOldQuit :: (IsVpnPluginOld a, MonadIO m) => a -> ((?self :: a) => VpnPluginOldQuitCallback) -> m SignalHandlerId
afterVpnPluginOldQuit :: forall a (m :: * -> *).
(IsVpnPluginOld a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterVpnPluginOldQuit a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_VpnPluginOldQuitCallback
wrapped' = (a -> IO ()) -> C_VpnPluginOldQuitCallback
forall a. GObject a => (a -> IO ()) -> C_VpnPluginOldQuitCallback
wrap_VpnPluginOldQuitCallback a -> IO ()
wrapped
    FunPtr C_VpnPluginOldQuitCallback
wrapped'' <- C_VpnPluginOldQuitCallback
-> IO (FunPtr C_VpnPluginOldQuitCallback)
mk_VpnPluginOldQuitCallback C_VpnPluginOldQuitCallback
wrapped'
    a
-> Text
-> FunPtr C_VpnPluginOldQuitCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"quit" FunPtr C_VpnPluginOldQuitCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VpnPluginOldQuitSignalInfo
instance SignalInfo VpnPluginOldQuitSignalInfo where
    type HaskellCallbackType VpnPluginOldQuitSignalInfo = VpnPluginOldQuitCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VpnPluginOldQuitCallback cb
        cb'' <- mk_VpnPluginOldQuitCallback cb'
        connectSignalFunPtr obj "quit" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld::quit"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#g:signal:quit"})

#endif

-- signal VpnPluginOld::secrets-required
-- | /No description available in the introspection data./
type VpnPluginOldSecretsRequiredCallback =
    T.Text
    -> [T.Text]
    -> IO ()

type C_VpnPluginOldSecretsRequiredCallback =
    Ptr VpnPluginOld ->                     -- object
    CString ->
    Ptr CString ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_VpnPluginOldSecretsRequiredCallback :: 
    GObject a => (a -> VpnPluginOldSecretsRequiredCallback) ->
    C_VpnPluginOldSecretsRequiredCallback
wrap_VpnPluginOldSecretsRequiredCallback :: forall a.
GObject a =>
(a -> VpnPluginOldSecretsRequiredCallback)
-> C_VpnPluginOldSecretsRequiredCallback
wrap_VpnPluginOldSecretsRequiredCallback a -> VpnPluginOldSecretsRequiredCallback
gi'cb Ptr VpnPluginOld
gi'selfPtr CString
object Ptr CString
p0 Ptr ()
_ = do
    Text
object' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
object
    [Text]
p0' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
p0
    Ptr VpnPluginOld -> (VpnPluginOld -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr VpnPluginOld
gi'selfPtr ((VpnPluginOld -> IO ()) -> IO ())
-> (VpnPluginOld -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \VpnPluginOld
gi'self -> a -> VpnPluginOldSecretsRequiredCallback
gi'cb (VpnPluginOld -> a
forall a b. Coercible a b => a -> b
Coerce.coerce VpnPluginOld
gi'self)  Text
object' [Text]
p0'


-- | Connect a signal handler for the [secretsRequired](#signal:secretsRequired) 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' vpnPluginOld #secretsRequired callback
-- @
-- 
-- 
onVpnPluginOldSecretsRequired :: (IsVpnPluginOld a, MonadIO m) => a -> ((?self :: a) => VpnPluginOldSecretsRequiredCallback) -> m SignalHandlerId
onVpnPluginOldSecretsRequired :: forall a (m :: * -> *).
(IsVpnPluginOld a, MonadIO m) =>
a
-> ((?self::a) => VpnPluginOldSecretsRequiredCallback)
-> m SignalHandlerId
onVpnPluginOldSecretsRequired a
obj (?self::a) => VpnPluginOldSecretsRequiredCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> VpnPluginOldSecretsRequiredCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => VpnPluginOldSecretsRequiredCallback
VpnPluginOldSecretsRequiredCallback
cb
    let wrapped' :: C_VpnPluginOldSecretsRequiredCallback
wrapped' = (a -> VpnPluginOldSecretsRequiredCallback)
-> C_VpnPluginOldSecretsRequiredCallback
forall a.
GObject a =>
(a -> VpnPluginOldSecretsRequiredCallback)
-> C_VpnPluginOldSecretsRequiredCallback
wrap_VpnPluginOldSecretsRequiredCallback a -> VpnPluginOldSecretsRequiredCallback
wrapped
    FunPtr C_VpnPluginOldSecretsRequiredCallback
wrapped'' <- C_VpnPluginOldSecretsRequiredCallback
-> IO (FunPtr C_VpnPluginOldSecretsRequiredCallback)
mk_VpnPluginOldSecretsRequiredCallback C_VpnPluginOldSecretsRequiredCallback
wrapped'
    a
-> Text
-> FunPtr C_VpnPluginOldSecretsRequiredCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"secrets-required" FunPtr C_VpnPluginOldSecretsRequiredCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [secretsRequired](#signal:secretsRequired) 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' vpnPluginOld #secretsRequired callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterVpnPluginOldSecretsRequired :: (IsVpnPluginOld a, MonadIO m) => a -> ((?self :: a) => VpnPluginOldSecretsRequiredCallback) -> m SignalHandlerId
afterVpnPluginOldSecretsRequired :: forall a (m :: * -> *).
(IsVpnPluginOld a, MonadIO m) =>
a
-> ((?self::a) => VpnPluginOldSecretsRequiredCallback)
-> m SignalHandlerId
afterVpnPluginOldSecretsRequired a
obj (?self::a) => VpnPluginOldSecretsRequiredCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> VpnPluginOldSecretsRequiredCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => VpnPluginOldSecretsRequiredCallback
VpnPluginOldSecretsRequiredCallback
cb
    let wrapped' :: C_VpnPluginOldSecretsRequiredCallback
wrapped' = (a -> VpnPluginOldSecretsRequiredCallback)
-> C_VpnPluginOldSecretsRequiredCallback
forall a.
GObject a =>
(a -> VpnPluginOldSecretsRequiredCallback)
-> C_VpnPluginOldSecretsRequiredCallback
wrap_VpnPluginOldSecretsRequiredCallback a -> VpnPluginOldSecretsRequiredCallback
wrapped
    FunPtr C_VpnPluginOldSecretsRequiredCallback
wrapped'' <- C_VpnPluginOldSecretsRequiredCallback
-> IO (FunPtr C_VpnPluginOldSecretsRequiredCallback)
mk_VpnPluginOldSecretsRequiredCallback C_VpnPluginOldSecretsRequiredCallback
wrapped'
    a
-> Text
-> FunPtr C_VpnPluginOldSecretsRequiredCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"secrets-required" FunPtr C_VpnPluginOldSecretsRequiredCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VpnPluginOldSecretsRequiredSignalInfo
instance SignalInfo VpnPluginOldSecretsRequiredSignalInfo where
    type HaskellCallbackType VpnPluginOldSecretsRequiredSignalInfo = VpnPluginOldSecretsRequiredCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VpnPluginOldSecretsRequiredCallback cb
        cb'' <- mk_VpnPluginOldSecretsRequiredCallback cb'
        connectSignalFunPtr obj "secrets-required" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld::secrets-required"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#g:signal:secretsRequired"})

#endif

-- signal VpnPluginOld::state-changed
-- | /No description available in the introspection data./
type VpnPluginOldStateChangedCallback =
    Word32
    -> IO ()

type C_VpnPluginOldStateChangedCallback =
    Ptr VpnPluginOld ->                     -- object
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_VpnPluginOldStateChangedCallback :: 
    GObject a => (a -> VpnPluginOldStateChangedCallback) ->
    C_VpnPluginOldStateChangedCallback
wrap_VpnPluginOldStateChangedCallback :: forall a.
GObject a =>
(a -> VpnPluginOldFailureCallback) -> C_VpnPluginOldFailureCallback
wrap_VpnPluginOldStateChangedCallback a -> VpnPluginOldFailureCallback
gi'cb Ptr VpnPluginOld
gi'selfPtr Word32
object Ptr ()
_ = do
    Ptr VpnPluginOld -> (VpnPluginOld -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr VpnPluginOld
gi'selfPtr ((VpnPluginOld -> IO ()) -> IO ())
-> (VpnPluginOld -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \VpnPluginOld
gi'self -> a -> VpnPluginOldFailureCallback
gi'cb (VpnPluginOld -> a
forall a b. Coercible a b => a -> b
Coerce.coerce VpnPluginOld
gi'self)  Word32
object


-- | Connect a signal handler for the [stateChanged](#signal:stateChanged) 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' vpnPluginOld #stateChanged callback
-- @
-- 
-- 
onVpnPluginOldStateChanged :: (IsVpnPluginOld a, MonadIO m) => a -> ((?self :: a) => VpnPluginOldStateChangedCallback) -> m SignalHandlerId
onVpnPluginOldStateChanged :: forall a (m :: * -> *).
(IsVpnPluginOld a, MonadIO m) =>
a
-> ((?self::a) => VpnPluginOldFailureCallback) -> m SignalHandlerId
onVpnPluginOldStateChanged a
obj (?self::a) => VpnPluginOldFailureCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> VpnPluginOldFailureCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => VpnPluginOldFailureCallback
VpnPluginOldFailureCallback
cb
    let wrapped' :: C_VpnPluginOldFailureCallback
wrapped' = (a -> VpnPluginOldFailureCallback) -> C_VpnPluginOldFailureCallback
forall a.
GObject a =>
(a -> VpnPluginOldFailureCallback) -> C_VpnPluginOldFailureCallback
wrap_VpnPluginOldStateChangedCallback a -> VpnPluginOldFailureCallback
wrapped
    FunPtr C_VpnPluginOldFailureCallback
wrapped'' <- C_VpnPluginOldFailureCallback
-> IO (FunPtr C_VpnPluginOldFailureCallback)
mk_VpnPluginOldStateChangedCallback C_VpnPluginOldFailureCallback
wrapped'
    a
-> Text
-> FunPtr C_VpnPluginOldFailureCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"state-changed" FunPtr C_VpnPluginOldFailureCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [stateChanged](#signal:stateChanged) 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' vpnPluginOld #stateChanged callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterVpnPluginOldStateChanged :: (IsVpnPluginOld a, MonadIO m) => a -> ((?self :: a) => VpnPluginOldStateChangedCallback) -> m SignalHandlerId
afterVpnPluginOldStateChanged :: forall a (m :: * -> *).
(IsVpnPluginOld a, MonadIO m) =>
a
-> ((?self::a) => VpnPluginOldFailureCallback) -> m SignalHandlerId
afterVpnPluginOldStateChanged a
obj (?self::a) => VpnPluginOldFailureCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> VpnPluginOldFailureCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => VpnPluginOldFailureCallback
VpnPluginOldFailureCallback
cb
    let wrapped' :: C_VpnPluginOldFailureCallback
wrapped' = (a -> VpnPluginOldFailureCallback) -> C_VpnPluginOldFailureCallback
forall a.
GObject a =>
(a -> VpnPluginOldFailureCallback) -> C_VpnPluginOldFailureCallback
wrap_VpnPluginOldStateChangedCallback a -> VpnPluginOldFailureCallback
wrapped
    FunPtr C_VpnPluginOldFailureCallback
wrapped'' <- C_VpnPluginOldFailureCallback
-> IO (FunPtr C_VpnPluginOldFailureCallback)
mk_VpnPluginOldStateChangedCallback C_VpnPluginOldFailureCallback
wrapped'
    a
-> Text
-> FunPtr C_VpnPluginOldFailureCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"state-changed" FunPtr C_VpnPluginOldFailureCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VpnPluginOldStateChangedSignalInfo
instance SignalInfo VpnPluginOldStateChangedSignalInfo where
    type HaskellCallbackType VpnPluginOldStateChangedSignalInfo = VpnPluginOldStateChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VpnPluginOldStateChangedCallback cb
        cb'' <- mk_VpnPluginOldStateChangedCallback cb'
        connectSignalFunPtr obj "state-changed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld::state-changed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#g:signal:stateChanged"})

#endif

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

-- | Get the value of the “@service-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' vpnPluginOld #serviceName
-- @
getVpnPluginOldServiceName :: (MonadIO m, IsVpnPluginOld o) => o -> m (Maybe T.Text)
getVpnPluginOldServiceName :: forall (m :: * -> *) o.
(MonadIO m, IsVpnPluginOld o) =>
o -> m (Maybe Text)
getVpnPluginOldServiceName o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 String
"service-name"

-- | Construct a t'GValueConstruct' with valid value for the “@service-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructVpnPluginOldServiceName :: (IsVpnPluginOld o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructVpnPluginOldServiceName :: forall o (m :: * -> *).
(IsVpnPluginOld o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructVpnPluginOldServiceName Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (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 String
"service-name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data VpnPluginOldServiceNamePropertyInfo
instance AttrInfo VpnPluginOldServiceNamePropertyInfo where
    type AttrAllowedOps VpnPluginOldServiceNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint VpnPluginOldServiceNamePropertyInfo = IsVpnPluginOld
    type AttrSetTypeConstraint VpnPluginOldServiceNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint VpnPluginOldServiceNamePropertyInfo = (~) T.Text
    type AttrTransferType VpnPluginOldServiceNamePropertyInfo = T.Text
    type AttrGetType VpnPluginOldServiceNamePropertyInfo = (Maybe T.Text)
    type AttrLabel VpnPluginOldServiceNamePropertyInfo = "service-name"
    type AttrOrigin VpnPluginOldServiceNamePropertyInfo = VpnPluginOld
    attrGet = getVpnPluginOldServiceName
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructVpnPluginOldServiceName
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld.serviceName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#g:attr:serviceName"
        })
#endif

-- VVV Prop "state"
   -- Type: TInterface (Name {namespace = "NM", name = "VpnServiceState"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,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' vpnPluginOld #state
-- @
getVpnPluginOldState :: (MonadIO m, IsVpnPluginOld o) => o -> m NM.Enums.VpnServiceState
getVpnPluginOldState :: forall (m :: * -> *) o.
(MonadIO m, IsVpnPluginOld o) =>
o -> m VpnServiceState
getVpnPluginOldState o
obj = IO VpnServiceState -> m VpnServiceState
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO VpnServiceState -> m VpnServiceState)
-> IO VpnServiceState -> m VpnServiceState
forall a b. (a -> b) -> a -> b
$ o -> String -> IO VpnServiceState
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"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' vpnPluginOld [ #state 'Data.GI.Base.Attributes.:=' value ]
-- @
setVpnPluginOldState :: (MonadIO m, IsVpnPluginOld o) => o -> NM.Enums.VpnServiceState -> m ()
setVpnPluginOldState :: forall (m :: * -> *) o.
(MonadIO m, IsVpnPluginOld o) =>
o -> VpnServiceState -> m ()
setVpnPluginOldState o
obj VpnServiceState
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> VpnServiceState -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"state" VpnServiceState
val

-- | Construct a t'GValueConstruct' with valid value for the “@state@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructVpnPluginOldState :: (IsVpnPluginOld o, MIO.MonadIO m) => NM.Enums.VpnServiceState -> m (GValueConstruct o)
constructVpnPluginOldState :: forall o (m :: * -> *).
(IsVpnPluginOld o, MonadIO m) =>
VpnServiceState -> m (GValueConstruct o)
constructVpnPluginOldState VpnServiceState
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> VpnServiceState -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"state" VpnServiceState
val

#if defined(ENABLE_OVERLOADING)
data VpnPluginOldStatePropertyInfo
instance AttrInfo VpnPluginOldStatePropertyInfo where
    type AttrAllowedOps VpnPluginOldStatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint VpnPluginOldStatePropertyInfo = IsVpnPluginOld
    type AttrSetTypeConstraint VpnPluginOldStatePropertyInfo = (~) NM.Enums.VpnServiceState
    type AttrTransferTypeConstraint VpnPluginOldStatePropertyInfo = (~) NM.Enums.VpnServiceState
    type AttrTransferType VpnPluginOldStatePropertyInfo = NM.Enums.VpnServiceState
    type AttrGetType VpnPluginOldStatePropertyInfo = NM.Enums.VpnServiceState
    type AttrLabel VpnPluginOldStatePropertyInfo = "state"
    type AttrOrigin VpnPluginOldStatePropertyInfo = VpnPluginOld
    attrGet = getVpnPluginOldState
    attrSet = setVpnPluginOldState
    attrTransfer _ v = do
        return v
    attrConstruct = constructVpnPluginOldState
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld.state"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#g:attr:state"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VpnPluginOld
type instance O.AttributeList VpnPluginOld = VpnPluginOldAttributeList
type VpnPluginOldAttributeList = ('[ '("serviceName", VpnPluginOldServiceNamePropertyInfo), '("state", VpnPluginOldStatePropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
vpnPluginOldServiceName :: AttrLabelProxy "serviceName"
vpnPluginOldServiceName = AttrLabelProxy

vpnPluginOldState :: AttrLabelProxy "state"
vpnPluginOldState = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList VpnPluginOld = VpnPluginOldSignalList
type VpnPluginOldSignalList = ('[ '("config", VpnPluginOldConfigSignalInfo), '("failure", VpnPluginOldFailureSignalInfo), '("ip4Config", VpnPluginOldIp4ConfigSignalInfo), '("ip6Config", VpnPluginOldIp6ConfigSignalInfo), '("loginBanner", VpnPluginOldLoginBannerSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("quit", VpnPluginOldQuitSignalInfo), '("secretsRequired", VpnPluginOldSecretsRequiredSignalInfo), '("stateChanged", VpnPluginOldStateChangedSignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method VpnPluginOld::disconnect
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "plugin"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "VpnPluginOld" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "nm_vpn_plugin_old_disconnect" nm_vpn_plugin_old_disconnect :: 
    Ptr VpnPluginOld ->                     -- plugin : TInterface (Name {namespace = "NM", name = "VpnPluginOld"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{-# DEPRECATED vpnPluginOldDisconnect ["(Since version 1.2)","Replaced by NMVpnServicePlugin."] #-}
-- | /No description available in the introspection data./
vpnPluginOldDisconnect ::
    (B.CallStack.HasCallStack, MonadIO m, IsVpnPluginOld a) =>
    a
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
vpnPluginOldDisconnect :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVpnPluginOld a) =>
a -> m ()
vpnPluginOldDisconnect a
plugin = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr VpnPluginOld
plugin' <- a -> IO (Ptr VpnPluginOld)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr VpnPluginOld -> Ptr (Ptr GError) -> IO CInt
nm_vpn_plugin_old_disconnect Ptr VpnPluginOld
plugin'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data VpnPluginOldDisconnectMethodInfo
instance (signature ~ (m ()), MonadIO m, IsVpnPluginOld a) => O.OverloadedMethod VpnPluginOldDisconnectMethodInfo a signature where
    overloadedMethod = vpnPluginOldDisconnect

instance O.OverloadedMethodInfo VpnPluginOldDisconnectMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld.vpnPluginOldDisconnect",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#v:vpnPluginOldDisconnect"
        })


#endif

-- method VpnPluginOld::failure
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "plugin"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "VpnPluginOld" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "reason"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "VpnPluginFailure" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "nm_vpn_plugin_old_failure" nm_vpn_plugin_old_failure :: 
    Ptr VpnPluginOld ->                     -- plugin : TInterface (Name {namespace = "NM", name = "VpnPluginOld"})
    CUInt ->                                -- reason : TInterface (Name {namespace = "NM", name = "VpnPluginFailure"})
    IO ()

{-# DEPRECATED vpnPluginOldFailure ["(Since version 1.2)","Replaced by NMVpnServicePlugin."] #-}
-- | /No description available in the introspection data./
vpnPluginOldFailure ::
    (B.CallStack.HasCallStack, MonadIO m, IsVpnPluginOld a) =>
    a
    -> NM.Enums.VpnPluginFailure
    -> m ()
vpnPluginOldFailure :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVpnPluginOld a) =>
a -> VpnPluginFailure -> m ()
vpnPluginOldFailure a
plugin VpnPluginFailure
reason = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr VpnPluginOld
plugin' <- a -> IO (Ptr VpnPluginOld)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
    let reason' :: CUInt
reason' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (VpnPluginFailure -> Int) -> VpnPluginFailure -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VpnPluginFailure -> Int
forall a. Enum a => a -> Int
fromEnum) VpnPluginFailure
reason
    Ptr VpnPluginOld -> CUInt -> IO ()
nm_vpn_plugin_old_failure Ptr VpnPluginOld
plugin' CUInt
reason'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VpnPluginOldFailureMethodInfo
instance (signature ~ (NM.Enums.VpnPluginFailure -> m ()), MonadIO m, IsVpnPluginOld a) => O.OverloadedMethod VpnPluginOldFailureMethodInfo a signature where
    overloadedMethod = vpnPluginOldFailure

instance O.OverloadedMethodInfo VpnPluginOldFailureMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld.vpnPluginOldFailure",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#v:vpnPluginOldFailure"
        })


#endif

-- method VpnPluginOld::get_connection
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "plugin"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "VpnPluginOld" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gio" , name = "DBusConnection" })
-- throws : False
-- Skip return : False

foreign import ccall "nm_vpn_plugin_old_get_connection" nm_vpn_plugin_old_get_connection :: 
    Ptr VpnPluginOld ->                     -- plugin : TInterface (Name {namespace = "NM", name = "VpnPluginOld"})
    IO (Ptr Gio.DBusConnection.DBusConnection)

{-# DEPRECATED vpnPluginOldGetConnection ["(Since version 1.2)","Replaced by NMVpnServicePlugin."] #-}
-- | /No description available in the introspection data./
vpnPluginOldGetConnection ::
    (B.CallStack.HasCallStack, MonadIO m, IsVpnPluginOld a) =>
    a
    -> m Gio.DBusConnection.DBusConnection
vpnPluginOldGetConnection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVpnPluginOld a) =>
a -> m DBusConnection
vpnPluginOldGetConnection a
plugin = IO DBusConnection -> m DBusConnection
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DBusConnection -> m DBusConnection)
-> IO DBusConnection -> m DBusConnection
forall a b. (a -> b) -> a -> b
$ do
    Ptr VpnPluginOld
plugin' <- a -> IO (Ptr VpnPluginOld)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
    Ptr DBusConnection
result <- Ptr VpnPluginOld -> IO (Ptr DBusConnection)
nm_vpn_plugin_old_get_connection Ptr VpnPluginOld
plugin'
    Text -> Ptr DBusConnection -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"vpnPluginOldGetConnection" Ptr DBusConnection
result
    DBusConnection
result' <- ((ManagedPtr DBusConnection -> DBusConnection)
-> Ptr DBusConnection -> IO DBusConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DBusConnection -> DBusConnection
Gio.DBusConnection.DBusConnection) Ptr DBusConnection
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
    DBusConnection -> IO DBusConnection
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DBusConnection
result'

#if defined(ENABLE_OVERLOADING)
data VpnPluginOldGetConnectionMethodInfo
instance (signature ~ (m Gio.DBusConnection.DBusConnection), MonadIO m, IsVpnPluginOld a) => O.OverloadedMethod VpnPluginOldGetConnectionMethodInfo a signature where
    overloadedMethod = vpnPluginOldGetConnection

instance O.OverloadedMethodInfo VpnPluginOldGetConnectionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld.vpnPluginOldGetConnection",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#v:vpnPluginOldGetConnection"
        })


#endif

-- method VpnPluginOld::get_state
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "plugin"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "VpnPluginOld" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "NM" , name = "VpnServiceState" })
-- throws : False
-- Skip return : False

foreign import ccall "nm_vpn_plugin_old_get_state" nm_vpn_plugin_old_get_state :: 
    Ptr VpnPluginOld ->                     -- plugin : TInterface (Name {namespace = "NM", name = "VpnPluginOld"})
    IO CUInt

{-# DEPRECATED vpnPluginOldGetState ["(Since version 1.2)","Replaced by NMVpnServicePlugin."] #-}
-- | /No description available in the introspection data./
vpnPluginOldGetState ::
    (B.CallStack.HasCallStack, MonadIO m, IsVpnPluginOld a) =>
    a
    -> m NM.Enums.VpnServiceState
vpnPluginOldGetState :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVpnPluginOld a) =>
a -> m VpnServiceState
vpnPluginOldGetState a
plugin = IO VpnServiceState -> m VpnServiceState
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VpnServiceState -> m VpnServiceState)
-> IO VpnServiceState -> m VpnServiceState
forall a b. (a -> b) -> a -> b
$ do
    Ptr VpnPluginOld
plugin' <- a -> IO (Ptr VpnPluginOld)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
    CUInt
result <- Ptr VpnPluginOld -> IO CUInt
nm_vpn_plugin_old_get_state Ptr VpnPluginOld
plugin'
    let result' :: VpnServiceState
result' = (Int -> VpnServiceState
forall a. Enum a => Int -> a
toEnum (Int -> VpnServiceState)
-> (CUInt -> Int) -> CUInt -> VpnServiceState
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
    VpnServiceState -> IO VpnServiceState
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return VpnServiceState
result'

#if defined(ENABLE_OVERLOADING)
data VpnPluginOldGetStateMethodInfo
instance (signature ~ (m NM.Enums.VpnServiceState), MonadIO m, IsVpnPluginOld a) => O.OverloadedMethod VpnPluginOldGetStateMethodInfo a signature where
    overloadedMethod = vpnPluginOldGetState

instance O.OverloadedMethodInfo VpnPluginOldGetStateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld.vpnPluginOldGetState",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#v:vpnPluginOldGetState"
        })


#endif

-- method VpnPluginOld::secrets_required
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "plugin"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "VpnPluginOld" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #NMVpnPluginOld"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "message"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "an information message about why secrets are required, if any"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "hints"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "VPN specific secret names for required new secrets"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "nm_vpn_plugin_old_secrets_required" nm_vpn_plugin_old_secrets_required :: 
    Ptr VpnPluginOld ->                     -- plugin : TInterface (Name {namespace = "NM", name = "VpnPluginOld"})
    CString ->                              -- message : TBasicType TUTF8
    CString ->                              -- hints : TBasicType TUTF8
    IO ()

{-# DEPRECATED vpnPluginOldSecretsRequired ["(Since version 1.2)","Replaced by NMVpnServicePlugin."] #-}
-- | Called by VPN plugin implementations to signal to NetworkManager that secrets
-- are required during the connection process.  This signal may be used to
-- request new secrets when the secrets originally provided by NetworkManager
-- are insufficient, or the VPN process indicates that it needs additional
-- information to complete the request.
vpnPluginOldSecretsRequired ::
    (B.CallStack.HasCallStack, MonadIO m, IsVpnPluginOld a) =>
    a
    -- ^ /@plugin@/: the t'GI.NM.Objects.VpnPluginOld.VpnPluginOld'
    -> T.Text
    -- ^ /@message@/: an information message about why secrets are required, if any
    -> T.Text
    -- ^ /@hints@/: VPN specific secret names for required new secrets
    -> m ()
vpnPluginOldSecretsRequired :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVpnPluginOld a) =>
a -> Text -> Text -> m ()
vpnPluginOldSecretsRequired a
plugin Text
message Text
hints = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr VpnPluginOld
plugin' <- a -> IO (Ptr VpnPluginOld)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
    CString
message' <- Text -> IO CString
textToCString Text
message
    CString
hints' <- Text -> IO CString
textToCString Text
hints
    Ptr VpnPluginOld -> CString -> CString -> IO ()
nm_vpn_plugin_old_secrets_required Ptr VpnPluginOld
plugin' CString
message' CString
hints'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
message'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
hints'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VpnPluginOldSecretsRequiredMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m, IsVpnPluginOld a) => O.OverloadedMethod VpnPluginOldSecretsRequiredMethodInfo a signature where
    overloadedMethod = vpnPluginOldSecretsRequired

instance O.OverloadedMethodInfo VpnPluginOldSecretsRequiredMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld.vpnPluginOldSecretsRequired",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#v:vpnPluginOldSecretsRequired"
        })


#endif

-- method VpnPluginOld::set_ip4_config
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "plugin"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "VpnPluginOld" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ip4_config"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "nm_vpn_plugin_old_set_ip4_config" nm_vpn_plugin_old_set_ip4_config :: 
    Ptr VpnPluginOld ->                     -- plugin : TInterface (Name {namespace = "NM", name = "VpnPluginOld"})
    Ptr GVariant ->                         -- ip4_config : TVariant
    IO ()

{-# DEPRECATED vpnPluginOldSetIp4Config ["(Since version 1.2)","Replaced by NMVpnServicePlugin."] #-}
-- | /No description available in the introspection data./
vpnPluginOldSetIp4Config ::
    (B.CallStack.HasCallStack, MonadIO m, IsVpnPluginOld a) =>
    a
    -> GVariant
    -> m ()
vpnPluginOldSetIp4Config :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVpnPluginOld a) =>
a -> GVariant -> m ()
vpnPluginOldSetIp4Config a
plugin GVariant
ip4Config = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr VpnPluginOld
plugin' <- a -> IO (Ptr VpnPluginOld)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
    Ptr GVariant
ip4Config' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
ip4Config
    Ptr VpnPluginOld -> Ptr GVariant -> IO ()
nm_vpn_plugin_old_set_ip4_config Ptr VpnPluginOld
plugin' Ptr GVariant
ip4Config'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
    VpnPluginOldConfigCallback
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
ip4Config
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VpnPluginOldSetIp4ConfigMethodInfo
instance (signature ~ (GVariant -> m ()), MonadIO m, IsVpnPluginOld a) => O.OverloadedMethod VpnPluginOldSetIp4ConfigMethodInfo a signature where
    overloadedMethod = vpnPluginOldSetIp4Config

instance O.OverloadedMethodInfo VpnPluginOldSetIp4ConfigMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld.vpnPluginOldSetIp4Config",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#v:vpnPluginOldSetIp4Config"
        })


#endif

-- method VpnPluginOld::set_login_banner
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "plugin"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "VpnPluginOld" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "banner"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "nm_vpn_plugin_old_set_login_banner" nm_vpn_plugin_old_set_login_banner :: 
    Ptr VpnPluginOld ->                     -- plugin : TInterface (Name {namespace = "NM", name = "VpnPluginOld"})
    CString ->                              -- banner : TBasicType TUTF8
    IO ()

{-# DEPRECATED vpnPluginOldSetLoginBanner ["(Since version 1.2)","Replaced by NMVpnServicePlugin."] #-}
-- | /No description available in the introspection data./
vpnPluginOldSetLoginBanner ::
    (B.CallStack.HasCallStack, MonadIO m, IsVpnPluginOld a) =>
    a
    -> T.Text
    -> m ()
vpnPluginOldSetLoginBanner :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVpnPluginOld a) =>
a -> Text -> m ()
vpnPluginOldSetLoginBanner a
plugin Text
banner = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr VpnPluginOld
plugin' <- a -> IO (Ptr VpnPluginOld)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
    CString
banner' <- Text -> IO CString
textToCString Text
banner
    Ptr VpnPluginOld -> CString -> IO ()
nm_vpn_plugin_old_set_login_banner Ptr VpnPluginOld
plugin' CString
banner'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
banner'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VpnPluginOldSetLoginBannerMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsVpnPluginOld a) => O.OverloadedMethod VpnPluginOldSetLoginBannerMethodInfo a signature where
    overloadedMethod = vpnPluginOldSetLoginBanner

instance O.OverloadedMethodInfo VpnPluginOldSetLoginBannerMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld.vpnPluginOldSetLoginBanner",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#v:vpnPluginOldSetLoginBanner"
        })


#endif

-- method VpnPluginOld::set_state
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "plugin"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "VpnPluginOld" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "state"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "VpnServiceState" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "nm_vpn_plugin_old_set_state" nm_vpn_plugin_old_set_state :: 
    Ptr VpnPluginOld ->                     -- plugin : TInterface (Name {namespace = "NM", name = "VpnPluginOld"})
    CUInt ->                                -- state : TInterface (Name {namespace = "NM", name = "VpnServiceState"})
    IO ()

{-# DEPRECATED vpnPluginOldSetState ["(Since version 1.2)","Replaced by NMVpnServicePlugin."] #-}
-- | /No description available in the introspection data./
vpnPluginOldSetState ::
    (B.CallStack.HasCallStack, MonadIO m, IsVpnPluginOld a) =>
    a
    -> NM.Enums.VpnServiceState
    -> m ()
vpnPluginOldSetState :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVpnPluginOld a) =>
a -> VpnServiceState -> m ()
vpnPluginOldSetState a
plugin VpnServiceState
state = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr VpnPluginOld
plugin' <- a -> IO (Ptr VpnPluginOld)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
plugin
    let state' :: CUInt
state' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (VpnServiceState -> Int) -> VpnServiceState -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VpnServiceState -> Int
forall a. Enum a => a -> Int
fromEnum) VpnServiceState
state
    Ptr VpnPluginOld -> CUInt -> IO ()
nm_vpn_plugin_old_set_state Ptr VpnPluginOld
plugin' CUInt
state'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
plugin
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VpnPluginOldSetStateMethodInfo
instance (signature ~ (NM.Enums.VpnServiceState -> m ()), MonadIO m, IsVpnPluginOld a) => O.OverloadedMethod VpnPluginOldSetStateMethodInfo a signature where
    overloadedMethod = vpnPluginOldSetState

instance O.OverloadedMethodInfo VpnPluginOldSetStateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.VpnPluginOld.vpnPluginOldSetState",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-VpnPluginOld.html#v:vpnPluginOldSetState"
        })


#endif

-- method VpnPluginOld::get_secret_flags
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "data"
--           , argType = TGHash (TBasicType TPtr) (TBasicType TPtr)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "hash table containing VPN key/value pair data items"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "secret_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "VPN secret key name for which to retrieve flags for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_flags"
--           , argType =
--               TInterface Name { namespace = "NM" , name = "SettingSecretFlags" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "on success, the flags associated with @secret_name"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "nm_vpn_plugin_old_get_secret_flags" nm_vpn_plugin_old_get_secret_flags :: 
    Ptr (GHashTable (Ptr ()) (Ptr ())) ->   -- data : TGHash (TBasicType TPtr) (TBasicType TPtr)
    CString ->                              -- secret_name : TBasicType TUTF8
    Ptr CUInt ->                            -- out_flags : TInterface (Name {namespace = "NM", name = "SettingSecretFlags"})
    IO CInt

{-# DEPRECATED vpnPluginOldGetSecretFlags ["(Since version 1.2)","Replaced by NMVpnServicePlugin."] #-}
-- | Given a VPN secret key name, attempts to find the corresponding flags data
-- item in /@data@/.  If found, converts the flags data item to
-- t'GI.NM.Flags.SettingSecretFlags' and returns it.
vpnPluginOldGetSecretFlags ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Map.Map (Ptr ()) (Ptr ())
    -- ^ /@data@/: hash table containing VPN key\/value pair data items
    -> T.Text
    -- ^ /@secretName@/: VPN secret key name for which to retrieve flags for
    -> m ((Bool, [NM.Flags.SettingSecretFlags]))
    -- ^ __Returns:__ 'P.True' if the flag data item was found and successfully converted
    -- to flags, 'P.False' if not
vpnPluginOldGetSecretFlags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Map (Ptr ()) (Ptr ()) -> Text -> m (Bool, [SettingSecretFlags])
vpnPluginOldGetSecretFlags Map (Ptr ()) (Ptr ())
data_ Text
secretName = IO (Bool, [SettingSecretFlags]) -> m (Bool, [SettingSecretFlags])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, [SettingSecretFlags]) -> m (Bool, [SettingSecretFlags]))
-> IO (Bool, [SettingSecretFlags])
-> m (Bool, [SettingSecretFlags])
forall a b. (a -> b) -> a -> b
$ do
    let data_' :: [(Ptr (), Ptr ())]
data_' = Map (Ptr ()) (Ptr ()) -> [(Ptr (), Ptr ())]
forall k a. Map k a -> [(k, a)]
Map.toList Map (Ptr ()) (Ptr ())
data_
    let data_'' :: [(PtrWrapped (Ptr ()), Ptr ())]
data_'' = (Ptr () -> PtrWrapped (Ptr ()))
-> [(Ptr (), Ptr ())] -> [(PtrWrapped (Ptr ()), Ptr ())]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst Ptr () -> PtrWrapped (Ptr ())
forall a. Ptr a -> PtrWrapped (Ptr a)
B.GHT.ptrPackPtr [(Ptr (), Ptr ())]
data_'
    let data_''' :: [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
data_''' = (Ptr () -> PtrWrapped (Ptr ()))
-> [(PtrWrapped (Ptr ()), Ptr ())]
-> [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond Ptr () -> PtrWrapped (Ptr ())
forall a. Ptr a -> PtrWrapped (Ptr a)
B.GHT.ptrPackPtr [(PtrWrapped (Ptr ()), Ptr ())]
data_''
    Ptr (GHashTable (Ptr ()) (Ptr ()))
data_'''' <- GHashFunc (Ptr ())
-> GEqualFunc (Ptr ())
-> Maybe (GDestroyNotify (Ptr ()))
-> Maybe (GDestroyNotify (Ptr ()))
-> [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
-> IO (Ptr (GHashTable (Ptr ()) (Ptr ())))
forall a b.
GHashFunc a
-> GEqualFunc a
-> Maybe (GDestroyNotify a)
-> Maybe (GDestroyNotify b)
-> [(PtrWrapped a, PtrWrapped b)]
-> IO (Ptr (GHashTable a b))
packGHashTable GHashFunc (Ptr ())
forall a. GHashFunc (Ptr a)
gDirectHash GEqualFunc (Ptr ())
forall a. GEqualFunc (Ptr a)
gDirectEqual Maybe (GDestroyNotify (Ptr ()))
forall a. Maybe a
Nothing Maybe (GDestroyNotify (Ptr ()))
forall a. Maybe a
Nothing [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
data_'''
    CString
secretName' <- Text -> IO CString
textToCString Text
secretName
    Ptr CUInt
outFlags <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
    CInt
result <- Ptr (GHashTable (Ptr ()) (Ptr ()))
-> CString -> Ptr CUInt -> IO CInt
nm_vpn_plugin_old_get_secret_flags Ptr (GHashTable (Ptr ()) (Ptr ()))
data_'''' CString
secretName' Ptr CUInt
outFlags
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CUInt
outFlags' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
outFlags
    let outFlags'' :: [SettingSecretFlags]
outFlags'' = CUInt -> [SettingSecretFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
outFlags'
    Ptr (GHashTable (Ptr ()) (Ptr ())) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable (Ptr ()) (Ptr ()))
data_''''
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
secretName'
    Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
outFlags
    (Bool, [SettingSecretFlags]) -> IO (Bool, [SettingSecretFlags])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', [SettingSecretFlags]
outFlags'')

#if defined(ENABLE_OVERLOADING)
#endif

-- method VpnPluginOld::read_vpn_details
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "fd"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "file descriptor to read from, usually stdin (0)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_data"
--           , argType = TGHash (TBasicType TPtr) (TBasicType TPtr)
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "on successful return, a hash table\n(mapping char*:char*) containing the key/value pairs of VPN data items"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "out_secrets"
--           , argType = TGHash (TBasicType TPtr) (TBasicType TPtr)
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "on successful return, a hash table\n(mapping char*:char*) containing the key/value pairsof VPN secrets"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "nm_vpn_plugin_old_read_vpn_details" nm_vpn_plugin_old_read_vpn_details :: 
    Int32 ->                                -- fd : TBasicType TInt
    Ptr (Ptr (GHashTable (Ptr ()) (Ptr ()))) -> -- out_data : TGHash (TBasicType TPtr) (TBasicType TPtr)
    Ptr (Ptr (GHashTable (Ptr ()) (Ptr ()))) -> -- out_secrets : TGHash (TBasicType TPtr) (TBasicType TPtr)
    IO CInt

{-# DEPRECATED vpnPluginOldReadVpnDetails ["(Since version 1.2)","Replaced by NMVpnServicePlugin."] #-}
-- | Parses key\/value pairs from a file descriptor (normally stdin) passed by
-- an applet when the applet calls the authentication dialog of the VPN plugin.
vpnPluginOldReadVpnDetails ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Int32
    -- ^ /@fd@/: file descriptor to read from, usually stdin (0)
    -> m ((Bool, Map.Map (Ptr ()) (Ptr ()), Map.Map (Ptr ()) (Ptr ())))
    -- ^ __Returns:__ 'P.True' if reading values was successful, 'P.False' if not
vpnPluginOldReadVpnDetails :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Int32 -> m (Bool, Map (Ptr ()) (Ptr ()), Map (Ptr ()) (Ptr ()))
vpnPluginOldReadVpnDetails Int32
fd = IO (Bool, Map (Ptr ()) (Ptr ()), Map (Ptr ()) (Ptr ()))
-> m (Bool, Map (Ptr ()) (Ptr ()), Map (Ptr ()) (Ptr ()))
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Map (Ptr ()) (Ptr ()), Map (Ptr ()) (Ptr ()))
 -> m (Bool, Map (Ptr ()) (Ptr ()), Map (Ptr ()) (Ptr ())))
-> IO (Bool, Map (Ptr ()) (Ptr ()), Map (Ptr ()) (Ptr ()))
-> m (Bool, Map (Ptr ()) (Ptr ()), Map (Ptr ()) (Ptr ()))
forall a b. (a -> b) -> a -> b
$ do
    Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
outData <- IO (Ptr (Ptr (GHashTable (Ptr ()) (Ptr ()))))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr (GHashTable (Ptr ()) (Ptr ()))))
    Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
outSecrets <- IO (Ptr (Ptr (GHashTable (Ptr ()) (Ptr ()))))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr (GHashTable (Ptr ()) (Ptr ()))))
    CInt
result <- Int32
-> Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
-> Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
-> IO CInt
nm_vpn_plugin_old_read_vpn_details Int32
fd Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
outData Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
outSecrets
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Ptr (GHashTable (Ptr ()) (Ptr ()))
outData' <- Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
-> IO (Ptr (GHashTable (Ptr ()) (Ptr ())))
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
outData
    [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
outData'' <- Ptr (GHashTable (Ptr ()) (Ptr ()))
-> IO [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable (Ptr ()) (Ptr ()))
outData'
    let outData''' :: [(Ptr (), PtrWrapped (Ptr ()))]
outData''' = (PtrWrapped (Ptr ()) -> Ptr ())
-> [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
-> [(Ptr (), PtrWrapped (Ptr ()))]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped (Ptr ()) -> Ptr ()
forall a. PtrWrapped (Ptr a) -> Ptr a
B.GHT.ptrUnpackPtr [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
outData''
    let outData'''' :: [(Ptr (), Ptr ())]
outData'''' = (PtrWrapped (Ptr ()) -> Ptr ())
-> [(Ptr (), PtrWrapped (Ptr ()))] -> [(Ptr (), Ptr ())]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped (Ptr ()) -> Ptr ()
forall a. PtrWrapped (Ptr a) -> Ptr a
B.GHT.ptrUnpackPtr [(Ptr (), PtrWrapped (Ptr ()))]
outData'''
    let outData''''' :: Map (Ptr ()) (Ptr ())
outData''''' = [(Ptr (), Ptr ())] -> Map (Ptr ()) (Ptr ())
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Ptr (), Ptr ())]
outData''''
    Ptr (GHashTable (Ptr ()) (Ptr ())) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable (Ptr ()) (Ptr ()))
outData'
    Ptr (GHashTable (Ptr ()) (Ptr ()))
outSecrets' <- Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
-> IO (Ptr (GHashTable (Ptr ()) (Ptr ())))
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
outSecrets
    [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
outSecrets'' <- Ptr (GHashTable (Ptr ()) (Ptr ()))
-> IO [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable (Ptr ()) (Ptr ()))
outSecrets'
    let outSecrets''' :: [(Ptr (), PtrWrapped (Ptr ()))]
outSecrets''' = (PtrWrapped (Ptr ()) -> Ptr ())
-> [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
-> [(Ptr (), PtrWrapped (Ptr ()))]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped (Ptr ()) -> Ptr ()
forall a. PtrWrapped (Ptr a) -> Ptr a
B.GHT.ptrUnpackPtr [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
outSecrets''
    let outSecrets'''' :: [(Ptr (), Ptr ())]
outSecrets'''' = (PtrWrapped (Ptr ()) -> Ptr ())
-> [(Ptr (), PtrWrapped (Ptr ()))] -> [(Ptr (), Ptr ())]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped (Ptr ()) -> Ptr ()
forall a. PtrWrapped (Ptr a) -> Ptr a
B.GHT.ptrUnpackPtr [(Ptr (), PtrWrapped (Ptr ()))]
outSecrets'''
    let outSecrets''''' :: Map (Ptr ()) (Ptr ())
outSecrets''''' = [(Ptr (), Ptr ())] -> Map (Ptr ()) (Ptr ())
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Ptr (), Ptr ())]
outSecrets''''
    Ptr (GHashTable (Ptr ()) (Ptr ())) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable (Ptr ()) (Ptr ()))
outSecrets'
    Ptr (Ptr (GHashTable (Ptr ()) (Ptr ()))) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
outData
    Ptr (Ptr (GHashTable (Ptr ()) (Ptr ()))) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
outSecrets
    (Bool, Map (Ptr ()) (Ptr ()), Map (Ptr ()) (Ptr ()))
-> IO (Bool, Map (Ptr ()) (Ptr ()), Map (Ptr ()) (Ptr ()))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Map (Ptr ()) (Ptr ())
outData''''', Map (Ptr ()) (Ptr ())
outSecrets''''')

#if defined(ENABLE_OVERLOADING)
#endif