{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Point-to-Point Protocol Settings

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

module GI.NM.Objects.SettingPpp
    ( 

-- * Exported types
    SettingPpp(..)                          ,
    IsSettingPpp                            ,
    toSettingPpp                            ,


 -- * 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"), [compare]("GI.NM.Objects.Setting#g:method:compare"), [diff]("GI.NM.Objects.Setting#g:method:diff"), [duplicate]("GI.NM.Objects.Setting#g:method:duplicate"), [enumerateValues]("GI.NM.Objects.Setting#g:method:enumerateValues"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [optionClearByName]("GI.NM.Objects.Setting#g:method:optionClearByName"), [optionGet]("GI.NM.Objects.Setting#g:method:optionGet"), [optionGetAllNames]("GI.NM.Objects.Setting#g:method:optionGetAllNames"), [optionGetBoolean]("GI.NM.Objects.Setting#g:method:optionGetBoolean"), [optionGetUint32]("GI.NM.Objects.Setting#g:method:optionGetUint32"), [optionSet]("GI.NM.Objects.Setting#g:method:optionSet"), [optionSetBoolean]("GI.NM.Objects.Setting#g:method:optionSetBoolean"), [optionSetUint32]("GI.NM.Objects.Setting#g:method:optionSetUint32"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [toString]("GI.NM.Objects.Setting#g:method:toString"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [verify]("GI.NM.Objects.Setting#g:method:verify"), [verifySecrets]("GI.NM.Objects.Setting#g:method:verifySecrets"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getBaud]("GI.NM.Objects.SettingPpp#g:method:getBaud"), [getCrtscts]("GI.NM.Objects.SettingPpp#g:method:getCrtscts"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDbusPropertyType]("GI.NM.Objects.Setting#g:method:getDbusPropertyType"), [getLcpEchoFailure]("GI.NM.Objects.SettingPpp#g:method:getLcpEchoFailure"), [getLcpEchoInterval]("GI.NM.Objects.SettingPpp#g:method:getLcpEchoInterval"), [getMppeStateful]("GI.NM.Objects.SettingPpp#g:method:getMppeStateful"), [getMru]("GI.NM.Objects.SettingPpp#g:method:getMru"), [getMtu]("GI.NM.Objects.SettingPpp#g:method:getMtu"), [getName]("GI.NM.Objects.Setting#g:method:getName"), [getNoVjComp]("GI.NM.Objects.SettingPpp#g:method:getNoVjComp"), [getNoauth]("GI.NM.Objects.SettingPpp#g:method:getNoauth"), [getNobsdcomp]("GI.NM.Objects.SettingPpp#g:method:getNobsdcomp"), [getNodeflate]("GI.NM.Objects.SettingPpp#g:method:getNodeflate"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRefuseChap]("GI.NM.Objects.SettingPpp#g:method:getRefuseChap"), [getRefuseEap]("GI.NM.Objects.SettingPpp#g:method:getRefuseEap"), [getRefuseMschap]("GI.NM.Objects.SettingPpp#g:method:getRefuseMschap"), [getRefuseMschapv2]("GI.NM.Objects.SettingPpp#g:method:getRefuseMschapv2"), [getRefusePap]("GI.NM.Objects.SettingPpp#g:method:getRefusePap"), [getRequireMppe]("GI.NM.Objects.SettingPpp#g:method:getRequireMppe"), [getRequireMppe128]("GI.NM.Objects.SettingPpp#g:method:getRequireMppe128"), [getSecretFlags]("GI.NM.Objects.Setting#g:method:getSecretFlags").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setSecretFlags]("GI.NM.Objects.Setting#g:method:setSecretFlags").

#if defined(ENABLE_OVERLOADING)
    ResolveSettingPppMethod                 ,
#endif

-- ** getBaud #method:getBaud#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetBaudMethodInfo             ,
#endif
    settingPppGetBaud                       ,


-- ** getCrtscts #method:getCrtscts#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetCrtsctsMethodInfo          ,
#endif
    settingPppGetCrtscts                    ,


-- ** getLcpEchoFailure #method:getLcpEchoFailure#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetLcpEchoFailureMethodInfo   ,
#endif
    settingPppGetLcpEchoFailure             ,


-- ** getLcpEchoInterval #method:getLcpEchoInterval#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetLcpEchoIntervalMethodInfo  ,
#endif
    settingPppGetLcpEchoInterval            ,


-- ** getMppeStateful #method:getMppeStateful#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetMppeStatefulMethodInfo     ,
#endif
    settingPppGetMppeStateful               ,


-- ** getMru #method:getMru#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetMruMethodInfo              ,
#endif
    settingPppGetMru                        ,


-- ** getMtu #method:getMtu#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetMtuMethodInfo              ,
#endif
    settingPppGetMtu                        ,


-- ** getNoVjComp #method:getNoVjComp#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetNoVjCompMethodInfo         ,
#endif
    settingPppGetNoVjComp                   ,


-- ** getNoauth #method:getNoauth#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetNoauthMethodInfo           ,
#endif
    settingPppGetNoauth                     ,


-- ** getNobsdcomp #method:getNobsdcomp#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetNobsdcompMethodInfo        ,
#endif
    settingPppGetNobsdcomp                  ,


-- ** getNodeflate #method:getNodeflate#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetNodeflateMethodInfo        ,
#endif
    settingPppGetNodeflate                  ,


-- ** getRefuseChap #method:getRefuseChap#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetRefuseChapMethodInfo       ,
#endif
    settingPppGetRefuseChap                 ,


-- ** getRefuseEap #method:getRefuseEap#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetRefuseEapMethodInfo        ,
#endif
    settingPppGetRefuseEap                  ,


-- ** getRefuseMschap #method:getRefuseMschap#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetRefuseMschapMethodInfo     ,
#endif
    settingPppGetRefuseMschap               ,


-- ** getRefuseMschapv2 #method:getRefuseMschapv2#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetRefuseMschapv2MethodInfo   ,
#endif
    settingPppGetRefuseMschapv2             ,


-- ** getRefusePap #method:getRefusePap#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetRefusePapMethodInfo        ,
#endif
    settingPppGetRefusePap                  ,


-- ** getRequireMppe #method:getRequireMppe#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetRequireMppeMethodInfo      ,
#endif
    settingPppGetRequireMppe                ,


-- ** getRequireMppe128 #method:getRequireMppe128#

#if defined(ENABLE_OVERLOADING)
    SettingPppGetRequireMppe128MethodInfo   ,
#endif
    settingPppGetRequireMppe128             ,


-- ** new #method:new#

    settingPppNew                           ,




 -- * Properties


-- ** baud #attr:baud#
-- | If non-zero, instruct pppd to set the serial port to the specified
-- baudrate.  This value should normally be left as 0 to automatically
-- choose the speed.

#if defined(ENABLE_OVERLOADING)
    SettingPppBaudPropertyInfo              ,
#endif
    constructSettingPppBaud                 ,
    getSettingPppBaud                       ,
    setSettingPppBaud                       ,
#if defined(ENABLE_OVERLOADING)
    settingPppBaud                          ,
#endif


-- ** crtscts #attr:crtscts#
-- | If 'P.True', specify that pppd should set the serial port to use hardware
-- flow control with RTS and CTS signals.  This value should normally be set
-- to 'P.False'.

#if defined(ENABLE_OVERLOADING)
    SettingPppCrtsctsPropertyInfo           ,
#endif
    constructSettingPppCrtscts              ,
    getSettingPppCrtscts                    ,
    setSettingPppCrtscts                    ,
#if defined(ENABLE_OVERLOADING)
    settingPppCrtscts                       ,
#endif


-- ** lcpEchoFailure #attr:lcpEchoFailure#
-- | If non-zero, instruct pppd to presume the connection to the peer has
-- failed if the specified number of LCP echo-requests go unanswered by the
-- peer.  The \"lcp-echo-interval\" property must also be set to a non-zero
-- value if this property is used.

#if defined(ENABLE_OVERLOADING)
    SettingPppLcpEchoFailurePropertyInfo    ,
#endif
    constructSettingPppLcpEchoFailure       ,
    getSettingPppLcpEchoFailure             ,
    setSettingPppLcpEchoFailure             ,
#if defined(ENABLE_OVERLOADING)
    settingPppLcpEchoFailure                ,
#endif


-- ** lcpEchoInterval #attr:lcpEchoInterval#
-- | If non-zero, instruct pppd to send an LCP echo-request frame to the peer
-- every n seconds (where n is the specified value).  Note that some PPP
-- peers will respond to echo requests and some will not, and it is not
-- possible to autodetect this.

#if defined(ENABLE_OVERLOADING)
    SettingPppLcpEchoIntervalPropertyInfo   ,
#endif
    constructSettingPppLcpEchoInterval      ,
    getSettingPppLcpEchoInterval            ,
    setSettingPppLcpEchoInterval            ,
#if defined(ENABLE_OVERLOADING)
    settingPppLcpEchoInterval               ,
#endif


-- ** mppeStateful #attr:mppeStateful#
-- | If 'P.True', stateful MPPE is used.  See pppd documentation for more
-- information on stateful MPPE.

#if defined(ENABLE_OVERLOADING)
    SettingPppMppeStatefulPropertyInfo      ,
#endif
    constructSettingPppMppeStateful         ,
    getSettingPppMppeStateful               ,
    setSettingPppMppeStateful               ,
#if defined(ENABLE_OVERLOADING)
    settingPppMppeStateful                  ,
#endif


-- ** mru #attr:mru#
-- | If non-zero, instruct pppd to request that the peer send packets no
-- larger than the specified size.  If non-zero, the MRU should be between
-- 128 and 16384.

#if defined(ENABLE_OVERLOADING)
    SettingPppMruPropertyInfo               ,
#endif
    constructSettingPppMru                  ,
    getSettingPppMru                        ,
    setSettingPppMru                        ,
#if defined(ENABLE_OVERLOADING)
    settingPppMru                           ,
#endif


-- ** mtu #attr:mtu#
-- | If non-zero, instruct pppd to send packets no larger than the specified
-- size.

#if defined(ENABLE_OVERLOADING)
    SettingPppMtuPropertyInfo               ,
#endif
    constructSettingPppMtu                  ,
    getSettingPppMtu                        ,
    setSettingPppMtu                        ,
#if defined(ENABLE_OVERLOADING)
    settingPppMtu                           ,
#endif


-- ** noVjComp #attr:noVjComp#
-- | If 'P.True', Van Jacobsen TCP header compression will not be requested.

#if defined(ENABLE_OVERLOADING)
    SettingPppNoVjCompPropertyInfo          ,
#endif
    constructSettingPppNoVjComp             ,
    getSettingPppNoVjComp                   ,
    setSettingPppNoVjComp                   ,
#if defined(ENABLE_OVERLOADING)
    settingPppNoVjComp                      ,
#endif


-- ** noauth #attr:noauth#
-- | If 'P.True', do not require the other side (usually the PPP server) to
-- authenticate itself to the client.  If 'P.False', require authentication
-- from the remote side.  In almost all cases, this should be 'P.True'.

#if defined(ENABLE_OVERLOADING)
    SettingPppNoauthPropertyInfo            ,
#endif
    constructSettingPppNoauth               ,
    getSettingPppNoauth                     ,
    setSettingPppNoauth                     ,
#if defined(ENABLE_OVERLOADING)
    settingPppNoauth                        ,
#endif


-- ** nobsdcomp #attr:nobsdcomp#
-- | If 'P.True', BSD compression will not be requested.

#if defined(ENABLE_OVERLOADING)
    SettingPppNobsdcompPropertyInfo         ,
#endif
    constructSettingPppNobsdcomp            ,
    getSettingPppNobsdcomp                  ,
    setSettingPppNobsdcomp                  ,
#if defined(ENABLE_OVERLOADING)
    settingPppNobsdcomp                     ,
#endif


-- ** nodeflate #attr:nodeflate#
-- | If 'P.True', \"deflate\" compression will not be requested.

#if defined(ENABLE_OVERLOADING)
    SettingPppNodeflatePropertyInfo         ,
#endif
    constructSettingPppNodeflate            ,
    getSettingPppNodeflate                  ,
    setSettingPppNodeflate                  ,
#if defined(ENABLE_OVERLOADING)
    settingPppNodeflate                     ,
#endif


-- ** refuseChap #attr:refuseChap#
-- | If 'P.True', the CHAP authentication method will not be used.

#if defined(ENABLE_OVERLOADING)
    SettingPppRefuseChapPropertyInfo        ,
#endif
    constructSettingPppRefuseChap           ,
    getSettingPppRefuseChap                 ,
    setSettingPppRefuseChap                 ,
#if defined(ENABLE_OVERLOADING)
    settingPppRefuseChap                    ,
#endif


-- ** refuseEap #attr:refuseEap#
-- | If 'P.True', the EAP authentication method will not be used.

#if defined(ENABLE_OVERLOADING)
    SettingPppRefuseEapPropertyInfo         ,
#endif
    constructSettingPppRefuseEap            ,
    getSettingPppRefuseEap                  ,
    setSettingPppRefuseEap                  ,
#if defined(ENABLE_OVERLOADING)
    settingPppRefuseEap                     ,
#endif


-- ** refuseMschap #attr:refuseMschap#
-- | If 'P.True', the MSCHAP authentication method will not be used.

#if defined(ENABLE_OVERLOADING)
    SettingPppRefuseMschapPropertyInfo      ,
#endif
    constructSettingPppRefuseMschap         ,
    getSettingPppRefuseMschap               ,
    setSettingPppRefuseMschap               ,
#if defined(ENABLE_OVERLOADING)
    settingPppRefuseMschap                  ,
#endif


-- ** refuseMschapv2 #attr:refuseMschapv2#
-- | If 'P.True', the MSCHAPv2 authentication method will not be used.

#if defined(ENABLE_OVERLOADING)
    SettingPppRefuseMschapv2PropertyInfo    ,
#endif
    constructSettingPppRefuseMschapv2       ,
    getSettingPppRefuseMschapv2             ,
    setSettingPppRefuseMschapv2             ,
#if defined(ENABLE_OVERLOADING)
    settingPppRefuseMschapv2                ,
#endif


-- ** refusePap #attr:refusePap#
-- | If 'P.True', the PAP authentication method will not be used.

#if defined(ENABLE_OVERLOADING)
    SettingPppRefusePapPropertyInfo         ,
#endif
    constructSettingPppRefusePap            ,
    getSettingPppRefusePap                  ,
    setSettingPppRefusePap                  ,
#if defined(ENABLE_OVERLOADING)
    settingPppRefusePap                     ,
#endif


-- ** requireMppe #attr:requireMppe#
-- | If 'P.True', MPPE (Microsoft Point-to-Point Encryption) will be required for
-- the PPP session.  If either 64-bit or 128-bit MPPE is not available the
-- session will fail.  Note that MPPE is not used on mobile broadband
-- connections.

#if defined(ENABLE_OVERLOADING)
    SettingPppRequireMppePropertyInfo       ,
#endif
    constructSettingPppRequireMppe          ,
    getSettingPppRequireMppe                ,
    setSettingPppRequireMppe                ,
#if defined(ENABLE_OVERLOADING)
    settingPppRequireMppe                   ,
#endif


-- ** requireMppe128 #attr:requireMppe128#
-- | If 'P.True', 128-bit MPPE (Microsoft Point-to-Point Encryption) will be
-- required for the PPP session, and the \"require-mppe\" property must also
-- be set to 'P.True'.  If 128-bit MPPE is not available the session will fail.

#if defined(ENABLE_OVERLOADING)
    SettingPppRequireMppe128PropertyInfo    ,
#endif
    constructSettingPppRequireMppe128       ,
    getSettingPppRequireMppe128             ,
    setSettingPppRequireMppe128             ,
#if defined(ENABLE_OVERLOADING)
    settingPppRequireMppe128                ,
#endif




    ) 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.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.VariantType as GLib.VariantType
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.NM.Callbacks as NM.Callbacks
import {-# SOURCE #-} qualified GI.NM.Enums as NM.Enums
import {-# SOURCE #-} qualified GI.NM.Flags as NM.Flags
import {-# SOURCE #-} qualified GI.NM.Interfaces.Connection as NM.Connection
import {-# SOURCE #-} qualified GI.NM.Objects.Setting as NM.Setting
import {-# SOURCE #-} qualified GI.NM.Objects.Setting8021x as NM.Setting8021x
import {-# SOURCE #-} qualified GI.NM.Objects.SettingAdsl as NM.SettingAdsl
import {-# SOURCE #-} qualified GI.NM.Objects.SettingBluetooth as NM.SettingBluetooth
import {-# SOURCE #-} qualified GI.NM.Objects.SettingBond as NM.SettingBond
import {-# SOURCE #-} qualified GI.NM.Objects.SettingBridge as NM.SettingBridge
import {-# SOURCE #-} qualified GI.NM.Objects.SettingBridgePort as NM.SettingBridgePort
import {-# SOURCE #-} qualified GI.NM.Objects.SettingCdma as NM.SettingCdma
import {-# SOURCE #-} qualified GI.NM.Objects.SettingConnection as NM.SettingConnection
import {-# SOURCE #-} qualified GI.NM.Objects.SettingDcb as NM.SettingDcb
import {-# SOURCE #-} qualified GI.NM.Objects.SettingDummy as NM.SettingDummy
import {-# SOURCE #-} qualified GI.NM.Objects.SettingGeneric as NM.SettingGeneric
import {-# SOURCE #-} qualified GI.NM.Objects.SettingGsm as NM.SettingGsm
import {-# SOURCE #-} qualified GI.NM.Objects.SettingIP4Config as NM.SettingIP4Config
import {-# SOURCE #-} qualified GI.NM.Objects.SettingIP6Config as NM.SettingIP6Config
import {-# SOURCE #-} qualified GI.NM.Objects.SettingIPConfig as NM.SettingIPConfig
import {-# SOURCE #-} qualified GI.NM.Objects.SettingIPTunnel as NM.SettingIPTunnel
import {-# SOURCE #-} qualified GI.NM.Objects.SettingInfiniband as NM.SettingInfiniband
import {-# SOURCE #-} qualified GI.NM.Objects.SettingMacsec as NM.SettingMacsec
import {-# SOURCE #-} qualified GI.NM.Objects.SettingMacvlan as NM.SettingMacvlan
import {-# SOURCE #-} qualified GI.NM.Objects.SettingOlpcMesh as NM.SettingOlpcMesh
import {-# SOURCE #-} qualified GI.NM.Objects.SettingOvsBridge as NM.SettingOvsBridge
import {-# SOURCE #-} qualified GI.NM.Objects.SettingOvsInterface as NM.SettingOvsInterface
import {-# SOURCE #-} qualified GI.NM.Objects.SettingOvsPatch as NM.SettingOvsPatch
import {-# SOURCE #-} qualified GI.NM.Objects.SettingOvsPort as NM.SettingOvsPort
import {-# SOURCE #-} qualified GI.NM.Objects.SettingPppoe as NM.SettingPppoe
import {-# SOURCE #-} qualified GI.NM.Objects.SettingProxy as NM.SettingProxy
import {-# SOURCE #-} qualified GI.NM.Objects.SettingSerial as NM.SettingSerial
import {-# SOURCE #-} qualified GI.NM.Objects.SettingTCConfig as NM.SettingTCConfig
import {-# SOURCE #-} qualified GI.NM.Objects.SettingTeam as NM.SettingTeam
import {-# SOURCE #-} qualified GI.NM.Objects.SettingTeamPort as NM.SettingTeamPort
import {-# SOURCE #-} qualified GI.NM.Objects.SettingTun as NM.SettingTun
import {-# SOURCE #-} qualified GI.NM.Objects.SettingVlan as NM.SettingVlan
import {-# SOURCE #-} qualified GI.NM.Objects.SettingVpn as NM.SettingVpn
import {-# SOURCE #-} qualified GI.NM.Objects.SettingVxlan as NM.SettingVxlan
import {-# SOURCE #-} qualified GI.NM.Objects.SettingWimax as NM.SettingWimax
import {-# SOURCE #-} qualified GI.NM.Objects.SettingWired as NM.SettingWired
import {-# SOURCE #-} qualified GI.NM.Objects.SettingWireless as NM.SettingWireless
import {-# SOURCE #-} qualified GI.NM.Objects.SettingWirelessSecurity as NM.SettingWirelessSecurity
import {-# SOURCE #-} qualified GI.NM.Structs.BridgeVlan as NM.BridgeVlan
import {-# SOURCE #-} qualified GI.NM.Structs.IPAddress as NM.IPAddress
import {-# SOURCE #-} qualified GI.NM.Structs.IPRoute as NM.IPRoute
import {-# SOURCE #-} qualified GI.NM.Structs.IPRoutingRule as NM.IPRoutingRule
import {-# SOURCE #-} qualified GI.NM.Structs.Range as NM.Range
import {-# SOURCE #-} qualified GI.NM.Structs.TCAction as NM.TCAction
import {-# SOURCE #-} qualified GI.NM.Structs.TCQdisc as NM.TCQdisc
import {-# SOURCE #-} qualified GI.NM.Structs.TCTfilter as NM.TCTfilter
import {-# SOURCE #-} qualified GI.NM.Structs.TeamLinkWatcher as NM.TeamLinkWatcher
import {-# SOURCE #-} qualified GI.NM.Structs.VariantAttributeSpec as NM.VariantAttributeSpec

#else
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.NM.Objects.Setting as NM.Setting

#endif

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

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

foreign import ccall "nm_setting_ppp_get_type"
    c_nm_setting_ppp_get_type :: IO B.Types.GType

instance B.Types.TypedObject SettingPpp where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_ppp_get_type

instance B.Types.GObject SettingPpp

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

instance O.HasParentTypes SettingPpp
type instance O.ParentTypes SettingPpp = '[NM.Setting.Setting, GObject.Object.Object]

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

-- | Convert t'SettingPpp' 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 SettingPpp) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_nm_setting_ppp_get_type
    gvalueSet_ :: Ptr GValue -> Maybe SettingPpp -> IO ()
gvalueSet_ Ptr GValue
gv Maybe SettingPpp
P.Nothing = Ptr GValue -> Ptr SettingPpp -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr SettingPpp
forall a. Ptr a
FP.nullPtr :: FP.Ptr SettingPpp)
    gvalueSet_ Ptr GValue
gv (P.Just SettingPpp
obj) = SettingPpp -> (Ptr SettingPpp -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SettingPpp
obj (Ptr GValue -> Ptr SettingPpp -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe SettingPpp)
gvalueGet_ Ptr GValue
gv = do
        Ptr SettingPpp
ptr <- Ptr GValue -> IO (Ptr SettingPpp)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr SettingPpp)
        if Ptr SettingPpp
ptr Ptr SettingPpp -> Ptr SettingPpp -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr SettingPpp
forall a. Ptr a
FP.nullPtr
        then SettingPpp -> Maybe SettingPpp
forall a. a -> Maybe a
P.Just (SettingPpp -> Maybe SettingPpp)
-> IO SettingPpp -> IO (Maybe SettingPpp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr SettingPpp -> SettingPpp)
-> Ptr SettingPpp -> IO SettingPpp
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr SettingPpp -> SettingPpp
SettingPpp Ptr SettingPpp
ptr
        else Maybe SettingPpp -> IO (Maybe SettingPpp)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SettingPpp
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveSettingPppMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveSettingPppMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveSettingPppMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveSettingPppMethod "compare" o = NM.Setting.SettingCompareMethodInfo
    ResolveSettingPppMethod "diff" o = NM.Setting.SettingDiffMethodInfo
    ResolveSettingPppMethod "duplicate" o = NM.Setting.SettingDuplicateMethodInfo
    ResolveSettingPppMethod "enumerateValues" o = NM.Setting.SettingEnumerateValuesMethodInfo
    ResolveSettingPppMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveSettingPppMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveSettingPppMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveSettingPppMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveSettingPppMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveSettingPppMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveSettingPppMethod "optionClearByName" o = NM.Setting.SettingOptionClearByNameMethodInfo
    ResolveSettingPppMethod "optionGet" o = NM.Setting.SettingOptionGetMethodInfo
    ResolveSettingPppMethod "optionGetAllNames" o = NM.Setting.SettingOptionGetAllNamesMethodInfo
    ResolveSettingPppMethod "optionGetBoolean" o = NM.Setting.SettingOptionGetBooleanMethodInfo
    ResolveSettingPppMethod "optionGetUint32" o = NM.Setting.SettingOptionGetUint32MethodInfo
    ResolveSettingPppMethod "optionSet" o = NM.Setting.SettingOptionSetMethodInfo
    ResolveSettingPppMethod "optionSetBoolean" o = NM.Setting.SettingOptionSetBooleanMethodInfo
    ResolveSettingPppMethod "optionSetUint32" o = NM.Setting.SettingOptionSetUint32MethodInfo
    ResolveSettingPppMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveSettingPppMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveSettingPppMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveSettingPppMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveSettingPppMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveSettingPppMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveSettingPppMethod "toString" o = NM.Setting.SettingToStringMethodInfo
    ResolveSettingPppMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveSettingPppMethod "verify" o = NM.Setting.SettingVerifyMethodInfo
    ResolveSettingPppMethod "verifySecrets" o = NM.Setting.SettingVerifySecretsMethodInfo
    ResolveSettingPppMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveSettingPppMethod "getBaud" o = SettingPppGetBaudMethodInfo
    ResolveSettingPppMethod "getCrtscts" o = SettingPppGetCrtsctsMethodInfo
    ResolveSettingPppMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveSettingPppMethod "getDbusPropertyType" o = NM.Setting.SettingGetDbusPropertyTypeMethodInfo
    ResolveSettingPppMethod "getLcpEchoFailure" o = SettingPppGetLcpEchoFailureMethodInfo
    ResolveSettingPppMethod "getLcpEchoInterval" o = SettingPppGetLcpEchoIntervalMethodInfo
    ResolveSettingPppMethod "getMppeStateful" o = SettingPppGetMppeStatefulMethodInfo
    ResolveSettingPppMethod "getMru" o = SettingPppGetMruMethodInfo
    ResolveSettingPppMethod "getMtu" o = SettingPppGetMtuMethodInfo
    ResolveSettingPppMethod "getName" o = NM.Setting.SettingGetNameMethodInfo
    ResolveSettingPppMethod "getNoVjComp" o = SettingPppGetNoVjCompMethodInfo
    ResolveSettingPppMethod "getNoauth" o = SettingPppGetNoauthMethodInfo
    ResolveSettingPppMethod "getNobsdcomp" o = SettingPppGetNobsdcompMethodInfo
    ResolveSettingPppMethod "getNodeflate" o = SettingPppGetNodeflateMethodInfo
    ResolveSettingPppMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveSettingPppMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveSettingPppMethod "getRefuseChap" o = SettingPppGetRefuseChapMethodInfo
    ResolveSettingPppMethod "getRefuseEap" o = SettingPppGetRefuseEapMethodInfo
    ResolveSettingPppMethod "getRefuseMschap" o = SettingPppGetRefuseMschapMethodInfo
    ResolveSettingPppMethod "getRefuseMschapv2" o = SettingPppGetRefuseMschapv2MethodInfo
    ResolveSettingPppMethod "getRefusePap" o = SettingPppGetRefusePapMethodInfo
    ResolveSettingPppMethod "getRequireMppe" o = SettingPppGetRequireMppeMethodInfo
    ResolveSettingPppMethod "getRequireMppe128" o = SettingPppGetRequireMppe128MethodInfo
    ResolveSettingPppMethod "getSecretFlags" o = NM.Setting.SettingGetSecretFlagsMethodInfo
    ResolveSettingPppMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveSettingPppMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveSettingPppMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveSettingPppMethod "setSecretFlags" o = NM.Setting.SettingSetSecretFlagsMethodInfo
    ResolveSettingPppMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveSettingPppMethod t SettingPpp, O.OverloadedMethod info SettingPpp p) => OL.IsLabel t (SettingPpp -> 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 ~ ResolveSettingPppMethod t SettingPpp, O.OverloadedMethod info SettingPpp p, R.HasField t SettingPpp p) => R.HasField t SettingPpp p where
    getField = O.overloadedMethod @info

#endif

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

#endif

-- VVV Prop "baud"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@baud@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #baud
-- @
getSettingPppBaud :: (MonadIO m, IsSettingPpp o) => o -> m Word32
getSettingPppBaud :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> m Word32
getSettingPppBaud o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"baud"

-- | Set the value of the “@baud@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #baud 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppBaud :: (MonadIO m, IsSettingPpp o) => o -> Word32 -> m ()
setSettingPppBaud :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Word32 -> m ()
setSettingPppBaud o
obj Word32
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 -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"baud" Word32
val

-- | Construct a t'GValueConstruct' with valid value for the “@baud@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppBaud :: (IsSettingPpp o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructSettingPppBaud :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructSettingPppBaud Word32
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 -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"baud" Word32
val

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

-- VVV Prop "crtscts"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@crtscts@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #crtscts
-- @
getSettingPppCrtscts :: (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppCrtscts :: forall (m :: * -> *) o. (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppCrtscts o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"crtscts"

-- | Set the value of the “@crtscts@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #crtscts 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppCrtscts :: (MonadIO m, IsSettingPpp o) => o -> Bool -> m ()
setSettingPppCrtscts :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Bool -> m ()
setSettingPppCrtscts o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"crtscts" Bool
val

-- | Construct a t'GValueConstruct' with valid value for the “@crtscts@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppCrtscts :: (IsSettingPpp o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSettingPppCrtscts :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSettingPppCrtscts Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"crtscts" Bool
val

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

-- VVV Prop "lcp-echo-failure"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@lcp-echo-failure@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #lcpEchoFailure
-- @
getSettingPppLcpEchoFailure :: (MonadIO m, IsSettingPpp o) => o -> m Word32
getSettingPppLcpEchoFailure :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> m Word32
getSettingPppLcpEchoFailure o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"lcp-echo-failure"

-- | Set the value of the “@lcp-echo-failure@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #lcpEchoFailure 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppLcpEchoFailure :: (MonadIO m, IsSettingPpp o) => o -> Word32 -> m ()
setSettingPppLcpEchoFailure :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Word32 -> m ()
setSettingPppLcpEchoFailure o
obj Word32
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 -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"lcp-echo-failure" Word32
val

-- | Construct a t'GValueConstruct' with valid value for the “@lcp-echo-failure@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppLcpEchoFailure :: (IsSettingPpp o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructSettingPppLcpEchoFailure :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructSettingPppLcpEchoFailure Word32
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 -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"lcp-echo-failure" Word32
val

#if defined(ENABLE_OVERLOADING)
data SettingPppLcpEchoFailurePropertyInfo
instance AttrInfo SettingPppLcpEchoFailurePropertyInfo where
    type AttrAllowedOps SettingPppLcpEchoFailurePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SettingPppLcpEchoFailurePropertyInfo = IsSettingPpp
    type AttrSetTypeConstraint SettingPppLcpEchoFailurePropertyInfo = (~) Word32
    type AttrTransferTypeConstraint SettingPppLcpEchoFailurePropertyInfo = (~) Word32
    type AttrTransferType SettingPppLcpEchoFailurePropertyInfo = Word32
    type AttrGetType SettingPppLcpEchoFailurePropertyInfo = Word32
    type AttrLabel SettingPppLcpEchoFailurePropertyInfo = "lcp-echo-failure"
    type AttrOrigin SettingPppLcpEchoFailurePropertyInfo = SettingPpp
    attrGet = getSettingPppLcpEchoFailure
    attrSet = setSettingPppLcpEchoFailure
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingPppLcpEchoFailure
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingPpp.lcpEchoFailure"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingPpp.html#g:attr:lcpEchoFailure"
        })
#endif

-- VVV Prop "lcp-echo-interval"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@lcp-echo-interval@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #lcpEchoInterval
-- @
getSettingPppLcpEchoInterval :: (MonadIO m, IsSettingPpp o) => o -> m Word32
getSettingPppLcpEchoInterval :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> m Word32
getSettingPppLcpEchoInterval o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"lcp-echo-interval"

-- | Set the value of the “@lcp-echo-interval@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #lcpEchoInterval 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppLcpEchoInterval :: (MonadIO m, IsSettingPpp o) => o -> Word32 -> m ()
setSettingPppLcpEchoInterval :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Word32 -> m ()
setSettingPppLcpEchoInterval o
obj Word32
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 -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"lcp-echo-interval" Word32
val

-- | Construct a t'GValueConstruct' with valid value for the “@lcp-echo-interval@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppLcpEchoInterval :: (IsSettingPpp o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructSettingPppLcpEchoInterval :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructSettingPppLcpEchoInterval Word32
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 -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"lcp-echo-interval" Word32
val

#if defined(ENABLE_OVERLOADING)
data SettingPppLcpEchoIntervalPropertyInfo
instance AttrInfo SettingPppLcpEchoIntervalPropertyInfo where
    type AttrAllowedOps SettingPppLcpEchoIntervalPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SettingPppLcpEchoIntervalPropertyInfo = IsSettingPpp
    type AttrSetTypeConstraint SettingPppLcpEchoIntervalPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint SettingPppLcpEchoIntervalPropertyInfo = (~) Word32
    type AttrTransferType SettingPppLcpEchoIntervalPropertyInfo = Word32
    type AttrGetType SettingPppLcpEchoIntervalPropertyInfo = Word32
    type AttrLabel SettingPppLcpEchoIntervalPropertyInfo = "lcp-echo-interval"
    type AttrOrigin SettingPppLcpEchoIntervalPropertyInfo = SettingPpp
    attrGet = getSettingPppLcpEchoInterval
    attrSet = setSettingPppLcpEchoInterval
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingPppLcpEchoInterval
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingPpp.lcpEchoInterval"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingPpp.html#g:attr:lcpEchoInterval"
        })
#endif

-- VVV Prop "mppe-stateful"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@mppe-stateful@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #mppeStateful
-- @
getSettingPppMppeStateful :: (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppMppeStateful :: forall (m :: * -> *) o. (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppMppeStateful o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"mppe-stateful"

-- | Set the value of the “@mppe-stateful@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #mppeStateful 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppMppeStateful :: (MonadIO m, IsSettingPpp o) => o -> Bool -> m ()
setSettingPppMppeStateful :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Bool -> m ()
setSettingPppMppeStateful o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"mppe-stateful" Bool
val

-- | Construct a t'GValueConstruct' with valid value for the “@mppe-stateful@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppMppeStateful :: (IsSettingPpp o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSettingPppMppeStateful :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSettingPppMppeStateful Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"mppe-stateful" Bool
val

#if defined(ENABLE_OVERLOADING)
data SettingPppMppeStatefulPropertyInfo
instance AttrInfo SettingPppMppeStatefulPropertyInfo where
    type AttrAllowedOps SettingPppMppeStatefulPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SettingPppMppeStatefulPropertyInfo = IsSettingPpp
    type AttrSetTypeConstraint SettingPppMppeStatefulPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SettingPppMppeStatefulPropertyInfo = (~) Bool
    type AttrTransferType SettingPppMppeStatefulPropertyInfo = Bool
    type AttrGetType SettingPppMppeStatefulPropertyInfo = Bool
    type AttrLabel SettingPppMppeStatefulPropertyInfo = "mppe-stateful"
    type AttrOrigin SettingPppMppeStatefulPropertyInfo = SettingPpp
    attrGet = getSettingPppMppeStateful
    attrSet = setSettingPppMppeStateful
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingPppMppeStateful
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingPpp.mppeStateful"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingPpp.html#g:attr:mppeStateful"
        })
#endif

-- VVV Prop "mru"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@mru@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #mru
-- @
getSettingPppMru :: (MonadIO m, IsSettingPpp o) => o -> m Word32
getSettingPppMru :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> m Word32
getSettingPppMru o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"mru"

-- | Set the value of the “@mru@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #mru 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppMru :: (MonadIO m, IsSettingPpp o) => o -> Word32 -> m ()
setSettingPppMru :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Word32 -> m ()
setSettingPppMru o
obj Word32
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 -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"mru" Word32
val

-- | Construct a t'GValueConstruct' with valid value for the “@mru@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppMru :: (IsSettingPpp o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructSettingPppMru :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructSettingPppMru Word32
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 -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"mru" Word32
val

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

-- VVV Prop "mtu"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@mtu@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #mtu
-- @
getSettingPppMtu :: (MonadIO m, IsSettingPpp o) => o -> m Word32
getSettingPppMtu :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> m Word32
getSettingPppMtu o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"mtu"

-- | Set the value of the “@mtu@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #mtu 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppMtu :: (MonadIO m, IsSettingPpp o) => o -> Word32 -> m ()
setSettingPppMtu :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Word32 -> m ()
setSettingPppMtu o
obj Word32
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 -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"mtu" Word32
val

-- | Construct a t'GValueConstruct' with valid value for the “@mtu@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppMtu :: (IsSettingPpp o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructSettingPppMtu :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructSettingPppMtu Word32
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 -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"mtu" Word32
val

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

-- VVV Prop "no-vj-comp"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@no-vj-comp@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #noVjComp
-- @
getSettingPppNoVjComp :: (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppNoVjComp :: forall (m :: * -> *) o. (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppNoVjComp o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"no-vj-comp"

-- | Set the value of the “@no-vj-comp@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #noVjComp 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppNoVjComp :: (MonadIO m, IsSettingPpp o) => o -> Bool -> m ()
setSettingPppNoVjComp :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Bool -> m ()
setSettingPppNoVjComp o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"no-vj-comp" Bool
val

-- | Construct a t'GValueConstruct' with valid value for the “@no-vj-comp@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppNoVjComp :: (IsSettingPpp o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSettingPppNoVjComp :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSettingPppNoVjComp Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"no-vj-comp" Bool
val

#if defined(ENABLE_OVERLOADING)
data SettingPppNoVjCompPropertyInfo
instance AttrInfo SettingPppNoVjCompPropertyInfo where
    type AttrAllowedOps SettingPppNoVjCompPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SettingPppNoVjCompPropertyInfo = IsSettingPpp
    type AttrSetTypeConstraint SettingPppNoVjCompPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SettingPppNoVjCompPropertyInfo = (~) Bool
    type AttrTransferType SettingPppNoVjCompPropertyInfo = Bool
    type AttrGetType SettingPppNoVjCompPropertyInfo = Bool
    type AttrLabel SettingPppNoVjCompPropertyInfo = "no-vj-comp"
    type AttrOrigin SettingPppNoVjCompPropertyInfo = SettingPpp
    attrGet = getSettingPppNoVjComp
    attrSet = setSettingPppNoVjComp
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingPppNoVjComp
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingPpp.noVjComp"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingPpp.html#g:attr:noVjComp"
        })
#endif

-- VVV Prop "noauth"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@noauth@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #noauth
-- @
getSettingPppNoauth :: (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppNoauth :: forall (m :: * -> *) o. (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppNoauth o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"noauth"

-- | Set the value of the “@noauth@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #noauth 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppNoauth :: (MonadIO m, IsSettingPpp o) => o -> Bool -> m ()
setSettingPppNoauth :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Bool -> m ()
setSettingPppNoauth o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"noauth" Bool
val

-- | Construct a t'GValueConstruct' with valid value for the “@noauth@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppNoauth :: (IsSettingPpp o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSettingPppNoauth :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSettingPppNoauth Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"noauth" Bool
val

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

-- VVV Prop "nobsdcomp"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@nobsdcomp@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #nobsdcomp
-- @
getSettingPppNobsdcomp :: (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppNobsdcomp :: forall (m :: * -> *) o. (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppNobsdcomp o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"nobsdcomp"

-- | Set the value of the “@nobsdcomp@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #nobsdcomp 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppNobsdcomp :: (MonadIO m, IsSettingPpp o) => o -> Bool -> m ()
setSettingPppNobsdcomp :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Bool -> m ()
setSettingPppNobsdcomp o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"nobsdcomp" Bool
val

-- | Construct a t'GValueConstruct' with valid value for the “@nobsdcomp@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppNobsdcomp :: (IsSettingPpp o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSettingPppNobsdcomp :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSettingPppNobsdcomp Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"nobsdcomp" Bool
val

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

-- VVV Prop "nodeflate"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@nodeflate@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #nodeflate
-- @
getSettingPppNodeflate :: (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppNodeflate :: forall (m :: * -> *) o. (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppNodeflate o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"nodeflate"

-- | Set the value of the “@nodeflate@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #nodeflate 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppNodeflate :: (MonadIO m, IsSettingPpp o) => o -> Bool -> m ()
setSettingPppNodeflate :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Bool -> m ()
setSettingPppNodeflate o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"nodeflate" Bool
val

-- | Construct a t'GValueConstruct' with valid value for the “@nodeflate@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppNodeflate :: (IsSettingPpp o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSettingPppNodeflate :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSettingPppNodeflate Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"nodeflate" Bool
val

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

-- VVV Prop "refuse-chap"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@refuse-chap@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #refuseChap
-- @
getSettingPppRefuseChap :: (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppRefuseChap :: forall (m :: * -> *) o. (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppRefuseChap o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"refuse-chap"

-- | Set the value of the “@refuse-chap@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #refuseChap 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppRefuseChap :: (MonadIO m, IsSettingPpp o) => o -> Bool -> m ()
setSettingPppRefuseChap :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Bool -> m ()
setSettingPppRefuseChap o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"refuse-chap" Bool
val

-- | Construct a t'GValueConstruct' with valid value for the “@refuse-chap@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppRefuseChap :: (IsSettingPpp o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSettingPppRefuseChap :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSettingPppRefuseChap Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"refuse-chap" Bool
val

#if defined(ENABLE_OVERLOADING)
data SettingPppRefuseChapPropertyInfo
instance AttrInfo SettingPppRefuseChapPropertyInfo where
    type AttrAllowedOps SettingPppRefuseChapPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SettingPppRefuseChapPropertyInfo = IsSettingPpp
    type AttrSetTypeConstraint SettingPppRefuseChapPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SettingPppRefuseChapPropertyInfo = (~) Bool
    type AttrTransferType SettingPppRefuseChapPropertyInfo = Bool
    type AttrGetType SettingPppRefuseChapPropertyInfo = Bool
    type AttrLabel SettingPppRefuseChapPropertyInfo = "refuse-chap"
    type AttrOrigin SettingPppRefuseChapPropertyInfo = SettingPpp
    attrGet = getSettingPppRefuseChap
    attrSet = setSettingPppRefuseChap
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingPppRefuseChap
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingPpp.refuseChap"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingPpp.html#g:attr:refuseChap"
        })
#endif

-- VVV Prop "refuse-eap"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@refuse-eap@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #refuseEap
-- @
getSettingPppRefuseEap :: (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppRefuseEap :: forall (m :: * -> *) o. (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppRefuseEap o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"refuse-eap"

-- | Set the value of the “@refuse-eap@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #refuseEap 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppRefuseEap :: (MonadIO m, IsSettingPpp o) => o -> Bool -> m ()
setSettingPppRefuseEap :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Bool -> m ()
setSettingPppRefuseEap o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"refuse-eap" Bool
val

-- | Construct a t'GValueConstruct' with valid value for the “@refuse-eap@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppRefuseEap :: (IsSettingPpp o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSettingPppRefuseEap :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSettingPppRefuseEap Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"refuse-eap" Bool
val

#if defined(ENABLE_OVERLOADING)
data SettingPppRefuseEapPropertyInfo
instance AttrInfo SettingPppRefuseEapPropertyInfo where
    type AttrAllowedOps SettingPppRefuseEapPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SettingPppRefuseEapPropertyInfo = IsSettingPpp
    type AttrSetTypeConstraint SettingPppRefuseEapPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SettingPppRefuseEapPropertyInfo = (~) Bool
    type AttrTransferType SettingPppRefuseEapPropertyInfo = Bool
    type AttrGetType SettingPppRefuseEapPropertyInfo = Bool
    type AttrLabel SettingPppRefuseEapPropertyInfo = "refuse-eap"
    type AttrOrigin SettingPppRefuseEapPropertyInfo = SettingPpp
    attrGet = getSettingPppRefuseEap
    attrSet = setSettingPppRefuseEap
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingPppRefuseEap
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingPpp.refuseEap"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingPpp.html#g:attr:refuseEap"
        })
#endif

-- VVV Prop "refuse-mschap"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@refuse-mschap@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #refuseMschap
-- @
getSettingPppRefuseMschap :: (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppRefuseMschap :: forall (m :: * -> *) o. (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppRefuseMschap o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"refuse-mschap"

-- | Set the value of the “@refuse-mschap@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #refuseMschap 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppRefuseMschap :: (MonadIO m, IsSettingPpp o) => o -> Bool -> m ()
setSettingPppRefuseMschap :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Bool -> m ()
setSettingPppRefuseMschap o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"refuse-mschap" Bool
val

-- | Construct a t'GValueConstruct' with valid value for the “@refuse-mschap@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppRefuseMschap :: (IsSettingPpp o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSettingPppRefuseMschap :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSettingPppRefuseMschap Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"refuse-mschap" Bool
val

#if defined(ENABLE_OVERLOADING)
data SettingPppRefuseMschapPropertyInfo
instance AttrInfo SettingPppRefuseMschapPropertyInfo where
    type AttrAllowedOps SettingPppRefuseMschapPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SettingPppRefuseMschapPropertyInfo = IsSettingPpp
    type AttrSetTypeConstraint SettingPppRefuseMschapPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SettingPppRefuseMschapPropertyInfo = (~) Bool
    type AttrTransferType SettingPppRefuseMschapPropertyInfo = Bool
    type AttrGetType SettingPppRefuseMschapPropertyInfo = Bool
    type AttrLabel SettingPppRefuseMschapPropertyInfo = "refuse-mschap"
    type AttrOrigin SettingPppRefuseMschapPropertyInfo = SettingPpp
    attrGet = getSettingPppRefuseMschap
    attrSet = setSettingPppRefuseMschap
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingPppRefuseMschap
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingPpp.refuseMschap"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingPpp.html#g:attr:refuseMschap"
        })
#endif

-- VVV Prop "refuse-mschapv2"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@refuse-mschapv2@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #refuseMschapv2
-- @
getSettingPppRefuseMschapv2 :: (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppRefuseMschapv2 :: forall (m :: * -> *) o. (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppRefuseMschapv2 o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"refuse-mschapv2"

-- | Set the value of the “@refuse-mschapv2@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #refuseMschapv2 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppRefuseMschapv2 :: (MonadIO m, IsSettingPpp o) => o -> Bool -> m ()
setSettingPppRefuseMschapv2 :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Bool -> m ()
setSettingPppRefuseMschapv2 o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"refuse-mschapv2" Bool
val

-- | Construct a t'GValueConstruct' with valid value for the “@refuse-mschapv2@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppRefuseMschapv2 :: (IsSettingPpp o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSettingPppRefuseMschapv2 :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSettingPppRefuseMschapv2 Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"refuse-mschapv2" Bool
val

#if defined(ENABLE_OVERLOADING)
data SettingPppRefuseMschapv2PropertyInfo
instance AttrInfo SettingPppRefuseMschapv2PropertyInfo where
    type AttrAllowedOps SettingPppRefuseMschapv2PropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SettingPppRefuseMschapv2PropertyInfo = IsSettingPpp
    type AttrSetTypeConstraint SettingPppRefuseMschapv2PropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SettingPppRefuseMschapv2PropertyInfo = (~) Bool
    type AttrTransferType SettingPppRefuseMschapv2PropertyInfo = Bool
    type AttrGetType SettingPppRefuseMschapv2PropertyInfo = Bool
    type AttrLabel SettingPppRefuseMschapv2PropertyInfo = "refuse-mschapv2"
    type AttrOrigin SettingPppRefuseMschapv2PropertyInfo = SettingPpp
    attrGet = getSettingPppRefuseMschapv2
    attrSet = setSettingPppRefuseMschapv2
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingPppRefuseMschapv2
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingPpp.refuseMschapv2"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingPpp.html#g:attr:refuseMschapv2"
        })
#endif

-- VVV Prop "refuse-pap"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@refuse-pap@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #refusePap
-- @
getSettingPppRefusePap :: (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppRefusePap :: forall (m :: * -> *) o. (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppRefusePap o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"refuse-pap"

-- | Set the value of the “@refuse-pap@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #refusePap 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppRefusePap :: (MonadIO m, IsSettingPpp o) => o -> Bool -> m ()
setSettingPppRefusePap :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Bool -> m ()
setSettingPppRefusePap o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"refuse-pap" Bool
val

-- | Construct a t'GValueConstruct' with valid value for the “@refuse-pap@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppRefusePap :: (IsSettingPpp o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSettingPppRefusePap :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSettingPppRefusePap Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"refuse-pap" Bool
val

#if defined(ENABLE_OVERLOADING)
data SettingPppRefusePapPropertyInfo
instance AttrInfo SettingPppRefusePapPropertyInfo where
    type AttrAllowedOps SettingPppRefusePapPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SettingPppRefusePapPropertyInfo = IsSettingPpp
    type AttrSetTypeConstraint SettingPppRefusePapPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SettingPppRefusePapPropertyInfo = (~) Bool
    type AttrTransferType SettingPppRefusePapPropertyInfo = Bool
    type AttrGetType SettingPppRefusePapPropertyInfo = Bool
    type AttrLabel SettingPppRefusePapPropertyInfo = "refuse-pap"
    type AttrOrigin SettingPppRefusePapPropertyInfo = SettingPpp
    attrGet = getSettingPppRefusePap
    attrSet = setSettingPppRefusePap
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingPppRefusePap
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingPpp.refusePap"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingPpp.html#g:attr:refusePap"
        })
#endif

-- VVV Prop "require-mppe"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@require-mppe@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #requireMppe
-- @
getSettingPppRequireMppe :: (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppRequireMppe :: forall (m :: * -> *) o. (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppRequireMppe o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"require-mppe"

-- | Set the value of the “@require-mppe@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #requireMppe 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppRequireMppe :: (MonadIO m, IsSettingPpp o) => o -> Bool -> m ()
setSettingPppRequireMppe :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Bool -> m ()
setSettingPppRequireMppe o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"require-mppe" Bool
val

-- | Construct a t'GValueConstruct' with valid value for the “@require-mppe@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppRequireMppe :: (IsSettingPpp o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSettingPppRequireMppe :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSettingPppRequireMppe Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"require-mppe" Bool
val

#if defined(ENABLE_OVERLOADING)
data SettingPppRequireMppePropertyInfo
instance AttrInfo SettingPppRequireMppePropertyInfo where
    type AttrAllowedOps SettingPppRequireMppePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SettingPppRequireMppePropertyInfo = IsSettingPpp
    type AttrSetTypeConstraint SettingPppRequireMppePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SettingPppRequireMppePropertyInfo = (~) Bool
    type AttrTransferType SettingPppRequireMppePropertyInfo = Bool
    type AttrGetType SettingPppRequireMppePropertyInfo = Bool
    type AttrLabel SettingPppRequireMppePropertyInfo = "require-mppe"
    type AttrOrigin SettingPppRequireMppePropertyInfo = SettingPpp
    attrGet = getSettingPppRequireMppe
    attrSet = setSettingPppRequireMppe
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingPppRequireMppe
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingPpp.requireMppe"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingPpp.html#g:attr:requireMppe"
        })
#endif

-- VVV Prop "require-mppe-128"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@require-mppe-128@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' settingPpp #requireMppe128
-- @
getSettingPppRequireMppe128 :: (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppRequireMppe128 :: forall (m :: * -> *) o. (MonadIO m, IsSettingPpp o) => o -> m Bool
getSettingPppRequireMppe128 o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"require-mppe-128"

-- | Set the value of the “@require-mppe-128@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' settingPpp [ #requireMppe128 'Data.GI.Base.Attributes.:=' value ]
-- @
setSettingPppRequireMppe128 :: (MonadIO m, IsSettingPpp o) => o -> Bool -> m ()
setSettingPppRequireMppe128 :: forall (m :: * -> *) o.
(MonadIO m, IsSettingPpp o) =>
o -> Bool -> m ()
setSettingPppRequireMppe128 o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"require-mppe-128" Bool
val

-- | Construct a t'GValueConstruct' with valid value for the “@require-mppe-128@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSettingPppRequireMppe128 :: (IsSettingPpp o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSettingPppRequireMppe128 :: forall o (m :: * -> *).
(IsSettingPpp o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSettingPppRequireMppe128 Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"require-mppe-128" Bool
val

#if defined(ENABLE_OVERLOADING)
data SettingPppRequireMppe128PropertyInfo
instance AttrInfo SettingPppRequireMppe128PropertyInfo where
    type AttrAllowedOps SettingPppRequireMppe128PropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SettingPppRequireMppe128PropertyInfo = IsSettingPpp
    type AttrSetTypeConstraint SettingPppRequireMppe128PropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SettingPppRequireMppe128PropertyInfo = (~) Bool
    type AttrTransferType SettingPppRequireMppe128PropertyInfo = Bool
    type AttrGetType SettingPppRequireMppe128PropertyInfo = Bool
    type AttrLabel SettingPppRequireMppe128PropertyInfo = "require-mppe-128"
    type AttrOrigin SettingPppRequireMppe128PropertyInfo = SettingPpp
    attrGet = getSettingPppRequireMppe128
    attrSet = setSettingPppRequireMppe128
    attrTransfer _ v = do
        return v
    attrConstruct = constructSettingPppRequireMppe128
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.NM.Objects.SettingPpp.requireMppe128"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-nm-1.0.1/docs/GI-NM-Objects-SettingPpp.html#g:attr:requireMppe128"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList SettingPpp
type instance O.AttributeList SettingPpp = SettingPppAttributeList
type SettingPppAttributeList = ('[ '("baud", SettingPppBaudPropertyInfo), '("crtscts", SettingPppCrtsctsPropertyInfo), '("lcpEchoFailure", SettingPppLcpEchoFailurePropertyInfo), '("lcpEchoInterval", SettingPppLcpEchoIntervalPropertyInfo), '("mppeStateful", SettingPppMppeStatefulPropertyInfo), '("mru", SettingPppMruPropertyInfo), '("mtu", SettingPppMtuPropertyInfo), '("name", NM.Setting.SettingNamePropertyInfo), '("noVjComp", SettingPppNoVjCompPropertyInfo), '("noauth", SettingPppNoauthPropertyInfo), '("nobsdcomp", SettingPppNobsdcompPropertyInfo), '("nodeflate", SettingPppNodeflatePropertyInfo), '("refuseChap", SettingPppRefuseChapPropertyInfo), '("refuseEap", SettingPppRefuseEapPropertyInfo), '("refuseMschap", SettingPppRefuseMschapPropertyInfo), '("refuseMschapv2", SettingPppRefuseMschapv2PropertyInfo), '("refusePap", SettingPppRefusePapPropertyInfo), '("requireMppe", SettingPppRequireMppePropertyInfo), '("requireMppe128", SettingPppRequireMppe128PropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
settingPppBaud :: AttrLabelProxy "baud"
settingPppBaud = AttrLabelProxy

settingPppCrtscts :: AttrLabelProxy "crtscts"
settingPppCrtscts = AttrLabelProxy

settingPppLcpEchoFailure :: AttrLabelProxy "lcpEchoFailure"
settingPppLcpEchoFailure = AttrLabelProxy

settingPppLcpEchoInterval :: AttrLabelProxy "lcpEchoInterval"
settingPppLcpEchoInterval = AttrLabelProxy

settingPppMppeStateful :: AttrLabelProxy "mppeStateful"
settingPppMppeStateful = AttrLabelProxy

settingPppMru :: AttrLabelProxy "mru"
settingPppMru = AttrLabelProxy

settingPppMtu :: AttrLabelProxy "mtu"
settingPppMtu = AttrLabelProxy

settingPppNoVjComp :: AttrLabelProxy "noVjComp"
settingPppNoVjComp = AttrLabelProxy

settingPppNoauth :: AttrLabelProxy "noauth"
settingPppNoauth = AttrLabelProxy

settingPppNobsdcomp :: AttrLabelProxy "nobsdcomp"
settingPppNobsdcomp = AttrLabelProxy

settingPppNodeflate :: AttrLabelProxy "nodeflate"
settingPppNodeflate = AttrLabelProxy

settingPppRefuseChap :: AttrLabelProxy "refuseChap"
settingPppRefuseChap = AttrLabelProxy

settingPppRefuseEap :: AttrLabelProxy "refuseEap"
settingPppRefuseEap = AttrLabelProxy

settingPppRefuseMschap :: AttrLabelProxy "refuseMschap"
settingPppRefuseMschap = AttrLabelProxy

settingPppRefuseMschapv2 :: AttrLabelProxy "refuseMschapv2"
settingPppRefuseMschapv2 = AttrLabelProxy

settingPppRefusePap :: AttrLabelProxy "refusePap"
settingPppRefusePap = AttrLabelProxy

settingPppRequireMppe :: AttrLabelProxy "requireMppe"
settingPppRequireMppe = AttrLabelProxy

settingPppRequireMppe128 :: AttrLabelProxy "requireMppe128"
settingPppRequireMppe128 = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList SettingPpp = SettingPppSignalList
type SettingPppSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method SettingPpp::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "NM" , name = "SettingPpp" })
-- throws : False
-- Skip return : False

foreign import ccall "nm_setting_ppp_new" nm_setting_ppp_new :: 
    IO (Ptr SettingPpp)

-- | Creates a new t'GI.NM.Objects.SettingPpp.SettingPpp' object with default values.
settingPppNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m SettingPpp
    -- ^ __Returns:__ the new empty t'GI.NM.Objects.SettingPpp.SettingPpp' object
settingPppNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m SettingPpp
settingPppNew  = IO SettingPpp -> m SettingPpp
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SettingPpp -> m SettingPpp) -> IO SettingPpp -> m SettingPpp
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
result <- IO (Ptr SettingPpp)
nm_setting_ppp_new
    Text -> Ptr SettingPpp -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"settingPppNew" Ptr SettingPpp
result
    SettingPpp
result' <- ((ManagedPtr SettingPpp -> SettingPpp)
-> Ptr SettingPpp -> IO SettingPpp
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr SettingPpp -> SettingPpp
SettingPpp) Ptr SettingPpp
result
    SettingPpp -> IO SettingPpp
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SettingPpp
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "nm_setting_ppp_get_baud" nm_setting_ppp_get_baud :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO Word32

-- | /No description available in the introspection data./
settingPppGetBaud ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Word32
    -- ^ __Returns:__ the [SettingPpp:baud]("GI.NM.Objects.SettingPpp#g:attr:baud") property of the setting
settingPppGetBaud :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Word32
settingPppGetBaud a
setting = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    Word32
result <- Ptr SettingPpp -> IO Word32
nm_setting_ppp_get_baud Ptr SettingPpp
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data SettingPppGetBaudMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetBaudMethodInfo a signature where
    overloadedMethod = settingPppGetBaud

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


#endif

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

foreign import ccall "nm_setting_ppp_get_crtscts" nm_setting_ppp_get_crtscts :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO CInt

-- | /No description available in the introspection data./
settingPppGetCrtscts ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Bool
    -- ^ __Returns:__ the [SettingPpp:crtscts]("GI.NM.Objects.SettingPpp#g:attr:crtscts") property of the setting
settingPppGetCrtscts :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Bool
settingPppGetCrtscts a
setting = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CInt
result <- Ptr SettingPpp -> IO CInt
nm_setting_ppp_get_crtscts Ptr SettingPpp
setting'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingPppGetCrtsctsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetCrtsctsMethodInfo a signature where
    overloadedMethod = settingPppGetCrtscts

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


#endif

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

foreign import ccall "nm_setting_ppp_get_lcp_echo_failure" nm_setting_ppp_get_lcp_echo_failure :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO Word32

-- | /No description available in the introspection data./
settingPppGetLcpEchoFailure ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Word32
    -- ^ __Returns:__ the [SettingPpp:lcpEchoFailure]("GI.NM.Objects.SettingPpp#g:attr:lcpEchoFailure") property of the setting
settingPppGetLcpEchoFailure :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Word32
settingPppGetLcpEchoFailure a
setting = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    Word32
result <- Ptr SettingPpp -> IO Word32
nm_setting_ppp_get_lcp_echo_failure Ptr SettingPpp
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data SettingPppGetLcpEchoFailureMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetLcpEchoFailureMethodInfo a signature where
    overloadedMethod = settingPppGetLcpEchoFailure

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


#endif

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

foreign import ccall "nm_setting_ppp_get_lcp_echo_interval" nm_setting_ppp_get_lcp_echo_interval :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO Word32

-- | /No description available in the introspection data./
settingPppGetLcpEchoInterval ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Word32
    -- ^ __Returns:__ the [SettingPpp:lcpEchoInterval]("GI.NM.Objects.SettingPpp#g:attr:lcpEchoInterval") property of the setting
settingPppGetLcpEchoInterval :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Word32
settingPppGetLcpEchoInterval a
setting = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    Word32
result <- Ptr SettingPpp -> IO Word32
nm_setting_ppp_get_lcp_echo_interval Ptr SettingPpp
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data SettingPppGetLcpEchoIntervalMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetLcpEchoIntervalMethodInfo a signature where
    overloadedMethod = settingPppGetLcpEchoInterval

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


#endif

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

foreign import ccall "nm_setting_ppp_get_mppe_stateful" nm_setting_ppp_get_mppe_stateful :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO CInt

-- | /No description available in the introspection data./
settingPppGetMppeStateful ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Bool
    -- ^ __Returns:__ the [SettingPpp:mppeStateful]("GI.NM.Objects.SettingPpp#g:attr:mppeStateful") property of the setting
settingPppGetMppeStateful :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Bool
settingPppGetMppeStateful a
setting = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CInt
result <- Ptr SettingPpp -> IO CInt
nm_setting_ppp_get_mppe_stateful Ptr SettingPpp
setting'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingPppGetMppeStatefulMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetMppeStatefulMethodInfo a signature where
    overloadedMethod = settingPppGetMppeStateful

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


#endif

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

foreign import ccall "nm_setting_ppp_get_mru" nm_setting_ppp_get_mru :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO Word32

-- | /No description available in the introspection data./
settingPppGetMru ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Word32
    -- ^ __Returns:__ the [SettingPpp:mru]("GI.NM.Objects.SettingPpp#g:attr:mru") property of the setting
settingPppGetMru :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Word32
settingPppGetMru a
setting = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    Word32
result <- Ptr SettingPpp -> IO Word32
nm_setting_ppp_get_mru Ptr SettingPpp
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data SettingPppGetMruMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetMruMethodInfo a signature where
    overloadedMethod = settingPppGetMru

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


#endif

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

foreign import ccall "nm_setting_ppp_get_mtu" nm_setting_ppp_get_mtu :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO Word32

-- | /No description available in the introspection data./
settingPppGetMtu ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Word32
    -- ^ __Returns:__ the [SettingPpp:mtu]("GI.NM.Objects.SettingPpp#g:attr:mtu") property of the setting
settingPppGetMtu :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Word32
settingPppGetMtu a
setting = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    Word32
result <- Ptr SettingPpp -> IO Word32
nm_setting_ppp_get_mtu Ptr SettingPpp
setting'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data SettingPppGetMtuMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetMtuMethodInfo a signature where
    overloadedMethod = settingPppGetMtu

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


#endif

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

foreign import ccall "nm_setting_ppp_get_no_vj_comp" nm_setting_ppp_get_no_vj_comp :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO CInt

-- | /No description available in the introspection data./
settingPppGetNoVjComp ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Bool
    -- ^ __Returns:__ the [SettingPpp:noVjComp]("GI.NM.Objects.SettingPpp#g:attr:noVjComp") property of the setting
settingPppGetNoVjComp :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Bool
settingPppGetNoVjComp a
setting = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CInt
result <- Ptr SettingPpp -> IO CInt
nm_setting_ppp_get_no_vj_comp Ptr SettingPpp
setting'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingPppGetNoVjCompMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetNoVjCompMethodInfo a signature where
    overloadedMethod = settingPppGetNoVjComp

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


#endif

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

foreign import ccall "nm_setting_ppp_get_noauth" nm_setting_ppp_get_noauth :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO CInt

-- | /No description available in the introspection data./
settingPppGetNoauth ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Bool
    -- ^ __Returns:__ the [SettingPpp:noauth]("GI.NM.Objects.SettingPpp#g:attr:noauth") property of the setting
settingPppGetNoauth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Bool
settingPppGetNoauth a
setting = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CInt
result <- Ptr SettingPpp -> IO CInt
nm_setting_ppp_get_noauth Ptr SettingPpp
setting'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingPppGetNoauthMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetNoauthMethodInfo a signature where
    overloadedMethod = settingPppGetNoauth

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


#endif

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

foreign import ccall "nm_setting_ppp_get_nobsdcomp" nm_setting_ppp_get_nobsdcomp :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO CInt

-- | /No description available in the introspection data./
settingPppGetNobsdcomp ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Bool
    -- ^ __Returns:__ the [SettingPpp:nobsdcomp]("GI.NM.Objects.SettingPpp#g:attr:nobsdcomp") property of the setting
settingPppGetNobsdcomp :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Bool
settingPppGetNobsdcomp a
setting = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CInt
result <- Ptr SettingPpp -> IO CInt
nm_setting_ppp_get_nobsdcomp Ptr SettingPpp
setting'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingPppGetNobsdcompMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetNobsdcompMethodInfo a signature where
    overloadedMethod = settingPppGetNobsdcomp

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


#endif

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

foreign import ccall "nm_setting_ppp_get_nodeflate" nm_setting_ppp_get_nodeflate :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO CInt

-- | /No description available in the introspection data./
settingPppGetNodeflate ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Bool
    -- ^ __Returns:__ the [SettingPpp:nodeflate]("GI.NM.Objects.SettingPpp#g:attr:nodeflate") property of the setting
settingPppGetNodeflate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Bool
settingPppGetNodeflate a
setting = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CInt
result <- Ptr SettingPpp -> IO CInt
nm_setting_ppp_get_nodeflate Ptr SettingPpp
setting'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingPppGetNodeflateMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetNodeflateMethodInfo a signature where
    overloadedMethod = settingPppGetNodeflate

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


#endif

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

foreign import ccall "nm_setting_ppp_get_refuse_chap" nm_setting_ppp_get_refuse_chap :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO CInt

-- | /No description available in the introspection data./
settingPppGetRefuseChap ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Bool
    -- ^ __Returns:__ the [SettingPpp:refuseChap]("GI.NM.Objects.SettingPpp#g:attr:refuseChap") property of the setting
settingPppGetRefuseChap :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Bool
settingPppGetRefuseChap a
setting = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CInt
result <- Ptr SettingPpp -> IO CInt
nm_setting_ppp_get_refuse_chap Ptr SettingPpp
setting'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingPppGetRefuseChapMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetRefuseChapMethodInfo a signature where
    overloadedMethod = settingPppGetRefuseChap

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


#endif

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

foreign import ccall "nm_setting_ppp_get_refuse_eap" nm_setting_ppp_get_refuse_eap :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO CInt

-- | /No description available in the introspection data./
settingPppGetRefuseEap ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Bool
    -- ^ __Returns:__ the [SettingPpp:refuseEap]("GI.NM.Objects.SettingPpp#g:attr:refuseEap") property of the setting
settingPppGetRefuseEap :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Bool
settingPppGetRefuseEap a
setting = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CInt
result <- Ptr SettingPpp -> IO CInt
nm_setting_ppp_get_refuse_eap Ptr SettingPpp
setting'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingPppGetRefuseEapMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetRefuseEapMethodInfo a signature where
    overloadedMethod = settingPppGetRefuseEap

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


#endif

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

foreign import ccall "nm_setting_ppp_get_refuse_mschap" nm_setting_ppp_get_refuse_mschap :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO CInt

-- | /No description available in the introspection data./
settingPppGetRefuseMschap ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Bool
    -- ^ __Returns:__ the [SettingPpp:refuseMschap]("GI.NM.Objects.SettingPpp#g:attr:refuseMschap") property of the setting
settingPppGetRefuseMschap :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Bool
settingPppGetRefuseMschap a
setting = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CInt
result <- Ptr SettingPpp -> IO CInt
nm_setting_ppp_get_refuse_mschap Ptr SettingPpp
setting'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingPppGetRefuseMschapMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetRefuseMschapMethodInfo a signature where
    overloadedMethod = settingPppGetRefuseMschap

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


#endif

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

foreign import ccall "nm_setting_ppp_get_refuse_mschapv2" nm_setting_ppp_get_refuse_mschapv2 :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO CInt

-- | /No description available in the introspection data./
settingPppGetRefuseMschapv2 ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Bool
    -- ^ __Returns:__ the [SettingPpp:refuseMschapv2]("GI.NM.Objects.SettingPpp#g:attr:refuseMschapv2") property of the setting
settingPppGetRefuseMschapv2 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Bool
settingPppGetRefuseMschapv2 a
setting = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CInt
result <- Ptr SettingPpp -> IO CInt
nm_setting_ppp_get_refuse_mschapv2 Ptr SettingPpp
setting'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingPppGetRefuseMschapv2MethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetRefuseMschapv2MethodInfo a signature where
    overloadedMethod = settingPppGetRefuseMschapv2

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


#endif

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

foreign import ccall "nm_setting_ppp_get_refuse_pap" nm_setting_ppp_get_refuse_pap :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO CInt

-- | /No description available in the introspection data./
settingPppGetRefusePap ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Bool
    -- ^ __Returns:__ the [SettingPpp:refusePap]("GI.NM.Objects.SettingPpp#g:attr:refusePap") property of the setting
settingPppGetRefusePap :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Bool
settingPppGetRefusePap a
setting = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CInt
result <- Ptr SettingPpp -> IO CInt
nm_setting_ppp_get_refuse_pap Ptr SettingPpp
setting'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingPppGetRefusePapMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetRefusePapMethodInfo a signature where
    overloadedMethod = settingPppGetRefusePap

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


#endif

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

foreign import ccall "nm_setting_ppp_get_require_mppe" nm_setting_ppp_get_require_mppe :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO CInt

-- | /No description available in the introspection data./
settingPppGetRequireMppe ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Bool
    -- ^ __Returns:__ the [SettingPpp:requireMppe]("GI.NM.Objects.SettingPpp#g:attr:requireMppe") property of the setting
settingPppGetRequireMppe :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Bool
settingPppGetRequireMppe a
setting = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CInt
result <- Ptr SettingPpp -> IO CInt
nm_setting_ppp_get_require_mppe Ptr SettingPpp
setting'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingPppGetRequireMppeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetRequireMppeMethodInfo a signature where
    overloadedMethod = settingPppGetRequireMppe

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


#endif

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

foreign import ccall "nm_setting_ppp_get_require_mppe_128" nm_setting_ppp_get_require_mppe_128 :: 
    Ptr SettingPpp ->                       -- setting : TInterface (Name {namespace = "NM", name = "SettingPpp"})
    IO CInt

-- | /No description available in the introspection data./
settingPppGetRequireMppe128 ::
    (B.CallStack.HasCallStack, MonadIO m, IsSettingPpp a) =>
    a
    -- ^ /@setting@/: the t'GI.NM.Objects.SettingPpp.SettingPpp'
    -> m Bool
    -- ^ __Returns:__ the [SettingPpp:requireMppe128]("GI.NM.Objects.SettingPpp#g:attr:requireMppe128") property of the setting
settingPppGetRequireMppe128 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSettingPpp a) =>
a -> m Bool
settingPppGetRequireMppe128 a
setting = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SettingPpp
setting' <- a -> IO (Ptr SettingPpp)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
setting
    CInt
result <- Ptr SettingPpp -> IO CInt
nm_setting_ppp_get_require_mppe_128 Ptr SettingPpp
setting'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
setting
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SettingPppGetRequireMppe128MethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSettingPpp a) => O.OverloadedMethod SettingPppGetRequireMppe128MethodInfo a signature where
    overloadedMethod = settingPppGetRequireMppe128

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


#endif