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

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

module GI.NM.Enums
    ( 

 -- * Enumerations


-- ** ActiveConnectionState #enum:ActiveConnectionState#

    ActiveConnectionState(..)               ,


-- ** ActiveConnectionStateReason #enum:ActiveConnectionStateReason#

    ActiveConnectionStateReason(..)         ,


-- ** AgentManagerError #enum:AgentManagerError#

    AgentManagerError(..)                   ,
    catchAgentManagerError                  ,
    handleAgentManagerError                 ,


-- ** Capability #enum:Capability#

    Capability(..)                          ,


-- ** ClientError #enum:ClientError#

    ClientError(..)                         ,
    catchClientError                        ,
    handleClientError                       ,


-- ** ClientPermission #enum:ClientPermission#

    ClientPermission(..)                    ,


-- ** ClientPermissionResult #enum:ClientPermissionResult#

    ClientPermissionResult(..)              ,


-- ** ConnectionError #enum:ConnectionError#

    ConnectionError(..)                     ,
    catchConnectionError                    ,
    handleConnectionError                   ,


-- ** ConnectionMultiConnect #enum:ConnectionMultiConnect#

    ConnectionMultiConnect(..)              ,


-- ** ConnectivityState #enum:ConnectivityState#

    ConnectivityState(..)                   ,


-- ** CryptoError #enum:CryptoError#

    CryptoError(..)                         ,
    catchCryptoError                        ,
    handleCryptoError                       ,


-- ** DeviceError #enum:DeviceError#

    DeviceError(..)                         ,
    catchDeviceError                        ,
    handleDeviceError                       ,


-- ** DeviceState #enum:DeviceState#

    DeviceState(..)                         ,


-- ** DeviceStateReason #enum:DeviceStateReason#

    DeviceStateReason(..)                   ,


-- ** DeviceType #enum:DeviceType#

    DeviceType(..)                          ,


-- ** IPTunnelMode #enum:IPTunnelMode#

    IPTunnelMode(..)                        ,


-- ** KeyfileHandlerType #enum:KeyfileHandlerType#

    KeyfileHandlerType(..)                  ,


-- ** KeyfileWarnSeverity #enum:KeyfileWarnSeverity#

    KeyfileWarnSeverity(..)                 ,


-- ** ManagerError #enum:ManagerError#

    ManagerError(..)                        ,
    catchManagerError                       ,
    handleManagerError                      ,


-- ** Metered #enum:Metered#

    Metered(..)                             ,


-- ** NM80211Mode #enum:NM80211Mode#

    NM80211Mode(..)                         ,


-- ** RollbackResult #enum:RollbackResult#

    RollbackResult(..)                      ,


-- ** SecretAgentError #enum:SecretAgentError#

    SecretAgentError(..)                    ,
    catchSecretAgentError                   ,
    handleSecretAgentError                  ,


-- ** Setting8021xCKFormat #enum:Setting8021xCKFormat#

    Setting8021xCKFormat(..)                ,


-- ** Setting8021xCKScheme #enum:Setting8021xCKScheme#

    Setting8021xCKScheme(..)                ,


-- ** SettingCompareFlags #enum:SettingCompareFlags#

    SettingCompareFlags(..)                 ,


-- ** SettingConnectionAutoconnectSlaves #enum:SettingConnectionAutoconnectSlaves#

    SettingConnectionAutoconnectSlaves(..)  ,


-- ** SettingConnectionDnsOverTls #enum:SettingConnectionDnsOverTls#

    SettingConnectionDnsOverTls(..)         ,


-- ** SettingConnectionDownOnPoweroff #enum:SettingConnectionDownOnPoweroff#

    SettingConnectionDownOnPoweroff(..)     ,


-- ** SettingConnectionLldp #enum:SettingConnectionLldp#

    SettingConnectionLldp(..)               ,


-- ** SettingConnectionLlmnr #enum:SettingConnectionLlmnr#

    SettingConnectionLlmnr(..)              ,


-- ** SettingConnectionMdns #enum:SettingConnectionMdns#

    SettingConnectionMdns(..)               ,


-- ** SettingDiffResult #enum:SettingDiffResult#

    SettingDiffResult(..)                   ,


-- ** SettingIP4LinkLocal #enum:SettingIP4LinkLocal#

    SettingIP4LinkLocal(..)                 ,


-- ** SettingIP6ConfigAddrGenMode #enum:SettingIP6ConfigAddrGenMode#

    SettingIP6ConfigAddrGenMode(..)         ,


-- ** SettingIP6ConfigPrivacy #enum:SettingIP6ConfigPrivacy#

    SettingIP6ConfigPrivacy(..)             ,


-- ** SettingMacRandomization #enum:SettingMacRandomization#

    SettingMacRandomization(..)             ,


-- ** SettingMacsecMode #enum:SettingMacsecMode#

    SettingMacsecMode(..)                   ,


-- ** SettingMacsecOffload #enum:SettingMacsecOffload#

    SettingMacsecOffload(..)                ,


-- ** SettingMacsecValidation #enum:SettingMacsecValidation#

    SettingMacsecValidation(..)             ,


-- ** SettingMacvlanMode #enum:SettingMacvlanMode#

    SettingMacvlanMode(..)                  ,


-- ** SettingProxyMethod #enum:SettingProxyMethod#

    SettingProxyMethod(..)                  ,


-- ** SettingSerialParity #enum:SettingSerialParity#

    SettingSerialParity(..)                 ,


-- ** SettingTunMode #enum:SettingTunMode#

    SettingTunMode(..)                      ,


-- ** SettingWirelessChannelWidth #enum:SettingWirelessChannelWidth#

    SettingWirelessChannelWidth(..)         ,


-- ** SettingWirelessPowersave #enum:SettingWirelessPowersave#

    SettingWirelessPowersave(..)            ,


-- ** SettingWirelessSecurityFils #enum:SettingWirelessSecurityFils#

    SettingWirelessSecurityFils(..)         ,


-- ** SettingWirelessSecurityPmf #enum:SettingWirelessSecurityPmf#

    SettingWirelessSecurityPmf(..)          ,


-- ** SettingsError #enum:SettingsError#

    SettingsError(..)                       ,
    catchSettingsError                      ,
    handleSettingsError                     ,


-- ** SriovEswitchEncapMode #enum:SriovEswitchEncapMode#

    SriovEswitchEncapMode(..)               ,


-- ** SriovEswitchInlineMode #enum:SriovEswitchInlineMode#

    SriovEswitchInlineMode(..)              ,


-- ** SriovEswitchMode #enum:SriovEswitchMode#

    SriovEswitchMode(..)                    ,


-- ** SriovVFVlanProtocol #enum:SriovVFVlanProtocol#

    SriovVFVlanProtocol(..)                 ,


-- ** State #enum:State#

    State(..)                               ,


-- ** Ternary #enum:Ternary#

    Ternary(..)                             ,


-- ** UtilsSecurityType #enum:UtilsSecurityType#

    UtilsSecurityType(..)                   ,


-- ** VersionInfoCapability #enum:VersionInfoCapability#

    VersionInfoCapability(..)               ,


-- ** VlanPriorityMap #enum:VlanPriorityMap#

    VlanPriorityMap(..)                     ,


-- ** VpnConnectionState #enum:VpnConnectionState#

    VpnConnectionState(..)                  ,


-- ** VpnConnectionStateReason #enum:VpnConnectionStateReason#

    VpnConnectionStateReason(..)            ,


-- ** VpnPluginError #enum:VpnPluginError#

    VpnPluginError(..)                      ,
    catchVpnPluginError                     ,
    handleVpnPluginError                    ,


-- ** VpnPluginFailure #enum:VpnPluginFailure#

    VpnPluginFailure(..)                    ,


-- ** VpnServiceState #enum:VpnServiceState#

    VpnServiceState(..)                     ,


-- ** WepKeyType #enum:WepKeyType#

    WepKeyType(..)                          ,


-- ** WimaxNspNetworkType #enum:WimaxNspNetworkType#

    WimaxNspNetworkType(..)                 ,




    ) 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)

#else

#endif

-- Enum WimaxNspNetworkType
-- | WiMAX network type.
data WimaxNspNetworkType = 
      WimaxNspNetworkTypeUnknown
    -- ^ unknown network type
    | WimaxNspNetworkTypeHome
    -- ^ home network
    | WimaxNspNetworkTypePartner
    -- ^ partner network
    | WimaxNspNetworkTypeRoamingPartner
    -- ^ roaming partner network
    | AnotherWimaxNspNetworkType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> WimaxNspNetworkType -> ShowS
[WimaxNspNetworkType] -> ShowS
WimaxNspNetworkType -> String
(Int -> WimaxNspNetworkType -> ShowS)
-> (WimaxNspNetworkType -> String)
-> ([WimaxNspNetworkType] -> ShowS)
-> Show WimaxNspNetworkType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WimaxNspNetworkType -> ShowS
showsPrec :: Int -> WimaxNspNetworkType -> ShowS
$cshow :: WimaxNspNetworkType -> String
show :: WimaxNspNetworkType -> String
$cshowList :: [WimaxNspNetworkType] -> ShowS
showList :: [WimaxNspNetworkType] -> ShowS
Show, WimaxNspNetworkType -> WimaxNspNetworkType -> Bool
(WimaxNspNetworkType -> WimaxNspNetworkType -> Bool)
-> (WimaxNspNetworkType -> WimaxNspNetworkType -> Bool)
-> Eq WimaxNspNetworkType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WimaxNspNetworkType -> WimaxNspNetworkType -> Bool
== :: WimaxNspNetworkType -> WimaxNspNetworkType -> Bool
$c/= :: WimaxNspNetworkType -> WimaxNspNetworkType -> Bool
/= :: WimaxNspNetworkType -> WimaxNspNetworkType -> Bool
Eq)

instance P.Enum WimaxNspNetworkType where
    fromEnum :: WimaxNspNetworkType -> Int
fromEnum WimaxNspNetworkType
WimaxNspNetworkTypeUnknown = Int
0
    fromEnum WimaxNspNetworkType
WimaxNspNetworkTypeHome = Int
1
    fromEnum WimaxNspNetworkType
WimaxNspNetworkTypePartner = Int
2
    fromEnum WimaxNspNetworkType
WimaxNspNetworkTypeRoamingPartner = Int
3
    fromEnum (AnotherWimaxNspNetworkType Int
k) = Int
k

    toEnum :: Int -> WimaxNspNetworkType
toEnum Int
0 = WimaxNspNetworkType
WimaxNspNetworkTypeUnknown
    toEnum Int
1 = WimaxNspNetworkType
WimaxNspNetworkTypeHome
    toEnum Int
2 = WimaxNspNetworkType
WimaxNspNetworkTypePartner
    toEnum Int
3 = WimaxNspNetworkType
WimaxNspNetworkTypeRoamingPartner
    toEnum Int
k = Int -> WimaxNspNetworkType
AnotherWimaxNspNetworkType Int
k

instance P.Ord WimaxNspNetworkType where
    compare :: WimaxNspNetworkType -> WimaxNspNetworkType -> Ordering
compare WimaxNspNetworkType
a WimaxNspNetworkType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WimaxNspNetworkType -> Int
forall a. Enum a => a -> Int
P.fromEnum WimaxNspNetworkType
a) (WimaxNspNetworkType -> Int
forall a. Enum a => a -> Int
P.fromEnum WimaxNspNetworkType
b)

type instance O.ParentTypes WimaxNspNetworkType = '[]
instance O.HasParentTypes WimaxNspNetworkType

foreign import ccall "nm_wimax_nsp_network_type_get_type" c_nm_wimax_nsp_network_type_get_type :: 
    IO GType

instance B.Types.TypedObject WimaxNspNetworkType where
    glibType :: IO GType
glibType = IO GType
c_nm_wimax_nsp_network_type_get_type

instance B.Types.BoxedEnum WimaxNspNetworkType

-- Enum WepKeyType
-- | The t'GI.NM.Enums.WepKeyType' values specify how any WEP keys present in the setting
-- are interpreted.  There are no standards governing how to hash the various WEP
-- key\/passphrase formats into the actual WEP key.  Unfortunately some WEP keys
-- can be interpreted in multiple ways, requiring the setting to specify how to
-- interpret the any WEP keys.  For example, the key \"732f2d712e4a394a375d366931\"
-- is both a valid Hexadecimal WEP key and a WEP passphrase.  Further, many
-- ASCII keys are also valid WEP passphrases, but since passphrases and ASCII
-- keys are hashed differently to determine the actual WEP key the type must be
-- specified.
data WepKeyType = 
      WepKeyTypeUnknown
    -- ^ unknown WEP key type
    | WepKeyTypeKey
    -- ^ indicates a hexadecimal or ASCII formatted WEP key.
    -- Hex keys are either 10 or 26 hexadecimal characters (ie \"5f782f2f5f\" or
    -- \"732f2d712e4a394a375d366931\"), while ASCII keys are either 5 or 13 ASCII
    -- characters (ie \"abcde\" or \"blahblah99$*1\").
    | WepKeyTypePassphrase
    -- ^ indicates a WEP passphrase (ex \"I bought a duck
    -- on my way back from the market 235Q&^%^*%\") instead of a hexadecimal or ASCII
    -- key.  Passphrases are between 8 and 64 characters inclusive and are hashed
    -- the actual WEP key using the MD5 hash algorithm.
    | AnotherWepKeyType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> WepKeyType -> ShowS
[WepKeyType] -> ShowS
WepKeyType -> String
(Int -> WepKeyType -> ShowS)
-> (WepKeyType -> String)
-> ([WepKeyType] -> ShowS)
-> Show WepKeyType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WepKeyType -> ShowS
showsPrec :: Int -> WepKeyType -> ShowS
$cshow :: WepKeyType -> String
show :: WepKeyType -> String
$cshowList :: [WepKeyType] -> ShowS
showList :: [WepKeyType] -> ShowS
Show, WepKeyType -> WepKeyType -> Bool
(WepKeyType -> WepKeyType -> Bool)
-> (WepKeyType -> WepKeyType -> Bool) -> Eq WepKeyType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WepKeyType -> WepKeyType -> Bool
== :: WepKeyType -> WepKeyType -> Bool
$c/= :: WepKeyType -> WepKeyType -> Bool
/= :: WepKeyType -> WepKeyType -> Bool
Eq)

instance P.Enum WepKeyType where
    fromEnum :: WepKeyType -> Int
fromEnum WepKeyType
WepKeyTypeUnknown = Int
0
    fromEnum WepKeyType
WepKeyTypeKey = Int
1
    fromEnum WepKeyType
WepKeyTypePassphrase = Int
2
    fromEnum (AnotherWepKeyType Int
k) = Int
k

    toEnum :: Int -> WepKeyType
toEnum Int
0 = WepKeyType
WepKeyTypeUnknown
    toEnum Int
1 = WepKeyType
WepKeyTypeKey
    toEnum Int
2 = WepKeyType
WepKeyTypePassphrase
    toEnum Int
k = Int -> WepKeyType
AnotherWepKeyType Int
k

instance P.Ord WepKeyType where
    compare :: WepKeyType -> WepKeyType -> Ordering
compare WepKeyType
a WepKeyType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WepKeyType -> Int
forall a. Enum a => a -> Int
P.fromEnum WepKeyType
a) (WepKeyType -> Int
forall a. Enum a => a -> Int
P.fromEnum WepKeyType
b)

type instance O.ParentTypes WepKeyType = '[]
instance O.HasParentTypes WepKeyType

foreign import ccall "nm_wep_key_type_get_type" c_nm_wep_key_type_get_type :: 
    IO GType

instance B.Types.TypedObject WepKeyType where
    glibType :: IO GType
glibType = IO GType
c_nm_wep_key_type_get_type

instance B.Types.BoxedEnum WepKeyType

-- Enum VpnServiceState
-- | VPN daemon states
data VpnServiceState = 
      VpnServiceStateUnknown
    -- ^ The state of the VPN plugin is unknown.
    | VpnServiceStateInit
    -- ^ The VPN plugin is initialized.
    | VpnServiceStateShutdown
    -- ^ Not used.
    | VpnServiceStateStarting
    -- ^ The plugin is attempting to connect to a VPN server.
    | VpnServiceStateStarted
    -- ^ The plugin has connected to a VPN server.
    | VpnServiceStateStopping
    -- ^ The plugin is disconnecting from the VPN server.
    | VpnServiceStateStopped
    -- ^ The plugin has disconnected from the VPN server.
    | AnotherVpnServiceState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VpnServiceState -> ShowS
[VpnServiceState] -> ShowS
VpnServiceState -> String
(Int -> VpnServiceState -> ShowS)
-> (VpnServiceState -> String)
-> ([VpnServiceState] -> ShowS)
-> Show VpnServiceState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VpnServiceState -> ShowS
showsPrec :: Int -> VpnServiceState -> ShowS
$cshow :: VpnServiceState -> String
show :: VpnServiceState -> String
$cshowList :: [VpnServiceState] -> ShowS
showList :: [VpnServiceState] -> ShowS
Show, VpnServiceState -> VpnServiceState -> Bool
(VpnServiceState -> VpnServiceState -> Bool)
-> (VpnServiceState -> VpnServiceState -> Bool)
-> Eq VpnServiceState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VpnServiceState -> VpnServiceState -> Bool
== :: VpnServiceState -> VpnServiceState -> Bool
$c/= :: VpnServiceState -> VpnServiceState -> Bool
/= :: VpnServiceState -> VpnServiceState -> Bool
Eq)

instance P.Enum VpnServiceState where
    fromEnum :: VpnServiceState -> Int
fromEnum VpnServiceState
VpnServiceStateUnknown = Int
0
    fromEnum VpnServiceState
VpnServiceStateInit = Int
1
    fromEnum VpnServiceState
VpnServiceStateShutdown = Int
2
    fromEnum VpnServiceState
VpnServiceStateStarting = Int
3
    fromEnum VpnServiceState
VpnServiceStateStarted = Int
4
    fromEnum VpnServiceState
VpnServiceStateStopping = Int
5
    fromEnum VpnServiceState
VpnServiceStateStopped = Int
6
    fromEnum (AnotherVpnServiceState Int
k) = Int
k

    toEnum :: Int -> VpnServiceState
toEnum Int
0 = VpnServiceState
VpnServiceStateUnknown
    toEnum Int
1 = VpnServiceState
VpnServiceStateInit
    toEnum Int
2 = VpnServiceState
VpnServiceStateShutdown
    toEnum Int
3 = VpnServiceState
VpnServiceStateStarting
    toEnum Int
4 = VpnServiceState
VpnServiceStateStarted
    toEnum Int
5 = VpnServiceState
VpnServiceStateStopping
    toEnum Int
6 = VpnServiceState
VpnServiceStateStopped
    toEnum Int
k = Int -> VpnServiceState
AnotherVpnServiceState Int
k

instance P.Ord VpnServiceState where
    compare :: VpnServiceState -> VpnServiceState -> Ordering
compare VpnServiceState
a VpnServiceState
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VpnServiceState -> Int
forall a. Enum a => a -> Int
P.fromEnum VpnServiceState
a) (VpnServiceState -> Int
forall a. Enum a => a -> Int
P.fromEnum VpnServiceState
b)

type instance O.ParentTypes VpnServiceState = '[]
instance O.HasParentTypes VpnServiceState

foreign import ccall "nm_vpn_service_state_get_type" c_nm_vpn_service_state_get_type :: 
    IO GType

instance B.Types.TypedObject VpnServiceState where
    glibType :: IO GType
glibType = IO GType
c_nm_vpn_service_state_get_type

instance B.Types.BoxedEnum VpnServiceState

-- Enum VpnPluginFailure
-- | VPN plugin failure reasons
data VpnPluginFailure = 
      VpnPluginFailureLoginFailed
    -- ^ Login failed.
    | VpnPluginFailureConnectFailed
    -- ^ Connect failed.
    | VpnPluginFailureBadIpConfig
    -- ^ Invalid IP configuration returned from
    --   the VPN plugin.
    | AnotherVpnPluginFailure Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VpnPluginFailure -> ShowS
[VpnPluginFailure] -> ShowS
VpnPluginFailure -> String
(Int -> VpnPluginFailure -> ShowS)
-> (VpnPluginFailure -> String)
-> ([VpnPluginFailure] -> ShowS)
-> Show VpnPluginFailure
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VpnPluginFailure -> ShowS
showsPrec :: Int -> VpnPluginFailure -> ShowS
$cshow :: VpnPluginFailure -> String
show :: VpnPluginFailure -> String
$cshowList :: [VpnPluginFailure] -> ShowS
showList :: [VpnPluginFailure] -> ShowS
Show, VpnPluginFailure -> VpnPluginFailure -> Bool
(VpnPluginFailure -> VpnPluginFailure -> Bool)
-> (VpnPluginFailure -> VpnPluginFailure -> Bool)
-> Eq VpnPluginFailure
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VpnPluginFailure -> VpnPluginFailure -> Bool
== :: VpnPluginFailure -> VpnPluginFailure -> Bool
$c/= :: VpnPluginFailure -> VpnPluginFailure -> Bool
/= :: VpnPluginFailure -> VpnPluginFailure -> Bool
Eq)

instance P.Enum VpnPluginFailure where
    fromEnum :: VpnPluginFailure -> Int
fromEnum VpnPluginFailure
VpnPluginFailureLoginFailed = Int
0
    fromEnum VpnPluginFailure
VpnPluginFailureConnectFailed = Int
1
    fromEnum VpnPluginFailure
VpnPluginFailureBadIpConfig = Int
2
    fromEnum (AnotherVpnPluginFailure Int
k) = Int
k

    toEnum :: Int -> VpnPluginFailure
toEnum Int
0 = VpnPluginFailure
VpnPluginFailureLoginFailed
    toEnum Int
1 = VpnPluginFailure
VpnPluginFailureConnectFailed
    toEnum Int
2 = VpnPluginFailure
VpnPluginFailureBadIpConfig
    toEnum Int
k = Int -> VpnPluginFailure
AnotherVpnPluginFailure Int
k

instance P.Ord VpnPluginFailure where
    compare :: VpnPluginFailure -> VpnPluginFailure -> Ordering
compare VpnPluginFailure
a VpnPluginFailure
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VpnPluginFailure -> Int
forall a. Enum a => a -> Int
P.fromEnum VpnPluginFailure
a) (VpnPluginFailure -> Int
forall a. Enum a => a -> Int
P.fromEnum VpnPluginFailure
b)

type instance O.ParentTypes VpnPluginFailure = '[]
instance O.HasParentTypes VpnPluginFailure

foreign import ccall "nm_vpn_plugin_failure_get_type" c_nm_vpn_plugin_failure_get_type :: 
    IO GType

instance B.Types.TypedObject VpnPluginFailure where
    glibType :: IO GType
glibType = IO GType
c_nm_vpn_plugin_failure_get_type

instance B.Types.BoxedEnum VpnPluginFailure

-- Enum VpnPluginError
-- | Returned by the VPN service plugin to indicate errors. These codes correspond
-- to errors in the \"org.freedesktop.NetworkManager.VPN.Error\" namespace.
data VpnPluginError = 
      VpnPluginErrorFailed
    -- ^ unknown or unclassified error
    | VpnPluginErrorStartingInProgress
    -- ^ the plugin is already starting,
    --   and another connect request was received
    | VpnPluginErrorAlreadyStarted
    -- ^ the plugin is already connected, and
    --   another connect request was received
    | VpnPluginErrorStoppingInProgress
    -- ^ the plugin is already stopping,
    --   and another stop request was received
    | VpnPluginErrorAlreadyStopped
    -- ^ the plugin is already stopped, and
    --   another disconnect request was received
    | VpnPluginErrorWrongState
    -- ^ the operation could not be performed in
    --   this state
    | VpnPluginErrorBadArguments
    -- ^ the operation could not be performed as
    --   the request contained malformed arguments, or arguments of unexpected type.
    --   Usually means that one of the VPN setting data items or secrets was not of
    --   the expected type (ie int, string, bool, etc).
    | VpnPluginErrorLaunchFailed
    -- ^ a child process failed to launch
    | VpnPluginErrorInvalidConnection
    -- ^ the operation could not be performed
    --   because the connection was invalid.  Usually means that the connection\'s
    --   VPN setting was missing some required data item or secret.
    | VpnPluginErrorInteractiveNotSupported
    -- ^ the operation could not be
    --   performed as the plugin does not support interactive operations, such as
    --   @/ConnectInteractive()/@ or @/NewSecrets()/@
    | AnotherVpnPluginError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VpnPluginError -> ShowS
[VpnPluginError] -> ShowS
VpnPluginError -> String
(Int -> VpnPluginError -> ShowS)
-> (VpnPluginError -> String)
-> ([VpnPluginError] -> ShowS)
-> Show VpnPluginError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VpnPluginError -> ShowS
showsPrec :: Int -> VpnPluginError -> ShowS
$cshow :: VpnPluginError -> String
show :: VpnPluginError -> String
$cshowList :: [VpnPluginError] -> ShowS
showList :: [VpnPluginError] -> ShowS
Show, VpnPluginError -> VpnPluginError -> Bool
(VpnPluginError -> VpnPluginError -> Bool)
-> (VpnPluginError -> VpnPluginError -> Bool) -> Eq VpnPluginError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VpnPluginError -> VpnPluginError -> Bool
== :: VpnPluginError -> VpnPluginError -> Bool
$c/= :: VpnPluginError -> VpnPluginError -> Bool
/= :: VpnPluginError -> VpnPluginError -> Bool
Eq)

instance P.Enum VpnPluginError where
    fromEnum :: VpnPluginError -> Int
fromEnum VpnPluginError
VpnPluginErrorFailed = Int
0
    fromEnum VpnPluginError
VpnPluginErrorStartingInProgress = Int
1
    fromEnum VpnPluginError
VpnPluginErrorAlreadyStarted = Int
2
    fromEnum VpnPluginError
VpnPluginErrorStoppingInProgress = Int
3
    fromEnum VpnPluginError
VpnPluginErrorAlreadyStopped = Int
4
    fromEnum VpnPluginError
VpnPluginErrorWrongState = Int
5
    fromEnum VpnPluginError
VpnPluginErrorBadArguments = Int
6
    fromEnum VpnPluginError
VpnPluginErrorLaunchFailed = Int
7
    fromEnum VpnPluginError
VpnPluginErrorInvalidConnection = Int
8
    fromEnum VpnPluginError
VpnPluginErrorInteractiveNotSupported = Int
9
    fromEnum (AnotherVpnPluginError Int
k) = Int
k

    toEnum :: Int -> VpnPluginError
toEnum Int
0 = VpnPluginError
VpnPluginErrorFailed
    toEnum Int
1 = VpnPluginError
VpnPluginErrorStartingInProgress
    toEnum Int
2 = VpnPluginError
VpnPluginErrorAlreadyStarted
    toEnum Int
3 = VpnPluginError
VpnPluginErrorStoppingInProgress
    toEnum Int
4 = VpnPluginError
VpnPluginErrorAlreadyStopped
    toEnum Int
5 = VpnPluginError
VpnPluginErrorWrongState
    toEnum Int
6 = VpnPluginError
VpnPluginErrorBadArguments
    toEnum Int
7 = VpnPluginError
VpnPluginErrorLaunchFailed
    toEnum Int
8 = VpnPluginError
VpnPluginErrorInvalidConnection
    toEnum Int
9 = VpnPluginError
VpnPluginErrorInteractiveNotSupported
    toEnum Int
k = Int -> VpnPluginError
AnotherVpnPluginError Int
k

instance P.Ord VpnPluginError where
    compare :: VpnPluginError -> VpnPluginError -> Ordering
compare VpnPluginError
a VpnPluginError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VpnPluginError -> Int
forall a. Enum a => a -> Int
P.fromEnum VpnPluginError
a) (VpnPluginError -> Int
forall a. Enum a => a -> Int
P.fromEnum VpnPluginError
b)

instance GErrorClass VpnPluginError where
    gerrorClassDomain :: VpnPluginError -> Text
gerrorClassDomain VpnPluginError
_ = Text
"nm-vpn-plugin-error-quark"

-- | Catch exceptions of type `VpnPluginError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchVpnPluginError ::
    IO a ->
    (VpnPluginError -> GErrorMessage -> IO a) ->
    IO a
catchVpnPluginError :: forall a. IO a -> (VpnPluginError -> Text -> IO a) -> IO a
catchVpnPluginError = IO a -> (VpnPluginError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `VpnPluginError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleVpnPluginError ::
    (VpnPluginError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleVpnPluginError :: forall a. (VpnPluginError -> Text -> IO a) -> IO a -> IO a
handleVpnPluginError = (VpnPluginError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes VpnPluginError = '[]
instance O.HasParentTypes VpnPluginError

foreign import ccall "nm_vpn_plugin_error_get_type" c_nm_vpn_plugin_error_get_type :: 
    IO GType

instance B.Types.TypedObject VpnPluginError where
    glibType :: IO GType
glibType = IO GType
c_nm_vpn_plugin_error_get_type

instance B.Types.BoxedEnum VpnPluginError

-- Enum VpnConnectionStateReason
-- | VPN connection state reasons
data VpnConnectionStateReason = 
      VpnConnectionStateReasonUnknown
    -- ^ The reason for the VPN connection
    --   state change is unknown.
    | VpnConnectionStateReasonNone
    -- ^ No reason was given for the VPN
    --   connection state change.
    | VpnConnectionStateReasonUserDisconnected
    -- ^ The VPN connection changed
    --   state because the user disconnected it.
    | VpnConnectionStateReasonDeviceDisconnected
    -- ^ The VPN connection
    --   changed state because the device it was using was disconnected.
    | VpnConnectionStateReasonServiceStopped
    -- ^ The service providing the
    --   VPN connection was stopped.
    | VpnConnectionStateReasonIpConfigInvalid
    -- ^ The IP config of the VPN
    --   connection was invalid.
    | VpnConnectionStateReasonConnectTimeout
    -- ^ The connection attempt to
    --   the VPN service timed out.
    | VpnConnectionStateReasonServiceStartTimeout
    -- ^ A timeout occurred
    --   while starting the service providing the VPN connection.
    | VpnConnectionStateReasonServiceStartFailed
    -- ^ Starting the service
    --   starting the service providing the VPN connection failed.
    | VpnConnectionStateReasonNoSecrets
    -- ^ Necessary secrets for the VPN
    --   connection were not provided.
    | VpnConnectionStateReasonLoginFailed
    -- ^ Authentication to the VPN
    --   server failed.
    | VpnConnectionStateReasonConnectionRemoved
    -- ^ The connection was
    --   deleted from settings.
    | AnotherVpnConnectionStateReason Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VpnConnectionStateReason -> ShowS
[VpnConnectionStateReason] -> ShowS
VpnConnectionStateReason -> String
(Int -> VpnConnectionStateReason -> ShowS)
-> (VpnConnectionStateReason -> String)
-> ([VpnConnectionStateReason] -> ShowS)
-> Show VpnConnectionStateReason
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VpnConnectionStateReason -> ShowS
showsPrec :: Int -> VpnConnectionStateReason -> ShowS
$cshow :: VpnConnectionStateReason -> String
show :: VpnConnectionStateReason -> String
$cshowList :: [VpnConnectionStateReason] -> ShowS
showList :: [VpnConnectionStateReason] -> ShowS
Show, VpnConnectionStateReason -> VpnConnectionStateReason -> Bool
(VpnConnectionStateReason -> VpnConnectionStateReason -> Bool)
-> (VpnConnectionStateReason -> VpnConnectionStateReason -> Bool)
-> Eq VpnConnectionStateReason
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VpnConnectionStateReason -> VpnConnectionStateReason -> Bool
== :: VpnConnectionStateReason -> VpnConnectionStateReason -> Bool
$c/= :: VpnConnectionStateReason -> VpnConnectionStateReason -> Bool
/= :: VpnConnectionStateReason -> VpnConnectionStateReason -> Bool
Eq)

instance P.Enum VpnConnectionStateReason where
    fromEnum :: VpnConnectionStateReason -> Int
fromEnum VpnConnectionStateReason
VpnConnectionStateReasonUnknown = Int
0
    fromEnum VpnConnectionStateReason
VpnConnectionStateReasonNone = Int
1
    fromEnum VpnConnectionStateReason
VpnConnectionStateReasonUserDisconnected = Int
2
    fromEnum VpnConnectionStateReason
VpnConnectionStateReasonDeviceDisconnected = Int
3
    fromEnum VpnConnectionStateReason
VpnConnectionStateReasonServiceStopped = Int
4
    fromEnum VpnConnectionStateReason
VpnConnectionStateReasonIpConfigInvalid = Int
5
    fromEnum VpnConnectionStateReason
VpnConnectionStateReasonConnectTimeout = Int
6
    fromEnum VpnConnectionStateReason
VpnConnectionStateReasonServiceStartTimeout = Int
7
    fromEnum VpnConnectionStateReason
VpnConnectionStateReasonServiceStartFailed = Int
8
    fromEnum VpnConnectionStateReason
VpnConnectionStateReasonNoSecrets = Int
9
    fromEnum VpnConnectionStateReason
VpnConnectionStateReasonLoginFailed = Int
10
    fromEnum VpnConnectionStateReason
VpnConnectionStateReasonConnectionRemoved = Int
11
    fromEnum (AnotherVpnConnectionStateReason Int
k) = Int
k

    toEnum :: Int -> VpnConnectionStateReason
toEnum Int
0 = VpnConnectionStateReason
VpnConnectionStateReasonUnknown
    toEnum Int
1 = VpnConnectionStateReason
VpnConnectionStateReasonNone
    toEnum Int
2 = VpnConnectionStateReason
VpnConnectionStateReasonUserDisconnected
    toEnum Int
3 = VpnConnectionStateReason
VpnConnectionStateReasonDeviceDisconnected
    toEnum Int
4 = VpnConnectionStateReason
VpnConnectionStateReasonServiceStopped
    toEnum Int
5 = VpnConnectionStateReason
VpnConnectionStateReasonIpConfigInvalid
    toEnum Int
6 = VpnConnectionStateReason
VpnConnectionStateReasonConnectTimeout
    toEnum Int
7 = VpnConnectionStateReason
VpnConnectionStateReasonServiceStartTimeout
    toEnum Int
8 = VpnConnectionStateReason
VpnConnectionStateReasonServiceStartFailed
    toEnum Int
9 = VpnConnectionStateReason
VpnConnectionStateReasonNoSecrets
    toEnum Int
10 = VpnConnectionStateReason
VpnConnectionStateReasonLoginFailed
    toEnum Int
11 = VpnConnectionStateReason
VpnConnectionStateReasonConnectionRemoved
    toEnum Int
k = Int -> VpnConnectionStateReason
AnotherVpnConnectionStateReason Int
k

instance P.Ord VpnConnectionStateReason where
    compare :: VpnConnectionStateReason -> VpnConnectionStateReason -> Ordering
compare VpnConnectionStateReason
a VpnConnectionStateReason
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VpnConnectionStateReason -> Int
forall a. Enum a => a -> Int
P.fromEnum VpnConnectionStateReason
a) (VpnConnectionStateReason -> Int
forall a. Enum a => a -> Int
P.fromEnum VpnConnectionStateReason
b)

type instance O.ParentTypes VpnConnectionStateReason = '[]
instance O.HasParentTypes VpnConnectionStateReason

foreign import ccall "nm_vpn_connection_state_reason_get_type" c_nm_vpn_connection_state_reason_get_type :: 
    IO GType

instance B.Types.TypedObject VpnConnectionStateReason where
    glibType :: IO GType
glibType = IO GType
c_nm_vpn_connection_state_reason_get_type

instance B.Types.BoxedEnum VpnConnectionStateReason

-- Enum VpnConnectionState
-- | VPN connection states
data VpnConnectionState = 
      VpnConnectionStateUnknown
    -- ^ The state of the VPN connection is
    --   unknown.
    | VpnConnectionStatePrepare
    -- ^ The VPN connection is preparing to
    --   connect.
    | VpnConnectionStateNeedAuth
    -- ^ The VPN connection needs authorization
    --   credentials.
    | VpnConnectionStateConnect
    -- ^ The VPN connection is being established.
    | VpnConnectionStateIpConfigGet
    -- ^ The VPN connection is getting an IP
    --   address.
    | VpnConnectionStateActivated
    -- ^ The VPN connection is active.
    | VpnConnectionStateFailed
    -- ^ The VPN connection failed.
    | VpnConnectionStateDisconnected
    -- ^ The VPN connection is disconnected.
    | AnotherVpnConnectionState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VpnConnectionState -> ShowS
[VpnConnectionState] -> ShowS
VpnConnectionState -> String
(Int -> VpnConnectionState -> ShowS)
-> (VpnConnectionState -> String)
-> ([VpnConnectionState] -> ShowS)
-> Show VpnConnectionState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VpnConnectionState -> ShowS
showsPrec :: Int -> VpnConnectionState -> ShowS
$cshow :: VpnConnectionState -> String
show :: VpnConnectionState -> String
$cshowList :: [VpnConnectionState] -> ShowS
showList :: [VpnConnectionState] -> ShowS
Show, VpnConnectionState -> VpnConnectionState -> Bool
(VpnConnectionState -> VpnConnectionState -> Bool)
-> (VpnConnectionState -> VpnConnectionState -> Bool)
-> Eq VpnConnectionState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VpnConnectionState -> VpnConnectionState -> Bool
== :: VpnConnectionState -> VpnConnectionState -> Bool
$c/= :: VpnConnectionState -> VpnConnectionState -> Bool
/= :: VpnConnectionState -> VpnConnectionState -> Bool
Eq)

instance P.Enum VpnConnectionState where
    fromEnum :: VpnConnectionState -> Int
fromEnum VpnConnectionState
VpnConnectionStateUnknown = Int
0
    fromEnum VpnConnectionState
VpnConnectionStatePrepare = Int
1
    fromEnum VpnConnectionState
VpnConnectionStateNeedAuth = Int
2
    fromEnum VpnConnectionState
VpnConnectionStateConnect = Int
3
    fromEnum VpnConnectionState
VpnConnectionStateIpConfigGet = Int
4
    fromEnum VpnConnectionState
VpnConnectionStateActivated = Int
5
    fromEnum VpnConnectionState
VpnConnectionStateFailed = Int
6
    fromEnum VpnConnectionState
VpnConnectionStateDisconnected = Int
7
    fromEnum (AnotherVpnConnectionState Int
k) = Int
k

    toEnum :: Int -> VpnConnectionState
toEnum Int
0 = VpnConnectionState
VpnConnectionStateUnknown
    toEnum Int
1 = VpnConnectionState
VpnConnectionStatePrepare
    toEnum Int
2 = VpnConnectionState
VpnConnectionStateNeedAuth
    toEnum Int
3 = VpnConnectionState
VpnConnectionStateConnect
    toEnum Int
4 = VpnConnectionState
VpnConnectionStateIpConfigGet
    toEnum Int
5 = VpnConnectionState
VpnConnectionStateActivated
    toEnum Int
6 = VpnConnectionState
VpnConnectionStateFailed
    toEnum Int
7 = VpnConnectionState
VpnConnectionStateDisconnected
    toEnum Int
k = Int -> VpnConnectionState
AnotherVpnConnectionState Int
k

instance P.Ord VpnConnectionState where
    compare :: VpnConnectionState -> VpnConnectionState -> Ordering
compare VpnConnectionState
a VpnConnectionState
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VpnConnectionState -> Int
forall a. Enum a => a -> Int
P.fromEnum VpnConnectionState
a) (VpnConnectionState -> Int
forall a. Enum a => a -> Int
P.fromEnum VpnConnectionState
b)

type instance O.ParentTypes VpnConnectionState = '[]
instance O.HasParentTypes VpnConnectionState

foreign import ccall "nm_vpn_connection_state_get_type" c_nm_vpn_connection_state_get_type :: 
    IO GType

instance B.Types.TypedObject VpnConnectionState where
    glibType :: IO GType
glibType = IO GType
c_nm_vpn_connection_state_get_type

instance B.Types.BoxedEnum VpnConnectionState

-- Enum VlanPriorityMap
-- | A selector for traffic priority maps; these map Linux SKB priorities
-- to 802.1p priorities used in VLANs.
data VlanPriorityMap = 
      VlanPriorityMapIngressMap
    -- ^ map for incoming data
    | VlanPriorityMapEgressMap
    -- ^ map for outgoing data
    | AnotherVlanPriorityMap Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VlanPriorityMap -> ShowS
[VlanPriorityMap] -> ShowS
VlanPriorityMap -> String
(Int -> VlanPriorityMap -> ShowS)
-> (VlanPriorityMap -> String)
-> ([VlanPriorityMap] -> ShowS)
-> Show VlanPriorityMap
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VlanPriorityMap -> ShowS
showsPrec :: Int -> VlanPriorityMap -> ShowS
$cshow :: VlanPriorityMap -> String
show :: VlanPriorityMap -> String
$cshowList :: [VlanPriorityMap] -> ShowS
showList :: [VlanPriorityMap] -> ShowS
Show, VlanPriorityMap -> VlanPriorityMap -> Bool
(VlanPriorityMap -> VlanPriorityMap -> Bool)
-> (VlanPriorityMap -> VlanPriorityMap -> Bool)
-> Eq VlanPriorityMap
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VlanPriorityMap -> VlanPriorityMap -> Bool
== :: VlanPriorityMap -> VlanPriorityMap -> Bool
$c/= :: VlanPriorityMap -> VlanPriorityMap -> Bool
/= :: VlanPriorityMap -> VlanPriorityMap -> Bool
Eq)

instance P.Enum VlanPriorityMap where
    fromEnum :: VlanPriorityMap -> Int
fromEnum VlanPriorityMap
VlanPriorityMapIngressMap = Int
0
    fromEnum VlanPriorityMap
VlanPriorityMapEgressMap = Int
1
    fromEnum (AnotherVlanPriorityMap Int
k) = Int
k

    toEnum :: Int -> VlanPriorityMap
toEnum Int
0 = VlanPriorityMap
VlanPriorityMapIngressMap
    toEnum Int
1 = VlanPriorityMap
VlanPriorityMapEgressMap
    toEnum Int
k = Int -> VlanPriorityMap
AnotherVlanPriorityMap Int
k

instance P.Ord VlanPriorityMap where
    compare :: VlanPriorityMap -> VlanPriorityMap -> Ordering
compare VlanPriorityMap
a VlanPriorityMap
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VlanPriorityMap -> Int
forall a. Enum a => a -> Int
P.fromEnum VlanPriorityMap
a) (VlanPriorityMap -> Int
forall a. Enum a => a -> Int
P.fromEnum VlanPriorityMap
b)

type instance O.ParentTypes VlanPriorityMap = '[]
instance O.HasParentTypes VlanPriorityMap

foreign import ccall "nm_vlan_priority_map_get_type" c_nm_vlan_priority_map_get_type :: 
    IO GType

instance B.Types.TypedObject VlanPriorityMap where
    glibType :: IO GType
glibType = IO GType
c_nm_vlan_priority_map_get_type

instance B.Types.BoxedEnum VlanPriorityMap

-- Enum VersionInfoCapability
-- | 'GI.NM.Enums.VersionInfoCapabilityUnused': a dummy capability. It has no meaning,
--   don\'t use it.
-- Currently no enum values are defined. These capabilities are exposed
-- on D-Bus in the \"VersionInfo\" bit field.
-- 
-- /Since: 1.42/
data VersionInfoCapability = 
      VersionInfoCapabilityUnused
    -- ^ /No description available in the introspection data./
    | AnotherVersionInfoCapability Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VersionInfoCapability -> ShowS
[VersionInfoCapability] -> ShowS
VersionInfoCapability -> String
(Int -> VersionInfoCapability -> ShowS)
-> (VersionInfoCapability -> String)
-> ([VersionInfoCapability] -> ShowS)
-> Show VersionInfoCapability
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VersionInfoCapability -> ShowS
showsPrec :: Int -> VersionInfoCapability -> ShowS
$cshow :: VersionInfoCapability -> String
show :: VersionInfoCapability -> String
$cshowList :: [VersionInfoCapability] -> ShowS
showList :: [VersionInfoCapability] -> ShowS
Show, VersionInfoCapability -> VersionInfoCapability -> Bool
(VersionInfoCapability -> VersionInfoCapability -> Bool)
-> (VersionInfoCapability -> VersionInfoCapability -> Bool)
-> Eq VersionInfoCapability
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VersionInfoCapability -> VersionInfoCapability -> Bool
== :: VersionInfoCapability -> VersionInfoCapability -> Bool
$c/= :: VersionInfoCapability -> VersionInfoCapability -> Bool
/= :: VersionInfoCapability -> VersionInfoCapability -> Bool
Eq)

instance P.Enum VersionInfoCapability where
    fromEnum :: VersionInfoCapability -> Int
fromEnum VersionInfoCapability
VersionInfoCapabilityUnused = Int
2147483647
    fromEnum (AnotherVersionInfoCapability Int
k) = Int
k

    toEnum :: Int -> VersionInfoCapability
toEnum Int
2147483647 = VersionInfoCapability
VersionInfoCapabilityUnused
    toEnum Int
k = Int -> VersionInfoCapability
AnotherVersionInfoCapability Int
k

instance P.Ord VersionInfoCapability where
    compare :: VersionInfoCapability -> VersionInfoCapability -> Ordering
compare VersionInfoCapability
a VersionInfoCapability
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VersionInfoCapability -> Int
forall a. Enum a => a -> Int
P.fromEnum VersionInfoCapability
a) (VersionInfoCapability -> Int
forall a. Enum a => a -> Int
P.fromEnum VersionInfoCapability
b)

type instance O.ParentTypes VersionInfoCapability = '[]
instance O.HasParentTypes VersionInfoCapability

foreign import ccall "nm_version_info_capability_get_type" c_nm_version_info_capability_get_type :: 
    IO GType

instance B.Types.TypedObject VersionInfoCapability where
    glibType :: IO GType
glibType = IO GType
c_nm_version_info_capability_get_type

instance B.Types.BoxedEnum VersionInfoCapability

-- Enum UtilsSecurityType
-- | Describes generic security mechanisms that 802.11 access points may offer.
-- Used with 'GI.NM.Functions.utilsSecurityValid' for checking whether a given access
-- point is compatible with a network device.
data UtilsSecurityType = 
      UtilsSecurityTypeInvalid
    -- ^ unknown or invalid security, placeholder and not used
    | UtilsSecurityTypeNone
    -- ^ unencrypted and open
    | UtilsSecurityTypeStaticWep
    -- ^ static WEP keys are used for encryption
    | UtilsSecurityTypeLeap
    -- ^ Cisco LEAP is used for authentication and for generating the
    -- dynamic WEP keys automatically
    | UtilsSecurityTypeDynamicWep
    -- ^ standard 802.1x is used for authentication and
    -- generating the dynamic WEP keys automatically
    | UtilsSecurityTypeWpaPsk
    -- ^ WPA1 is used with Pre-Shared Keys (PSK)
    | UtilsSecurityTypeWpaEnterprise
    -- ^ WPA1 is used with 802.1x authentication
    | UtilsSecurityTypeWpa2Psk
    -- ^ WPA2\/RSN is used with Pre-Shared Keys (PSK)
    | UtilsSecurityTypeWpa2Enterprise
    -- ^ WPA2 is used with 802.1x authentication
    | UtilsSecurityTypeSae
    -- ^ is used with WPA3 Enterprise
    | UtilsSecurityTypeOwe
    -- ^ is used with Enhanced Open
    | UtilsSecurityTypeWpa3SuiteB192
    -- ^ is used with WPA3 Enterprise Suite-B 192 bit mode. Since: 1.30.
    | AnotherUtilsSecurityType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> UtilsSecurityType -> ShowS
[UtilsSecurityType] -> ShowS
UtilsSecurityType -> String
(Int -> UtilsSecurityType -> ShowS)
-> (UtilsSecurityType -> String)
-> ([UtilsSecurityType] -> ShowS)
-> Show UtilsSecurityType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UtilsSecurityType -> ShowS
showsPrec :: Int -> UtilsSecurityType -> ShowS
$cshow :: UtilsSecurityType -> String
show :: UtilsSecurityType -> String
$cshowList :: [UtilsSecurityType] -> ShowS
showList :: [UtilsSecurityType] -> ShowS
Show, UtilsSecurityType -> UtilsSecurityType -> Bool
(UtilsSecurityType -> UtilsSecurityType -> Bool)
-> (UtilsSecurityType -> UtilsSecurityType -> Bool)
-> Eq UtilsSecurityType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UtilsSecurityType -> UtilsSecurityType -> Bool
== :: UtilsSecurityType -> UtilsSecurityType -> Bool
$c/= :: UtilsSecurityType -> UtilsSecurityType -> Bool
/= :: UtilsSecurityType -> UtilsSecurityType -> Bool
Eq)

instance P.Enum UtilsSecurityType where
    fromEnum :: UtilsSecurityType -> Int
fromEnum UtilsSecurityType
UtilsSecurityTypeInvalid = Int
0
    fromEnum UtilsSecurityType
UtilsSecurityTypeNone = Int
1
    fromEnum UtilsSecurityType
UtilsSecurityTypeStaticWep = Int
2
    fromEnum UtilsSecurityType
UtilsSecurityTypeLeap = Int
3
    fromEnum UtilsSecurityType
UtilsSecurityTypeDynamicWep = Int
4
    fromEnum UtilsSecurityType
UtilsSecurityTypeWpaPsk = Int
5
    fromEnum UtilsSecurityType
UtilsSecurityTypeWpaEnterprise = Int
6
    fromEnum UtilsSecurityType
UtilsSecurityTypeWpa2Psk = Int
7
    fromEnum UtilsSecurityType
UtilsSecurityTypeWpa2Enterprise = Int
8
    fromEnum UtilsSecurityType
UtilsSecurityTypeSae = Int
9
    fromEnum UtilsSecurityType
UtilsSecurityTypeOwe = Int
10
    fromEnum UtilsSecurityType
UtilsSecurityTypeWpa3SuiteB192 = Int
11
    fromEnum (AnotherUtilsSecurityType Int
k) = Int
k

    toEnum :: Int -> UtilsSecurityType
toEnum Int
0 = UtilsSecurityType
UtilsSecurityTypeInvalid
    toEnum Int
1 = UtilsSecurityType
UtilsSecurityTypeNone
    toEnum Int
2 = UtilsSecurityType
UtilsSecurityTypeStaticWep
    toEnum Int
3 = UtilsSecurityType
UtilsSecurityTypeLeap
    toEnum Int
4 = UtilsSecurityType
UtilsSecurityTypeDynamicWep
    toEnum Int
5 = UtilsSecurityType
UtilsSecurityTypeWpaPsk
    toEnum Int
6 = UtilsSecurityType
UtilsSecurityTypeWpaEnterprise
    toEnum Int
7 = UtilsSecurityType
UtilsSecurityTypeWpa2Psk
    toEnum Int
8 = UtilsSecurityType
UtilsSecurityTypeWpa2Enterprise
    toEnum Int
9 = UtilsSecurityType
UtilsSecurityTypeSae
    toEnum Int
10 = UtilsSecurityType
UtilsSecurityTypeOwe
    toEnum Int
11 = UtilsSecurityType
UtilsSecurityTypeWpa3SuiteB192
    toEnum Int
k = Int -> UtilsSecurityType
AnotherUtilsSecurityType Int
k

instance P.Ord UtilsSecurityType where
    compare :: UtilsSecurityType -> UtilsSecurityType -> Ordering
compare UtilsSecurityType
a UtilsSecurityType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (UtilsSecurityType -> Int
forall a. Enum a => a -> Int
P.fromEnum UtilsSecurityType
a) (UtilsSecurityType -> Int
forall a. Enum a => a -> Int
P.fromEnum UtilsSecurityType
b)

type instance O.ParentTypes UtilsSecurityType = '[]
instance O.HasParentTypes UtilsSecurityType

foreign import ccall "nm_utils_security_type_get_type" c_nm_utils_security_type_get_type :: 
    IO GType

instance B.Types.TypedObject UtilsSecurityType where
    glibType :: IO GType
glibType = IO GType
c_nm_utils_security_type_get_type

instance B.Types.BoxedEnum UtilsSecurityType

-- Enum Ternary
-- | An boolean value that can be overridden by a default.
-- 
-- /Since: 1.14/
data Ternary = 
      TernaryDefault
    -- ^ use the globally-configured default value.
    | TernaryFalse
    -- ^ the option is disabled.
    | TernaryTrue
    -- ^ the option is enabled.
    | AnotherTernary Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Ternary -> ShowS
[Ternary] -> ShowS
Ternary -> String
(Int -> Ternary -> ShowS)
-> (Ternary -> String) -> ([Ternary] -> ShowS) -> Show Ternary
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Ternary -> ShowS
showsPrec :: Int -> Ternary -> ShowS
$cshow :: Ternary -> String
show :: Ternary -> String
$cshowList :: [Ternary] -> ShowS
showList :: [Ternary] -> ShowS
Show, Ternary -> Ternary -> Bool
(Ternary -> Ternary -> Bool)
-> (Ternary -> Ternary -> Bool) -> Eq Ternary
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Ternary -> Ternary -> Bool
== :: Ternary -> Ternary -> Bool
$c/= :: Ternary -> Ternary -> Bool
/= :: Ternary -> Ternary -> Bool
Eq)

instance P.Enum Ternary where
    fromEnum :: Ternary -> Int
fromEnum Ternary
TernaryDefault = Int
-1
    fromEnum Ternary
TernaryFalse = Int
0
    fromEnum Ternary
TernaryTrue = Int
1
    fromEnum (AnotherTernary Int
k) = Int
k

    toEnum :: Int -> Ternary
toEnum Int
-1 = Ternary
TernaryDefault
    toEnum Int
0 = Ternary
TernaryFalse
    toEnum Int
1 = Ternary
TernaryTrue
    toEnum Int
k = Int -> Ternary
AnotherTernary Int
k

instance P.Ord Ternary where
    compare :: Ternary -> Ternary -> Ordering
compare Ternary
a Ternary
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Ternary -> Int
forall a. Enum a => a -> Int
P.fromEnum Ternary
a) (Ternary -> Int
forall a. Enum a => a -> Int
P.fromEnum Ternary
b)

type instance O.ParentTypes Ternary = '[]
instance O.HasParentTypes Ternary

foreign import ccall "nm_ternary_get_type" c_nm_ternary_get_type :: 
    IO GType

instance B.Types.TypedObject Ternary where
    glibType :: IO GType
glibType = IO GType
c_nm_ternary_get_type

instance B.Types.BoxedEnum Ternary

-- Enum State
-- | t'GI.NM.Enums.State' values indicate the current overall networking state.
data State = 
      StateUnknown
    -- ^ Networking state is unknown. This indicates a daemon error
    --    that makes it unable to reasonably assess the state. In such event the
    --    applications are expected to assume Internet connectivity might be present
    --    and not disable controls that require network access.
    --    The graphical shells may hide the network accessibility indicator altogether
    --    since no meaningful status indication can be provided.
    | StateAsleep
    -- ^ Networking is not enabled, the system is being suspended or
    --    resumed from suspend.
    | StateDisconnected
    -- ^ There is no active network connection.
    --    The graphical shell should indicate  no network connectivity and the
    --    applications should not attempt to access the network.
    | StateDisconnecting
    -- ^ Network connections are being cleaned up.
    --    The applications should tear down their network sessions.
    | StateConnecting
    -- ^ A network connection is being started
    --    The graphical shell should indicate the network is being connected while
    --    the applications should still make no attempts to connect the network.
    | StateConnectedLocal
    -- ^ There is only local IPv4 and\/or IPv6 connectivity,
    --    but no default route to access the Internet. The graphical shell should
    --    indicate no network connectivity.
    | StateConnectedSite
    -- ^ There is only site-wide IPv4 and\/or IPv6 connectivity.
    --    This means a default route is available, but the Internet connectivity check
    --    (see \"Connectivity\" property) did not succeed. The graphical shell should
    --    indicate limited network connectivity.
    | StateConnectedGlobal
    -- ^ There is global IPv4 and\/or IPv6 Internet connectivity
    --    This means the Internet connectivity check succeeded, the graphical shell should
    --    indicate full network connectivity.
    | AnotherState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> State -> ShowS
[State] -> ShowS
State -> String
(Int -> State -> ShowS)
-> (State -> String) -> ([State] -> ShowS) -> Show State
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> State -> ShowS
showsPrec :: Int -> State -> ShowS
$cshow :: State -> String
show :: State -> String
$cshowList :: [State] -> ShowS
showList :: [State] -> ShowS
Show, State -> State -> Bool
(State -> State -> Bool) -> (State -> State -> Bool) -> Eq State
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: State -> State -> Bool
== :: State -> State -> Bool
$c/= :: State -> State -> Bool
/= :: State -> State -> Bool
Eq)

instance P.Enum State where
    fromEnum :: State -> Int
fromEnum State
StateUnknown = Int
0
    fromEnum State
StateAsleep = Int
10
    fromEnum State
StateDisconnected = Int
20
    fromEnum State
StateDisconnecting = Int
30
    fromEnum State
StateConnecting = Int
40
    fromEnum State
StateConnectedLocal = Int
50
    fromEnum State
StateConnectedSite = Int
60
    fromEnum State
StateConnectedGlobal = Int
70
    fromEnum (AnotherState Int
k) = Int
k

    toEnum :: Int -> State
toEnum Int
0 = State
StateUnknown
    toEnum Int
10 = State
StateAsleep
    toEnum Int
20 = State
StateDisconnected
    toEnum Int
30 = State
StateDisconnecting
    toEnum Int
40 = State
StateConnecting
    toEnum Int
50 = State
StateConnectedLocal
    toEnum Int
60 = State
StateConnectedSite
    toEnum Int
70 = State
StateConnectedGlobal
    toEnum Int
k = Int -> State
AnotherState Int
k

instance P.Ord State where
    compare :: State -> State -> Ordering
compare State
a State
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (State -> Int
forall a. Enum a => a -> Int
P.fromEnum State
a) (State -> Int
forall a. Enum a => a -> Int
P.fromEnum State
b)

type instance O.ParentTypes State = '[]
instance O.HasParentTypes State

foreign import ccall "nm_state_get_type" c_nm_state_get_type :: 
    IO GType

instance B.Types.TypedObject State where
    glibType :: IO GType
glibType = IO GType
c_nm_state_get_type

instance B.Types.BoxedEnum State

-- Enum SriovVFVlanProtocol
-- | t'GI.NM.Enums.SriovVFVlanProtocol' indicates the VLAN protocol to use.
-- 
-- /Since: 1.14/
data SriovVFVlanProtocol = 
      SriovVFVlanProtocol1q
    -- ^ use 802.1Q
    | SriovVFVlanProtocol1ad
    -- ^ use 802.1ad
    | AnotherSriovVFVlanProtocol Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SriovVFVlanProtocol -> ShowS
[SriovVFVlanProtocol] -> ShowS
SriovVFVlanProtocol -> String
(Int -> SriovVFVlanProtocol -> ShowS)
-> (SriovVFVlanProtocol -> String)
-> ([SriovVFVlanProtocol] -> ShowS)
-> Show SriovVFVlanProtocol
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SriovVFVlanProtocol -> ShowS
showsPrec :: Int -> SriovVFVlanProtocol -> ShowS
$cshow :: SriovVFVlanProtocol -> String
show :: SriovVFVlanProtocol -> String
$cshowList :: [SriovVFVlanProtocol] -> ShowS
showList :: [SriovVFVlanProtocol] -> ShowS
Show, SriovVFVlanProtocol -> SriovVFVlanProtocol -> Bool
(SriovVFVlanProtocol -> SriovVFVlanProtocol -> Bool)
-> (SriovVFVlanProtocol -> SriovVFVlanProtocol -> Bool)
-> Eq SriovVFVlanProtocol
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SriovVFVlanProtocol -> SriovVFVlanProtocol -> Bool
== :: SriovVFVlanProtocol -> SriovVFVlanProtocol -> Bool
$c/= :: SriovVFVlanProtocol -> SriovVFVlanProtocol -> Bool
/= :: SriovVFVlanProtocol -> SriovVFVlanProtocol -> Bool
Eq)

instance P.Enum SriovVFVlanProtocol where
    fromEnum :: SriovVFVlanProtocol -> Int
fromEnum SriovVFVlanProtocol
SriovVFVlanProtocol1q = Int
0
    fromEnum SriovVFVlanProtocol
SriovVFVlanProtocol1ad = Int
1
    fromEnum (AnotherSriovVFVlanProtocol Int
k) = Int
k

    toEnum :: Int -> SriovVFVlanProtocol
toEnum Int
0 = SriovVFVlanProtocol
SriovVFVlanProtocol1q
    toEnum Int
1 = SriovVFVlanProtocol
SriovVFVlanProtocol1ad
    toEnum Int
k = Int -> SriovVFVlanProtocol
AnotherSriovVFVlanProtocol Int
k

instance P.Ord SriovVFVlanProtocol where
    compare :: SriovVFVlanProtocol -> SriovVFVlanProtocol -> Ordering
compare SriovVFVlanProtocol
a SriovVFVlanProtocol
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SriovVFVlanProtocol -> Int
forall a. Enum a => a -> Int
P.fromEnum SriovVFVlanProtocol
a) (SriovVFVlanProtocol -> Int
forall a. Enum a => a -> Int
P.fromEnum SriovVFVlanProtocol
b)

type instance O.ParentTypes SriovVFVlanProtocol = '[]
instance O.HasParentTypes SriovVFVlanProtocol

foreign import ccall "nm_sriov_vf_vlan_protocol_get_type" c_nm_sriov_vf_vlan_protocol_get_type :: 
    IO GType

instance B.Types.TypedObject SriovVFVlanProtocol where
    glibType :: IO GType
glibType = IO GType
c_nm_sriov_vf_vlan_protocol_get_type

instance B.Types.BoxedEnum SriovVFVlanProtocol

-- Enum SriovEswitchMode
-- | /No description available in the introspection data./
-- 
-- /Since: 1.46/
data SriovEswitchMode = 
      SriovEswitchModePreserve
    -- ^ don\'t modify current eswitch mode
    | SriovEswitchModeLegacy
    -- ^ use legacy SRIOV
    | SriovEswitchModeSwitchdev
    -- ^ use switchdev mode
    | AnotherSriovEswitchMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SriovEswitchMode -> ShowS
[SriovEswitchMode] -> ShowS
SriovEswitchMode -> String
(Int -> SriovEswitchMode -> ShowS)
-> (SriovEswitchMode -> String)
-> ([SriovEswitchMode] -> ShowS)
-> Show SriovEswitchMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SriovEswitchMode -> ShowS
showsPrec :: Int -> SriovEswitchMode -> ShowS
$cshow :: SriovEswitchMode -> String
show :: SriovEswitchMode -> String
$cshowList :: [SriovEswitchMode] -> ShowS
showList :: [SriovEswitchMode] -> ShowS
Show, SriovEswitchMode -> SriovEswitchMode -> Bool
(SriovEswitchMode -> SriovEswitchMode -> Bool)
-> (SriovEswitchMode -> SriovEswitchMode -> Bool)
-> Eq SriovEswitchMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SriovEswitchMode -> SriovEswitchMode -> Bool
== :: SriovEswitchMode -> SriovEswitchMode -> Bool
$c/= :: SriovEswitchMode -> SriovEswitchMode -> Bool
/= :: SriovEswitchMode -> SriovEswitchMode -> Bool
Eq)

instance P.Enum SriovEswitchMode where
    fromEnum :: SriovEswitchMode -> Int
fromEnum SriovEswitchMode
SriovEswitchModePreserve = Int
-1
    fromEnum SriovEswitchMode
SriovEswitchModeLegacy = Int
0
    fromEnum SriovEswitchMode
SriovEswitchModeSwitchdev = Int
1
    fromEnum (AnotherSriovEswitchMode Int
k) = Int
k

    toEnum :: Int -> SriovEswitchMode
toEnum Int
-1 = SriovEswitchMode
SriovEswitchModePreserve
    toEnum Int
0 = SriovEswitchMode
SriovEswitchModeLegacy
    toEnum Int
1 = SriovEswitchMode
SriovEswitchModeSwitchdev
    toEnum Int
k = Int -> SriovEswitchMode
AnotherSriovEswitchMode Int
k

instance P.Ord SriovEswitchMode where
    compare :: SriovEswitchMode -> SriovEswitchMode -> Ordering
compare SriovEswitchMode
a SriovEswitchMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SriovEswitchMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SriovEswitchMode
a) (SriovEswitchMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SriovEswitchMode
b)

type instance O.ParentTypes SriovEswitchMode = '[]
instance O.HasParentTypes SriovEswitchMode

foreign import ccall "nm_sriov_eswitch_mode_get_type" c_nm_sriov_eswitch_mode_get_type :: 
    IO GType

instance B.Types.TypedObject SriovEswitchMode where
    glibType :: IO GType
glibType = IO GType
c_nm_sriov_eswitch_mode_get_type

instance B.Types.BoxedEnum SriovEswitchMode

-- Enum SriovEswitchInlineMode
-- | /No description available in the introspection data./
-- 
-- /Since: 1.46/
data SriovEswitchInlineMode = 
      SriovEswitchInlineModePreserve
    -- ^ don\'t modify current inline-mode
    | SriovEswitchInlineModeNone
    -- ^ don\'t use inline mode
    | SriovEswitchInlineModeLink
    -- ^ L2 mode
    | SriovEswitchInlineModeNetwork
    -- ^ L3 mode
    | SriovEswitchInlineModeTransport
    -- ^ L4 mode
    | AnotherSriovEswitchInlineMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SriovEswitchInlineMode -> ShowS
[SriovEswitchInlineMode] -> ShowS
SriovEswitchInlineMode -> String
(Int -> SriovEswitchInlineMode -> ShowS)
-> (SriovEswitchInlineMode -> String)
-> ([SriovEswitchInlineMode] -> ShowS)
-> Show SriovEswitchInlineMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SriovEswitchInlineMode -> ShowS
showsPrec :: Int -> SriovEswitchInlineMode -> ShowS
$cshow :: SriovEswitchInlineMode -> String
show :: SriovEswitchInlineMode -> String
$cshowList :: [SriovEswitchInlineMode] -> ShowS
showList :: [SriovEswitchInlineMode] -> ShowS
Show, SriovEswitchInlineMode -> SriovEswitchInlineMode -> Bool
(SriovEswitchInlineMode -> SriovEswitchInlineMode -> Bool)
-> (SriovEswitchInlineMode -> SriovEswitchInlineMode -> Bool)
-> Eq SriovEswitchInlineMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SriovEswitchInlineMode -> SriovEswitchInlineMode -> Bool
== :: SriovEswitchInlineMode -> SriovEswitchInlineMode -> Bool
$c/= :: SriovEswitchInlineMode -> SriovEswitchInlineMode -> Bool
/= :: SriovEswitchInlineMode -> SriovEswitchInlineMode -> Bool
Eq)

instance P.Enum SriovEswitchInlineMode where
    fromEnum :: SriovEswitchInlineMode -> Int
fromEnum SriovEswitchInlineMode
SriovEswitchInlineModePreserve = Int
-1
    fromEnum SriovEswitchInlineMode
SriovEswitchInlineModeNone = Int
0
    fromEnum SriovEswitchInlineMode
SriovEswitchInlineModeLink = Int
1
    fromEnum SriovEswitchInlineMode
SriovEswitchInlineModeNetwork = Int
2
    fromEnum SriovEswitchInlineMode
SriovEswitchInlineModeTransport = Int
3
    fromEnum (AnotherSriovEswitchInlineMode Int
k) = Int
k

    toEnum :: Int -> SriovEswitchInlineMode
toEnum Int
-1 = SriovEswitchInlineMode
SriovEswitchInlineModePreserve
    toEnum Int
0 = SriovEswitchInlineMode
SriovEswitchInlineModeNone
    toEnum Int
1 = SriovEswitchInlineMode
SriovEswitchInlineModeLink
    toEnum Int
2 = SriovEswitchInlineMode
SriovEswitchInlineModeNetwork
    toEnum Int
3 = SriovEswitchInlineMode
SriovEswitchInlineModeTransport
    toEnum Int
k = Int -> SriovEswitchInlineMode
AnotherSriovEswitchInlineMode Int
k

instance P.Ord SriovEswitchInlineMode where
    compare :: SriovEswitchInlineMode -> SriovEswitchInlineMode -> Ordering
compare SriovEswitchInlineMode
a SriovEswitchInlineMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SriovEswitchInlineMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SriovEswitchInlineMode
a) (SriovEswitchInlineMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SriovEswitchInlineMode
b)

type instance O.ParentTypes SriovEswitchInlineMode = '[]
instance O.HasParentTypes SriovEswitchInlineMode

foreign import ccall "nm_sriov_eswitch_inline_mode_get_type" c_nm_sriov_eswitch_inline_mode_get_type :: 
    IO GType

instance B.Types.TypedObject SriovEswitchInlineMode where
    glibType :: IO GType
glibType = IO GType
c_nm_sriov_eswitch_inline_mode_get_type

instance B.Types.BoxedEnum SriovEswitchInlineMode

-- Enum SriovEswitchEncapMode
-- | /No description available in the introspection data./
-- 
-- /Since: 1.46/
data SriovEswitchEncapMode = 
      SriovEswitchEncapModePreserve
    -- ^ don\'t modify current encap-mode
    | SriovEswitchEncapModeNone
    -- ^ disable encapsulation mode
    | SriovEswitchEncapModeBasic
    -- ^ enable encapsulation mode
    | AnotherSriovEswitchEncapMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SriovEswitchEncapMode -> ShowS
[SriovEswitchEncapMode] -> ShowS
SriovEswitchEncapMode -> String
(Int -> SriovEswitchEncapMode -> ShowS)
-> (SriovEswitchEncapMode -> String)
-> ([SriovEswitchEncapMode] -> ShowS)
-> Show SriovEswitchEncapMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SriovEswitchEncapMode -> ShowS
showsPrec :: Int -> SriovEswitchEncapMode -> ShowS
$cshow :: SriovEswitchEncapMode -> String
show :: SriovEswitchEncapMode -> String
$cshowList :: [SriovEswitchEncapMode] -> ShowS
showList :: [SriovEswitchEncapMode] -> ShowS
Show, SriovEswitchEncapMode -> SriovEswitchEncapMode -> Bool
(SriovEswitchEncapMode -> SriovEswitchEncapMode -> Bool)
-> (SriovEswitchEncapMode -> SriovEswitchEncapMode -> Bool)
-> Eq SriovEswitchEncapMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SriovEswitchEncapMode -> SriovEswitchEncapMode -> Bool
== :: SriovEswitchEncapMode -> SriovEswitchEncapMode -> Bool
$c/= :: SriovEswitchEncapMode -> SriovEswitchEncapMode -> Bool
/= :: SriovEswitchEncapMode -> SriovEswitchEncapMode -> Bool
Eq)

instance P.Enum SriovEswitchEncapMode where
    fromEnum :: SriovEswitchEncapMode -> Int
fromEnum SriovEswitchEncapMode
SriovEswitchEncapModePreserve = Int
-1
    fromEnum SriovEswitchEncapMode
SriovEswitchEncapModeNone = Int
0
    fromEnum SriovEswitchEncapMode
SriovEswitchEncapModeBasic = Int
1
    fromEnum (AnotherSriovEswitchEncapMode Int
k) = Int
k

    toEnum :: Int -> SriovEswitchEncapMode
toEnum Int
-1 = SriovEswitchEncapMode
SriovEswitchEncapModePreserve
    toEnum Int
0 = SriovEswitchEncapMode
SriovEswitchEncapModeNone
    toEnum Int
1 = SriovEswitchEncapMode
SriovEswitchEncapModeBasic
    toEnum Int
k = Int -> SriovEswitchEncapMode
AnotherSriovEswitchEncapMode Int
k

instance P.Ord SriovEswitchEncapMode where
    compare :: SriovEswitchEncapMode -> SriovEswitchEncapMode -> Ordering
compare SriovEswitchEncapMode
a SriovEswitchEncapMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SriovEswitchEncapMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SriovEswitchEncapMode
a) (SriovEswitchEncapMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SriovEswitchEncapMode
b)

type instance O.ParentTypes SriovEswitchEncapMode = '[]
instance O.HasParentTypes SriovEswitchEncapMode

foreign import ccall "nm_sriov_eswitch_encap_mode_get_type" c_nm_sriov_eswitch_encap_mode_get_type :: 
    IO GType

instance B.Types.TypedObject SriovEswitchEncapMode where
    glibType :: IO GType
glibType = IO GType
c_nm_sriov_eswitch_encap_mode_get_type

instance B.Types.BoxedEnum SriovEswitchEncapMode

-- Enum SettingsError
-- | Errors related to the settings\/persistent configuration interface of
-- NetworkManager.
-- 
-- These may be returned from t'GI.NM.Objects.Client.Client' methods that invoke D-Bus operations on
-- the \"org.freedesktop.NetworkManager.Settings\" interface, and correspond to
-- D-Bus errors in that namespace.
data SettingsError = 
      SettingsErrorFailed
    -- ^ unknown or unclassified error
    | SettingsErrorPermissionDenied
    -- ^ permission denied
    | SettingsErrorNotSupported
    -- ^ the requested operation is not supported by any
    --   active settings backend
    | SettingsErrorInvalidConnection
    -- ^ the connection was invalid
    | SettingsErrorReadOnlyConnection
    -- ^ attempted to modify a read-only connection
    | SettingsErrorUuidExists
    -- ^ a connection with that UUID already exists
    | SettingsErrorInvalidHostname
    -- ^ attempted to set an invalid hostname
    | SettingsErrorInvalidArguments
    -- ^ invalid arguments
    | SettingsErrorVersionIdMismatch
    -- ^ The profile\'s VersionId mismatched
    --   and the update is rejected. See the \"version-id\" argument to @/Update2()/@
    --   method. Since 1.44.
    | SettingsErrorNotSupportedByPlugin
    -- ^ the requested operation is not
    --   supported by the settings plugin currently in use for the specified object.
    --   Since: 1.44.
    | AnotherSettingsError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingsError -> ShowS
[SettingsError] -> ShowS
SettingsError -> String
(Int -> SettingsError -> ShowS)
-> (SettingsError -> String)
-> ([SettingsError] -> ShowS)
-> Show SettingsError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingsError -> ShowS
showsPrec :: Int -> SettingsError -> ShowS
$cshow :: SettingsError -> String
show :: SettingsError -> String
$cshowList :: [SettingsError] -> ShowS
showList :: [SettingsError] -> ShowS
Show, SettingsError -> SettingsError -> Bool
(SettingsError -> SettingsError -> Bool)
-> (SettingsError -> SettingsError -> Bool) -> Eq SettingsError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingsError -> SettingsError -> Bool
== :: SettingsError -> SettingsError -> Bool
$c/= :: SettingsError -> SettingsError -> Bool
/= :: SettingsError -> SettingsError -> Bool
Eq)

instance P.Enum SettingsError where
    fromEnum :: SettingsError -> Int
fromEnum SettingsError
SettingsErrorFailed = Int
0
    fromEnum SettingsError
SettingsErrorPermissionDenied = Int
1
    fromEnum SettingsError
SettingsErrorNotSupported = Int
2
    fromEnum SettingsError
SettingsErrorInvalidConnection = Int
3
    fromEnum SettingsError
SettingsErrorReadOnlyConnection = Int
4
    fromEnum SettingsError
SettingsErrorUuidExists = Int
5
    fromEnum SettingsError
SettingsErrorInvalidHostname = Int
6
    fromEnum SettingsError
SettingsErrorInvalidArguments = Int
7
    fromEnum SettingsError
SettingsErrorVersionIdMismatch = Int
8
    fromEnum SettingsError
SettingsErrorNotSupportedByPlugin = Int
9
    fromEnum (AnotherSettingsError Int
k) = Int
k

    toEnum :: Int -> SettingsError
toEnum Int
0 = SettingsError
SettingsErrorFailed
    toEnum Int
1 = SettingsError
SettingsErrorPermissionDenied
    toEnum Int
2 = SettingsError
SettingsErrorNotSupported
    toEnum Int
3 = SettingsError
SettingsErrorInvalidConnection
    toEnum Int
4 = SettingsError
SettingsErrorReadOnlyConnection
    toEnum Int
5 = SettingsError
SettingsErrorUuidExists
    toEnum Int
6 = SettingsError
SettingsErrorInvalidHostname
    toEnum Int
7 = SettingsError
SettingsErrorInvalidArguments
    toEnum Int
8 = SettingsError
SettingsErrorVersionIdMismatch
    toEnum Int
9 = SettingsError
SettingsErrorNotSupportedByPlugin
    toEnum Int
k = Int -> SettingsError
AnotherSettingsError Int
k

instance P.Ord SettingsError where
    compare :: SettingsError -> SettingsError -> Ordering
compare SettingsError
a SettingsError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingsError -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingsError
a) (SettingsError -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingsError
b)

instance GErrorClass SettingsError where
    gerrorClassDomain :: SettingsError -> Text
gerrorClassDomain SettingsError
_ = Text
"nm-settings-error-quark"

-- | Catch exceptions of type `SettingsError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchSettingsError ::
    IO a ->
    (SettingsError -> GErrorMessage -> IO a) ->
    IO a
catchSettingsError :: forall a. IO a -> (SettingsError -> Text -> IO a) -> IO a
catchSettingsError = IO a -> (SettingsError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `SettingsError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleSettingsError ::
    (SettingsError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleSettingsError :: forall a. (SettingsError -> Text -> IO a) -> IO a -> IO a
handleSettingsError = (SettingsError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes SettingsError = '[]
instance O.HasParentTypes SettingsError

foreign import ccall "nm_settings_error_get_type" c_nm_settings_error_get_type :: 
    IO GType

instance B.Types.TypedObject SettingsError where
    glibType :: IO GType
glibType = IO GType
c_nm_settings_error_get_type

instance B.Types.BoxedEnum SettingsError

-- Enum SettingWirelessSecurityPmf
-- | These flags indicate whether PMF must be enabled.
-- 
-- /Since: 1.10/
data SettingWirelessSecurityPmf = 
      SettingWirelessSecurityPmfDefault
    -- ^ use the default value
    | SettingWirelessSecurityPmfDisable
    -- ^ disable PMF
    | SettingWirelessSecurityPmfOptional
    -- ^ enable PMF if the supplicant and the AP support it
    | SettingWirelessSecurityPmfRequired
    -- ^ require PMF and fail if not available
    | AnotherSettingWirelessSecurityPmf Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingWirelessSecurityPmf -> ShowS
[SettingWirelessSecurityPmf] -> ShowS
SettingWirelessSecurityPmf -> String
(Int -> SettingWirelessSecurityPmf -> ShowS)
-> (SettingWirelessSecurityPmf -> String)
-> ([SettingWirelessSecurityPmf] -> ShowS)
-> Show SettingWirelessSecurityPmf
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingWirelessSecurityPmf -> ShowS
showsPrec :: Int -> SettingWirelessSecurityPmf -> ShowS
$cshow :: SettingWirelessSecurityPmf -> String
show :: SettingWirelessSecurityPmf -> String
$cshowList :: [SettingWirelessSecurityPmf] -> ShowS
showList :: [SettingWirelessSecurityPmf] -> ShowS
Show, SettingWirelessSecurityPmf -> SettingWirelessSecurityPmf -> Bool
(SettingWirelessSecurityPmf -> SettingWirelessSecurityPmf -> Bool)
-> (SettingWirelessSecurityPmf
    -> SettingWirelessSecurityPmf -> Bool)
-> Eq SettingWirelessSecurityPmf
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingWirelessSecurityPmf -> SettingWirelessSecurityPmf -> Bool
== :: SettingWirelessSecurityPmf -> SettingWirelessSecurityPmf -> Bool
$c/= :: SettingWirelessSecurityPmf -> SettingWirelessSecurityPmf -> Bool
/= :: SettingWirelessSecurityPmf -> SettingWirelessSecurityPmf -> Bool
Eq)

instance P.Enum SettingWirelessSecurityPmf where
    fromEnum :: SettingWirelessSecurityPmf -> Int
fromEnum SettingWirelessSecurityPmf
SettingWirelessSecurityPmfDefault = Int
0
    fromEnum SettingWirelessSecurityPmf
SettingWirelessSecurityPmfDisable = Int
1
    fromEnum SettingWirelessSecurityPmf
SettingWirelessSecurityPmfOptional = Int
2
    fromEnum SettingWirelessSecurityPmf
SettingWirelessSecurityPmfRequired = Int
3
    fromEnum (AnotherSettingWirelessSecurityPmf Int
k) = Int
k

    toEnum :: Int -> SettingWirelessSecurityPmf
toEnum Int
0 = SettingWirelessSecurityPmf
SettingWirelessSecurityPmfDefault
    toEnum Int
1 = SettingWirelessSecurityPmf
SettingWirelessSecurityPmfDisable
    toEnum Int
2 = SettingWirelessSecurityPmf
SettingWirelessSecurityPmfOptional
    toEnum Int
3 = SettingWirelessSecurityPmf
SettingWirelessSecurityPmfRequired
    toEnum Int
k = Int -> SettingWirelessSecurityPmf
AnotherSettingWirelessSecurityPmf Int
k

instance P.Ord SettingWirelessSecurityPmf where
    compare :: SettingWirelessSecurityPmf
-> SettingWirelessSecurityPmf -> Ordering
compare SettingWirelessSecurityPmf
a SettingWirelessSecurityPmf
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingWirelessSecurityPmf -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingWirelessSecurityPmf
a) (SettingWirelessSecurityPmf -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingWirelessSecurityPmf
b)

type instance O.ParentTypes SettingWirelessSecurityPmf = '[]
instance O.HasParentTypes SettingWirelessSecurityPmf

foreign import ccall "nm_setting_wireless_security_pmf_get_type" c_nm_setting_wireless_security_pmf_get_type :: 
    IO GType

instance B.Types.TypedObject SettingWirelessSecurityPmf where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_wireless_security_pmf_get_type

instance B.Types.BoxedEnum SettingWirelessSecurityPmf

-- Enum SettingWirelessSecurityFils
-- | These flags indicate whether FILS must be enabled.
-- 
-- /Since: 1.12/
data SettingWirelessSecurityFils = 
      SettingWirelessSecurityFilsDefault
    -- ^ use the default value
    | SettingWirelessSecurityFilsDisable
    -- ^ disable FILS
    | SettingWirelessSecurityFilsOptional
    -- ^ enable FILS if the supplicant and the AP support it
    | SettingWirelessSecurityFilsRequired
    -- ^ require FILS and fail if not available
    | AnotherSettingWirelessSecurityFils Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingWirelessSecurityFils -> ShowS
[SettingWirelessSecurityFils] -> ShowS
SettingWirelessSecurityFils -> String
(Int -> SettingWirelessSecurityFils -> ShowS)
-> (SettingWirelessSecurityFils -> String)
-> ([SettingWirelessSecurityFils] -> ShowS)
-> Show SettingWirelessSecurityFils
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingWirelessSecurityFils -> ShowS
showsPrec :: Int -> SettingWirelessSecurityFils -> ShowS
$cshow :: SettingWirelessSecurityFils -> String
show :: SettingWirelessSecurityFils -> String
$cshowList :: [SettingWirelessSecurityFils] -> ShowS
showList :: [SettingWirelessSecurityFils] -> ShowS
Show, SettingWirelessSecurityFils -> SettingWirelessSecurityFils -> Bool
(SettingWirelessSecurityFils
 -> SettingWirelessSecurityFils -> Bool)
-> (SettingWirelessSecurityFils
    -> SettingWirelessSecurityFils -> Bool)
-> Eq SettingWirelessSecurityFils
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingWirelessSecurityFils -> SettingWirelessSecurityFils -> Bool
== :: SettingWirelessSecurityFils -> SettingWirelessSecurityFils -> Bool
$c/= :: SettingWirelessSecurityFils -> SettingWirelessSecurityFils -> Bool
/= :: SettingWirelessSecurityFils -> SettingWirelessSecurityFils -> Bool
Eq)

instance P.Enum SettingWirelessSecurityFils where
    fromEnum :: SettingWirelessSecurityFils -> Int
fromEnum SettingWirelessSecurityFils
SettingWirelessSecurityFilsDefault = Int
0
    fromEnum SettingWirelessSecurityFils
SettingWirelessSecurityFilsDisable = Int
1
    fromEnum SettingWirelessSecurityFils
SettingWirelessSecurityFilsOptional = Int
2
    fromEnum SettingWirelessSecurityFils
SettingWirelessSecurityFilsRequired = Int
3
    fromEnum (AnotherSettingWirelessSecurityFils Int
k) = Int
k

    toEnum :: Int -> SettingWirelessSecurityFils
toEnum Int
0 = SettingWirelessSecurityFils
SettingWirelessSecurityFilsDefault
    toEnum Int
1 = SettingWirelessSecurityFils
SettingWirelessSecurityFilsDisable
    toEnum Int
2 = SettingWirelessSecurityFils
SettingWirelessSecurityFilsOptional
    toEnum Int
3 = SettingWirelessSecurityFils
SettingWirelessSecurityFilsRequired
    toEnum Int
k = Int -> SettingWirelessSecurityFils
AnotherSettingWirelessSecurityFils Int
k

instance P.Ord SettingWirelessSecurityFils where
    compare :: SettingWirelessSecurityFils
-> SettingWirelessSecurityFils -> Ordering
compare SettingWirelessSecurityFils
a SettingWirelessSecurityFils
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingWirelessSecurityFils -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingWirelessSecurityFils
a) (SettingWirelessSecurityFils -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingWirelessSecurityFils
b)

type instance O.ParentTypes SettingWirelessSecurityFils = '[]
instance O.HasParentTypes SettingWirelessSecurityFils

foreign import ccall "nm_setting_wireless_security_fils_get_type" c_nm_setting_wireless_security_fils_get_type :: 
    IO GType

instance B.Types.TypedObject SettingWirelessSecurityFils where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_wireless_security_fils_get_type

instance B.Types.BoxedEnum SettingWirelessSecurityFils

-- Enum SettingWirelessPowersave
-- | These flags indicate whether wireless powersave must be enabled.
-- 
-- /Since: 1.2/
data SettingWirelessPowersave = 
      SettingWirelessPowersaveDefault
    -- ^ use the default value
    | SettingWirelessPowersaveIgnore
    -- ^ don\'t touch existing setting
    | SettingWirelessPowersaveDisable
    -- ^ disable powersave
    | SettingWirelessPowersaveEnable
    -- ^ enable powersave
    | AnotherSettingWirelessPowersave Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingWirelessPowersave -> ShowS
[SettingWirelessPowersave] -> ShowS
SettingWirelessPowersave -> String
(Int -> SettingWirelessPowersave -> ShowS)
-> (SettingWirelessPowersave -> String)
-> ([SettingWirelessPowersave] -> ShowS)
-> Show SettingWirelessPowersave
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingWirelessPowersave -> ShowS
showsPrec :: Int -> SettingWirelessPowersave -> ShowS
$cshow :: SettingWirelessPowersave -> String
show :: SettingWirelessPowersave -> String
$cshowList :: [SettingWirelessPowersave] -> ShowS
showList :: [SettingWirelessPowersave] -> ShowS
Show, SettingWirelessPowersave -> SettingWirelessPowersave -> Bool
(SettingWirelessPowersave -> SettingWirelessPowersave -> Bool)
-> (SettingWirelessPowersave -> SettingWirelessPowersave -> Bool)
-> Eq SettingWirelessPowersave
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingWirelessPowersave -> SettingWirelessPowersave -> Bool
== :: SettingWirelessPowersave -> SettingWirelessPowersave -> Bool
$c/= :: SettingWirelessPowersave -> SettingWirelessPowersave -> Bool
/= :: SettingWirelessPowersave -> SettingWirelessPowersave -> Bool
Eq)

instance P.Enum SettingWirelessPowersave where
    fromEnum :: SettingWirelessPowersave -> Int
fromEnum SettingWirelessPowersave
SettingWirelessPowersaveDefault = Int
0
    fromEnum SettingWirelessPowersave
SettingWirelessPowersaveIgnore = Int
1
    fromEnum SettingWirelessPowersave
SettingWirelessPowersaveDisable = Int
2
    fromEnum SettingWirelessPowersave
SettingWirelessPowersaveEnable = Int
3
    fromEnum (AnotherSettingWirelessPowersave Int
k) = Int
k

    toEnum :: Int -> SettingWirelessPowersave
toEnum Int
0 = SettingWirelessPowersave
SettingWirelessPowersaveDefault
    toEnum Int
1 = SettingWirelessPowersave
SettingWirelessPowersaveIgnore
    toEnum Int
2 = SettingWirelessPowersave
SettingWirelessPowersaveDisable
    toEnum Int
3 = SettingWirelessPowersave
SettingWirelessPowersaveEnable
    toEnum Int
k = Int -> SettingWirelessPowersave
AnotherSettingWirelessPowersave Int
k

instance P.Ord SettingWirelessPowersave where
    compare :: SettingWirelessPowersave -> SettingWirelessPowersave -> Ordering
compare SettingWirelessPowersave
a SettingWirelessPowersave
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingWirelessPowersave -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingWirelessPowersave
a) (SettingWirelessPowersave -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingWirelessPowersave
b)

type instance O.ParentTypes SettingWirelessPowersave = '[]
instance O.HasParentTypes SettingWirelessPowersave

foreign import ccall "nm_setting_wireless_powersave_get_type" c_nm_setting_wireless_powersave_get_type :: 
    IO GType

instance B.Types.TypedObject SettingWirelessPowersave where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_wireless_powersave_get_type

instance B.Types.BoxedEnum SettingWirelessPowersave

-- Enum SettingWirelessChannelWidth
-- | Indicates the wireless channel width.
-- 
-- /Since: 1.50/
data SettingWirelessChannelWidth = 
      SettingWirelessChannelWidthAuto
    -- ^ automatically determine the width
    | SettingWirelessChannelWidth20mhz
    -- ^ use a 20MHz channel width
    | SettingWirelessChannelWidth40mhz
    -- ^ use a 40MHz channel width
    | SettingWirelessChannelWidth80mhz
    -- ^ use a 80MHz channel width
    | AnotherSettingWirelessChannelWidth Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingWirelessChannelWidth -> ShowS
[SettingWirelessChannelWidth] -> ShowS
SettingWirelessChannelWidth -> String
(Int -> SettingWirelessChannelWidth -> ShowS)
-> (SettingWirelessChannelWidth -> String)
-> ([SettingWirelessChannelWidth] -> ShowS)
-> Show SettingWirelessChannelWidth
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingWirelessChannelWidth -> ShowS
showsPrec :: Int -> SettingWirelessChannelWidth -> ShowS
$cshow :: SettingWirelessChannelWidth -> String
show :: SettingWirelessChannelWidth -> String
$cshowList :: [SettingWirelessChannelWidth] -> ShowS
showList :: [SettingWirelessChannelWidth] -> ShowS
Show, SettingWirelessChannelWidth -> SettingWirelessChannelWidth -> Bool
(SettingWirelessChannelWidth
 -> SettingWirelessChannelWidth -> Bool)
-> (SettingWirelessChannelWidth
    -> SettingWirelessChannelWidth -> Bool)
-> Eq SettingWirelessChannelWidth
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingWirelessChannelWidth -> SettingWirelessChannelWidth -> Bool
== :: SettingWirelessChannelWidth -> SettingWirelessChannelWidth -> Bool
$c/= :: SettingWirelessChannelWidth -> SettingWirelessChannelWidth -> Bool
/= :: SettingWirelessChannelWidth -> SettingWirelessChannelWidth -> Bool
Eq)

instance P.Enum SettingWirelessChannelWidth where
    fromEnum :: SettingWirelessChannelWidth -> Int
fromEnum SettingWirelessChannelWidth
SettingWirelessChannelWidthAuto = Int
0
    fromEnum SettingWirelessChannelWidth
SettingWirelessChannelWidth20mhz = Int
20
    fromEnum SettingWirelessChannelWidth
SettingWirelessChannelWidth40mhz = Int
40
    fromEnum SettingWirelessChannelWidth
SettingWirelessChannelWidth80mhz = Int
80
    fromEnum (AnotherSettingWirelessChannelWidth Int
k) = Int
k

    toEnum :: Int -> SettingWirelessChannelWidth
toEnum Int
0 = SettingWirelessChannelWidth
SettingWirelessChannelWidthAuto
    toEnum Int
20 = SettingWirelessChannelWidth
SettingWirelessChannelWidth20mhz
    toEnum Int
40 = SettingWirelessChannelWidth
SettingWirelessChannelWidth40mhz
    toEnum Int
80 = SettingWirelessChannelWidth
SettingWirelessChannelWidth80mhz
    toEnum Int
k = Int -> SettingWirelessChannelWidth
AnotherSettingWirelessChannelWidth Int
k

instance P.Ord SettingWirelessChannelWidth where
    compare :: SettingWirelessChannelWidth
-> SettingWirelessChannelWidth -> Ordering
compare SettingWirelessChannelWidth
a SettingWirelessChannelWidth
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingWirelessChannelWidth -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingWirelessChannelWidth
a) (SettingWirelessChannelWidth -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingWirelessChannelWidth
b)

type instance O.ParentTypes SettingWirelessChannelWidth = '[]
instance O.HasParentTypes SettingWirelessChannelWidth

foreign import ccall "nm_setting_wireless_channel_width_get_type" c_nm_setting_wireless_channel_width_get_type :: 
    IO GType

instance B.Types.TypedObject SettingWirelessChannelWidth where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_wireless_channel_width_get_type

instance B.Types.BoxedEnum SettingWirelessChannelWidth

-- Enum SettingTunMode
-- | t'GI.NM.Enums.SettingTunMode' values indicate the device type (TUN\/TAP)
-- 
-- /Since: 1.2/
data SettingTunMode = 
      SettingTunModeUnknown
    -- ^ an unknown device type
    | SettingTunModeTun
    -- ^ a TUN device
    | SettingTunModeTap
    -- ^ a TAP device
    | AnotherSettingTunMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingTunMode -> ShowS
[SettingTunMode] -> ShowS
SettingTunMode -> String
(Int -> SettingTunMode -> ShowS)
-> (SettingTunMode -> String)
-> ([SettingTunMode] -> ShowS)
-> Show SettingTunMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingTunMode -> ShowS
showsPrec :: Int -> SettingTunMode -> ShowS
$cshow :: SettingTunMode -> String
show :: SettingTunMode -> String
$cshowList :: [SettingTunMode] -> ShowS
showList :: [SettingTunMode] -> ShowS
Show, SettingTunMode -> SettingTunMode -> Bool
(SettingTunMode -> SettingTunMode -> Bool)
-> (SettingTunMode -> SettingTunMode -> Bool) -> Eq SettingTunMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingTunMode -> SettingTunMode -> Bool
== :: SettingTunMode -> SettingTunMode -> Bool
$c/= :: SettingTunMode -> SettingTunMode -> Bool
/= :: SettingTunMode -> SettingTunMode -> Bool
Eq)

instance P.Enum SettingTunMode where
    fromEnum :: SettingTunMode -> Int
fromEnum SettingTunMode
SettingTunModeUnknown = Int
0
    fromEnum SettingTunMode
SettingTunModeTun = Int
1
    fromEnum SettingTunMode
SettingTunModeTap = Int
2
    fromEnum (AnotherSettingTunMode Int
k) = Int
k

    toEnum :: Int -> SettingTunMode
toEnum Int
0 = SettingTunMode
SettingTunModeUnknown
    toEnum Int
1 = SettingTunMode
SettingTunModeTun
    toEnum Int
2 = SettingTunMode
SettingTunModeTap
    toEnum Int
k = Int -> SettingTunMode
AnotherSettingTunMode Int
k

instance P.Ord SettingTunMode where
    compare :: SettingTunMode -> SettingTunMode -> Ordering
compare SettingTunMode
a SettingTunMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingTunMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingTunMode
a) (SettingTunMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingTunMode
b)

type instance O.ParentTypes SettingTunMode = '[]
instance O.HasParentTypes SettingTunMode

foreign import ccall "nm_setting_tun_mode_get_type" c_nm_setting_tun_mode_get_type :: 
    IO GType

instance B.Types.TypedObject SettingTunMode where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_tun_mode_get_type

instance B.Types.BoxedEnum SettingTunMode

-- Enum SettingSerialParity
-- | The parity setting of a serial port.
data SettingSerialParity = 
      SettingSerialParityNone
    -- ^ No parity bits (default)
    | SettingSerialParityEven
    -- ^ Even parity
    | SettingSerialParityOdd
    -- ^ Odd parity
    | AnotherSettingSerialParity Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingSerialParity -> ShowS
[SettingSerialParity] -> ShowS
SettingSerialParity -> String
(Int -> SettingSerialParity -> ShowS)
-> (SettingSerialParity -> String)
-> ([SettingSerialParity] -> ShowS)
-> Show SettingSerialParity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingSerialParity -> ShowS
showsPrec :: Int -> SettingSerialParity -> ShowS
$cshow :: SettingSerialParity -> String
show :: SettingSerialParity -> String
$cshowList :: [SettingSerialParity] -> ShowS
showList :: [SettingSerialParity] -> ShowS
Show, SettingSerialParity -> SettingSerialParity -> Bool
(SettingSerialParity -> SettingSerialParity -> Bool)
-> (SettingSerialParity -> SettingSerialParity -> Bool)
-> Eq SettingSerialParity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingSerialParity -> SettingSerialParity -> Bool
== :: SettingSerialParity -> SettingSerialParity -> Bool
$c/= :: SettingSerialParity -> SettingSerialParity -> Bool
/= :: SettingSerialParity -> SettingSerialParity -> Bool
Eq)

instance P.Enum SettingSerialParity where
    fromEnum :: SettingSerialParity -> Int
fromEnum SettingSerialParity
SettingSerialParityNone = Int
0
    fromEnum SettingSerialParity
SettingSerialParityEven = Int
1
    fromEnum SettingSerialParity
SettingSerialParityOdd = Int
2
    fromEnum (AnotherSettingSerialParity Int
k) = Int
k

    toEnum :: Int -> SettingSerialParity
toEnum Int
0 = SettingSerialParity
SettingSerialParityNone
    toEnum Int
1 = SettingSerialParity
SettingSerialParityEven
    toEnum Int
2 = SettingSerialParity
SettingSerialParityOdd
    toEnum Int
k = Int -> SettingSerialParity
AnotherSettingSerialParity Int
k

instance P.Ord SettingSerialParity where
    compare :: SettingSerialParity -> SettingSerialParity -> Ordering
compare SettingSerialParity
a SettingSerialParity
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingSerialParity -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingSerialParity
a) (SettingSerialParity -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingSerialParity
b)

type instance O.ParentTypes SettingSerialParity = '[]
instance O.HasParentTypes SettingSerialParity

foreign import ccall "nm_setting_serial_parity_get_type" c_nm_setting_serial_parity_get_type :: 
    IO GType

instance B.Types.TypedObject SettingSerialParity where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_serial_parity_get_type

instance B.Types.BoxedEnum SettingSerialParity

-- Enum SettingProxyMethod
-- | The Proxy method.
-- 
-- /Since: 1.6/
data SettingProxyMethod = 
      SettingProxyMethodNone
    -- ^ No Proxy for the Connection
    | SettingProxyMethodAuto
    -- ^ DHCP obtained Proxy\/ Manual override
    | AnotherSettingProxyMethod Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingProxyMethod -> ShowS
[SettingProxyMethod] -> ShowS
SettingProxyMethod -> String
(Int -> SettingProxyMethod -> ShowS)
-> (SettingProxyMethod -> String)
-> ([SettingProxyMethod] -> ShowS)
-> Show SettingProxyMethod
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingProxyMethod -> ShowS
showsPrec :: Int -> SettingProxyMethod -> ShowS
$cshow :: SettingProxyMethod -> String
show :: SettingProxyMethod -> String
$cshowList :: [SettingProxyMethod] -> ShowS
showList :: [SettingProxyMethod] -> ShowS
Show, SettingProxyMethod -> SettingProxyMethod -> Bool
(SettingProxyMethod -> SettingProxyMethod -> Bool)
-> (SettingProxyMethod -> SettingProxyMethod -> Bool)
-> Eq SettingProxyMethod
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingProxyMethod -> SettingProxyMethod -> Bool
== :: SettingProxyMethod -> SettingProxyMethod -> Bool
$c/= :: SettingProxyMethod -> SettingProxyMethod -> Bool
/= :: SettingProxyMethod -> SettingProxyMethod -> Bool
Eq)

instance P.Enum SettingProxyMethod where
    fromEnum :: SettingProxyMethod -> Int
fromEnum SettingProxyMethod
SettingProxyMethodNone = Int
0
    fromEnum SettingProxyMethod
SettingProxyMethodAuto = Int
1
    fromEnum (AnotherSettingProxyMethod Int
k) = Int
k

    toEnum :: Int -> SettingProxyMethod
toEnum Int
0 = SettingProxyMethod
SettingProxyMethodNone
    toEnum Int
1 = SettingProxyMethod
SettingProxyMethodAuto
    toEnum Int
k = Int -> SettingProxyMethod
AnotherSettingProxyMethod Int
k

instance P.Ord SettingProxyMethod where
    compare :: SettingProxyMethod -> SettingProxyMethod -> Ordering
compare SettingProxyMethod
a SettingProxyMethod
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingProxyMethod -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingProxyMethod
a) (SettingProxyMethod -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingProxyMethod
b)

type instance O.ParentTypes SettingProxyMethod = '[]
instance O.HasParentTypes SettingProxyMethod

foreign import ccall "nm_setting_proxy_method_get_type" c_nm_setting_proxy_method_get_type :: 
    IO GType

instance B.Types.TypedObject SettingProxyMethod where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_proxy_method_get_type

instance B.Types.BoxedEnum SettingProxyMethod

-- Enum SettingMacvlanMode
-- | /No description available in the introspection data./
-- 
-- /Since: 1.2/
data SettingMacvlanMode = 
      SettingMacvlanModeUnknown
    -- ^ unknown\/unset mode
    | SettingMacvlanModeVepa
    -- ^ Virtual Ethernet Port Aggregator mode
    | SettingMacvlanModeBridge
    -- ^ bridge mode
    | SettingMacvlanModePrivate
    -- ^ private mode
    | SettingMacvlanModePassthru
    -- ^ passthru mode
    | SettingMacvlanModeSource
    -- ^ source mode
    | AnotherSettingMacvlanMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingMacvlanMode -> ShowS
[SettingMacvlanMode] -> ShowS
SettingMacvlanMode -> String
(Int -> SettingMacvlanMode -> ShowS)
-> (SettingMacvlanMode -> String)
-> ([SettingMacvlanMode] -> ShowS)
-> Show SettingMacvlanMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingMacvlanMode -> ShowS
showsPrec :: Int -> SettingMacvlanMode -> ShowS
$cshow :: SettingMacvlanMode -> String
show :: SettingMacvlanMode -> String
$cshowList :: [SettingMacvlanMode] -> ShowS
showList :: [SettingMacvlanMode] -> ShowS
Show, SettingMacvlanMode -> SettingMacvlanMode -> Bool
(SettingMacvlanMode -> SettingMacvlanMode -> Bool)
-> (SettingMacvlanMode -> SettingMacvlanMode -> Bool)
-> Eq SettingMacvlanMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingMacvlanMode -> SettingMacvlanMode -> Bool
== :: SettingMacvlanMode -> SettingMacvlanMode -> Bool
$c/= :: SettingMacvlanMode -> SettingMacvlanMode -> Bool
/= :: SettingMacvlanMode -> SettingMacvlanMode -> Bool
Eq)

instance P.Enum SettingMacvlanMode where
    fromEnum :: SettingMacvlanMode -> Int
fromEnum SettingMacvlanMode
SettingMacvlanModeUnknown = Int
0
    fromEnum SettingMacvlanMode
SettingMacvlanModeVepa = Int
1
    fromEnum SettingMacvlanMode
SettingMacvlanModeBridge = Int
2
    fromEnum SettingMacvlanMode
SettingMacvlanModePrivate = Int
3
    fromEnum SettingMacvlanMode
SettingMacvlanModePassthru = Int
4
    fromEnum SettingMacvlanMode
SettingMacvlanModeSource = Int
5
    fromEnum (AnotherSettingMacvlanMode Int
k) = Int
k

    toEnum :: Int -> SettingMacvlanMode
toEnum Int
0 = SettingMacvlanMode
SettingMacvlanModeUnknown
    toEnum Int
1 = SettingMacvlanMode
SettingMacvlanModeVepa
    toEnum Int
2 = SettingMacvlanMode
SettingMacvlanModeBridge
    toEnum Int
3 = SettingMacvlanMode
SettingMacvlanModePrivate
    toEnum Int
4 = SettingMacvlanMode
SettingMacvlanModePassthru
    toEnum Int
5 = SettingMacvlanMode
SettingMacvlanModeSource
    toEnum Int
k = Int -> SettingMacvlanMode
AnotherSettingMacvlanMode Int
k

instance P.Ord SettingMacvlanMode where
    compare :: SettingMacvlanMode -> SettingMacvlanMode -> Ordering
compare SettingMacvlanMode
a SettingMacvlanMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingMacvlanMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingMacvlanMode
a) (SettingMacvlanMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingMacvlanMode
b)

type instance O.ParentTypes SettingMacvlanMode = '[]
instance O.HasParentTypes SettingMacvlanMode

foreign import ccall "nm_setting_macvlan_mode_get_type" c_nm_setting_macvlan_mode_get_type :: 
    IO GType

instance B.Types.TypedObject SettingMacvlanMode where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_macvlan_mode_get_type

instance B.Types.BoxedEnum SettingMacvlanMode

-- Enum SettingMacsecValidation
-- | t'GI.NM.Enums.SettingMacsecValidation' specifies a validation mode for incoming frames.
-- 
-- /Since: 1.6/
data SettingMacsecValidation = 
      SettingMacsecValidationDisable
    -- ^ All incoming frames are accepted if
    --   possible
    | SettingMacsecValidationCheck
    -- ^ Non protected, invalid, or impossible to
    --   verify frames are accepted and counted as \"invalid\"
    | SettingMacsecValidationStrict
    -- ^ Non protected, invalid, or impossible to
    --   verify frames are dropped
    | AnotherSettingMacsecValidation Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingMacsecValidation -> ShowS
[SettingMacsecValidation] -> ShowS
SettingMacsecValidation -> String
(Int -> SettingMacsecValidation -> ShowS)
-> (SettingMacsecValidation -> String)
-> ([SettingMacsecValidation] -> ShowS)
-> Show SettingMacsecValidation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingMacsecValidation -> ShowS
showsPrec :: Int -> SettingMacsecValidation -> ShowS
$cshow :: SettingMacsecValidation -> String
show :: SettingMacsecValidation -> String
$cshowList :: [SettingMacsecValidation] -> ShowS
showList :: [SettingMacsecValidation] -> ShowS
Show, SettingMacsecValidation -> SettingMacsecValidation -> Bool
(SettingMacsecValidation -> SettingMacsecValidation -> Bool)
-> (SettingMacsecValidation -> SettingMacsecValidation -> Bool)
-> Eq SettingMacsecValidation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingMacsecValidation -> SettingMacsecValidation -> Bool
== :: SettingMacsecValidation -> SettingMacsecValidation -> Bool
$c/= :: SettingMacsecValidation -> SettingMacsecValidation -> Bool
/= :: SettingMacsecValidation -> SettingMacsecValidation -> Bool
Eq)

instance P.Enum SettingMacsecValidation where
    fromEnum :: SettingMacsecValidation -> Int
fromEnum SettingMacsecValidation
SettingMacsecValidationDisable = Int
0
    fromEnum SettingMacsecValidation
SettingMacsecValidationCheck = Int
1
    fromEnum SettingMacsecValidation
SettingMacsecValidationStrict = Int
2
    fromEnum (AnotherSettingMacsecValidation Int
k) = Int
k

    toEnum :: Int -> SettingMacsecValidation
toEnum Int
0 = SettingMacsecValidation
SettingMacsecValidationDisable
    toEnum Int
1 = SettingMacsecValidation
SettingMacsecValidationCheck
    toEnum Int
2 = SettingMacsecValidation
SettingMacsecValidationStrict
    toEnum Int
k = Int -> SettingMacsecValidation
AnotherSettingMacsecValidation Int
k

instance P.Ord SettingMacsecValidation where
    compare :: SettingMacsecValidation -> SettingMacsecValidation -> Ordering
compare SettingMacsecValidation
a SettingMacsecValidation
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingMacsecValidation -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingMacsecValidation
a) (SettingMacsecValidation -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingMacsecValidation
b)

type instance O.ParentTypes SettingMacsecValidation = '[]
instance O.HasParentTypes SettingMacsecValidation

foreign import ccall "nm_setting_macsec_validation_get_type" c_nm_setting_macsec_validation_get_type :: 
    IO GType

instance B.Types.TypedObject SettingMacsecValidation where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_macsec_validation_get_type

instance B.Types.BoxedEnum SettingMacsecValidation

-- Enum SettingMacsecOffload
-- | These flags control the MACsec offload mode.
-- 
-- /Since: 1.46/
data SettingMacsecOffload = 
      SettingMacsecOffloadDefault
    -- ^ use the global default; disable if not defined
    | SettingMacsecOffloadOff
    -- ^ disable offload
    | SettingMacsecOffloadPhy
    -- ^ request offload to the PHY
    | SettingMacsecOffloadMac
    -- ^ request offload to the MAC
    | AnotherSettingMacsecOffload Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingMacsecOffload -> ShowS
[SettingMacsecOffload] -> ShowS
SettingMacsecOffload -> String
(Int -> SettingMacsecOffload -> ShowS)
-> (SettingMacsecOffload -> String)
-> ([SettingMacsecOffload] -> ShowS)
-> Show SettingMacsecOffload
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingMacsecOffload -> ShowS
showsPrec :: Int -> SettingMacsecOffload -> ShowS
$cshow :: SettingMacsecOffload -> String
show :: SettingMacsecOffload -> String
$cshowList :: [SettingMacsecOffload] -> ShowS
showList :: [SettingMacsecOffload] -> ShowS
Show, SettingMacsecOffload -> SettingMacsecOffload -> Bool
(SettingMacsecOffload -> SettingMacsecOffload -> Bool)
-> (SettingMacsecOffload -> SettingMacsecOffload -> Bool)
-> Eq SettingMacsecOffload
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingMacsecOffload -> SettingMacsecOffload -> Bool
== :: SettingMacsecOffload -> SettingMacsecOffload -> Bool
$c/= :: SettingMacsecOffload -> SettingMacsecOffload -> Bool
/= :: SettingMacsecOffload -> SettingMacsecOffload -> Bool
Eq)

instance P.Enum SettingMacsecOffload where
    fromEnum :: SettingMacsecOffload -> Int
fromEnum SettingMacsecOffload
SettingMacsecOffloadDefault = Int
-1
    fromEnum SettingMacsecOffload
SettingMacsecOffloadOff = Int
0
    fromEnum SettingMacsecOffload
SettingMacsecOffloadPhy = Int
1
    fromEnum SettingMacsecOffload
SettingMacsecOffloadMac = Int
2
    fromEnum (AnotherSettingMacsecOffload Int
k) = Int
k

    toEnum :: Int -> SettingMacsecOffload
toEnum Int
-1 = SettingMacsecOffload
SettingMacsecOffloadDefault
    toEnum Int
0 = SettingMacsecOffload
SettingMacsecOffloadOff
    toEnum Int
1 = SettingMacsecOffload
SettingMacsecOffloadPhy
    toEnum Int
2 = SettingMacsecOffload
SettingMacsecOffloadMac
    toEnum Int
k = Int -> SettingMacsecOffload
AnotherSettingMacsecOffload Int
k

instance P.Ord SettingMacsecOffload where
    compare :: SettingMacsecOffload -> SettingMacsecOffload -> Ordering
compare SettingMacsecOffload
a SettingMacsecOffload
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingMacsecOffload -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingMacsecOffload
a) (SettingMacsecOffload -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingMacsecOffload
b)

type instance O.ParentTypes SettingMacsecOffload = '[]
instance O.HasParentTypes SettingMacsecOffload

foreign import ccall "nm_setting_macsec_offload_get_type" c_nm_setting_macsec_offload_get_type :: 
    IO GType

instance B.Types.TypedObject SettingMacsecOffload where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_macsec_offload_get_type

instance B.Types.BoxedEnum SettingMacsecOffload

-- Enum SettingMacsecMode
-- | t'GI.NM.Enums.SettingMacsecMode' controls how the CAK (Connectivity Association Key) used
-- in MKA (MACsec Key Agreement) is obtained.
-- 
-- /Since: 1.6/
data SettingMacsecMode = 
      SettingMacsecModePsk
    -- ^ The CAK is pre-shared
    | SettingMacsecModeEap
    -- ^ The CAK is the result of participation in EAP
    | AnotherSettingMacsecMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingMacsecMode -> ShowS
[SettingMacsecMode] -> ShowS
SettingMacsecMode -> String
(Int -> SettingMacsecMode -> ShowS)
-> (SettingMacsecMode -> String)
-> ([SettingMacsecMode] -> ShowS)
-> Show SettingMacsecMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingMacsecMode -> ShowS
showsPrec :: Int -> SettingMacsecMode -> ShowS
$cshow :: SettingMacsecMode -> String
show :: SettingMacsecMode -> String
$cshowList :: [SettingMacsecMode] -> ShowS
showList :: [SettingMacsecMode] -> ShowS
Show, SettingMacsecMode -> SettingMacsecMode -> Bool
(SettingMacsecMode -> SettingMacsecMode -> Bool)
-> (SettingMacsecMode -> SettingMacsecMode -> Bool)
-> Eq SettingMacsecMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingMacsecMode -> SettingMacsecMode -> Bool
== :: SettingMacsecMode -> SettingMacsecMode -> Bool
$c/= :: SettingMacsecMode -> SettingMacsecMode -> Bool
/= :: SettingMacsecMode -> SettingMacsecMode -> Bool
Eq)

instance P.Enum SettingMacsecMode where
    fromEnum :: SettingMacsecMode -> Int
fromEnum SettingMacsecMode
SettingMacsecModePsk = Int
0
    fromEnum SettingMacsecMode
SettingMacsecModeEap = Int
1
    fromEnum (AnotherSettingMacsecMode Int
k) = Int
k

    toEnum :: Int -> SettingMacsecMode
toEnum Int
0 = SettingMacsecMode
SettingMacsecModePsk
    toEnum Int
1 = SettingMacsecMode
SettingMacsecModeEap
    toEnum Int
k = Int -> SettingMacsecMode
AnotherSettingMacsecMode Int
k

instance P.Ord SettingMacsecMode where
    compare :: SettingMacsecMode -> SettingMacsecMode -> Ordering
compare SettingMacsecMode
a SettingMacsecMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingMacsecMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingMacsecMode
a) (SettingMacsecMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingMacsecMode
b)

type instance O.ParentTypes SettingMacsecMode = '[]
instance O.HasParentTypes SettingMacsecMode

foreign import ccall "nm_setting_macsec_mode_get_type" c_nm_setting_macsec_mode_get_type :: 
    IO GType

instance B.Types.TypedObject SettingMacsecMode where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_macsec_mode_get_type

instance B.Types.BoxedEnum SettingMacsecMode

-- Enum SettingMacRandomization
-- | Controls if and how the MAC address of a device is randomzied.
-- 
-- /Since: 1.2/
data SettingMacRandomization = 
      SettingMacRandomizationDefault
    -- ^ the default value, which unless
    -- overridden by user-controlled defaults configuration, is \"never\".
    | SettingMacRandomizationNever
    -- ^ the device\'s MAC address is always used.
    | SettingMacRandomizationAlways
    -- ^ a random MAC address is used.
    | AnotherSettingMacRandomization Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingMacRandomization -> ShowS
[SettingMacRandomization] -> ShowS
SettingMacRandomization -> String
(Int -> SettingMacRandomization -> ShowS)
-> (SettingMacRandomization -> String)
-> ([SettingMacRandomization] -> ShowS)
-> Show SettingMacRandomization
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingMacRandomization -> ShowS
showsPrec :: Int -> SettingMacRandomization -> ShowS
$cshow :: SettingMacRandomization -> String
show :: SettingMacRandomization -> String
$cshowList :: [SettingMacRandomization] -> ShowS
showList :: [SettingMacRandomization] -> ShowS
Show, SettingMacRandomization -> SettingMacRandomization -> Bool
(SettingMacRandomization -> SettingMacRandomization -> Bool)
-> (SettingMacRandomization -> SettingMacRandomization -> Bool)
-> Eq SettingMacRandomization
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingMacRandomization -> SettingMacRandomization -> Bool
== :: SettingMacRandomization -> SettingMacRandomization -> Bool
$c/= :: SettingMacRandomization -> SettingMacRandomization -> Bool
/= :: SettingMacRandomization -> SettingMacRandomization -> Bool
Eq)

instance P.Enum SettingMacRandomization where
    fromEnum :: SettingMacRandomization -> Int
fromEnum SettingMacRandomization
SettingMacRandomizationDefault = Int
0
    fromEnum SettingMacRandomization
SettingMacRandomizationNever = Int
1
    fromEnum SettingMacRandomization
SettingMacRandomizationAlways = Int
2
    fromEnum (AnotherSettingMacRandomization Int
k) = Int
k

    toEnum :: Int -> SettingMacRandomization
toEnum Int
0 = SettingMacRandomization
SettingMacRandomizationDefault
    toEnum Int
1 = SettingMacRandomization
SettingMacRandomizationNever
    toEnum Int
2 = SettingMacRandomization
SettingMacRandomizationAlways
    toEnum Int
k = Int -> SettingMacRandomization
AnotherSettingMacRandomization Int
k

instance P.Ord SettingMacRandomization where
    compare :: SettingMacRandomization -> SettingMacRandomization -> Ordering
compare SettingMacRandomization
a SettingMacRandomization
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingMacRandomization -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingMacRandomization
a) (SettingMacRandomization -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingMacRandomization
b)

type instance O.ParentTypes SettingMacRandomization = '[]
instance O.HasParentTypes SettingMacRandomization

foreign import ccall "nm_setting_mac_randomization_get_type" c_nm_setting_mac_randomization_get_type :: 
    IO GType

instance B.Types.TypedObject SettingMacRandomization where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_mac_randomization_get_type

instance B.Types.BoxedEnum SettingMacRandomization

-- Enum SettingIP6ConfigPrivacy
-- | t'GI.NM.Enums.SettingIP6ConfigPrivacy' values indicate if and how IPv6 Privacy
-- Extensions are used (RFC4941).
data SettingIP6ConfigPrivacy = 
      SettingIP6ConfigPrivacyUnknown
    -- ^ unknown or no value specified
    | SettingIP6ConfigPrivacyDisabled
    -- ^ IPv6 Privacy Extensions are disabled
    | SettingIP6ConfigPrivacyPreferPublicAddr
    -- ^ IPv6 Privacy Extensions
    -- are enabled, but public addresses are preferred over temporary addresses
    | SettingIP6ConfigPrivacyPreferTempAddr
    -- ^ IPv6 Privacy Extensions
    -- are enabled and temporary addresses are preferred over public addresses
    | AnotherSettingIP6ConfigPrivacy Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingIP6ConfigPrivacy -> ShowS
[SettingIP6ConfigPrivacy] -> ShowS
SettingIP6ConfigPrivacy -> String
(Int -> SettingIP6ConfigPrivacy -> ShowS)
-> (SettingIP6ConfigPrivacy -> String)
-> ([SettingIP6ConfigPrivacy] -> ShowS)
-> Show SettingIP6ConfigPrivacy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingIP6ConfigPrivacy -> ShowS
showsPrec :: Int -> SettingIP6ConfigPrivacy -> ShowS
$cshow :: SettingIP6ConfigPrivacy -> String
show :: SettingIP6ConfigPrivacy -> String
$cshowList :: [SettingIP6ConfigPrivacy] -> ShowS
showList :: [SettingIP6ConfigPrivacy] -> ShowS
Show, SettingIP6ConfigPrivacy -> SettingIP6ConfigPrivacy -> Bool
(SettingIP6ConfigPrivacy -> SettingIP6ConfigPrivacy -> Bool)
-> (SettingIP6ConfigPrivacy -> SettingIP6ConfigPrivacy -> Bool)
-> Eq SettingIP6ConfigPrivacy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingIP6ConfigPrivacy -> SettingIP6ConfigPrivacy -> Bool
== :: SettingIP6ConfigPrivacy -> SettingIP6ConfigPrivacy -> Bool
$c/= :: SettingIP6ConfigPrivacy -> SettingIP6ConfigPrivacy -> Bool
/= :: SettingIP6ConfigPrivacy -> SettingIP6ConfigPrivacy -> Bool
Eq)

instance P.Enum SettingIP6ConfigPrivacy where
    fromEnum :: SettingIP6ConfigPrivacy -> Int
fromEnum SettingIP6ConfigPrivacy
SettingIP6ConfigPrivacyUnknown = Int
-1
    fromEnum SettingIP6ConfigPrivacy
SettingIP6ConfigPrivacyDisabled = Int
0
    fromEnum SettingIP6ConfigPrivacy
SettingIP6ConfigPrivacyPreferPublicAddr = Int
1
    fromEnum SettingIP6ConfigPrivacy
SettingIP6ConfigPrivacyPreferTempAddr = Int
2
    fromEnum (AnotherSettingIP6ConfigPrivacy Int
k) = Int
k

    toEnum :: Int -> SettingIP6ConfigPrivacy
toEnum Int
-1 = SettingIP6ConfigPrivacy
SettingIP6ConfigPrivacyUnknown
    toEnum Int
0 = SettingIP6ConfigPrivacy
SettingIP6ConfigPrivacyDisabled
    toEnum Int
1 = SettingIP6ConfigPrivacy
SettingIP6ConfigPrivacyPreferPublicAddr
    toEnum Int
2 = SettingIP6ConfigPrivacy
SettingIP6ConfigPrivacyPreferTempAddr
    toEnum Int
k = Int -> SettingIP6ConfigPrivacy
AnotherSettingIP6ConfigPrivacy Int
k

instance P.Ord SettingIP6ConfigPrivacy where
    compare :: SettingIP6ConfigPrivacy -> SettingIP6ConfigPrivacy -> Ordering
compare SettingIP6ConfigPrivacy
a SettingIP6ConfigPrivacy
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingIP6ConfigPrivacy -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingIP6ConfigPrivacy
a) (SettingIP6ConfigPrivacy -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingIP6ConfigPrivacy
b)

type instance O.ParentTypes SettingIP6ConfigPrivacy = '[]
instance O.HasParentTypes SettingIP6ConfigPrivacy

foreign import ccall "nm_setting_ip6_config_privacy_get_type" c_nm_setting_ip6_config_privacy_get_type :: 
    IO GType

instance B.Types.TypedObject SettingIP6ConfigPrivacy where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_ip6_config_privacy_get_type

instance B.Types.BoxedEnum SettingIP6ConfigPrivacy

-- Enum SettingIP6ConfigAddrGenMode
-- | t'GI.NM.Enums.SettingIP6ConfigAddrGenMode' controls how the Interface Identifier for
-- RFC4862 Stateless Address Autoconfiguration is created.
-- 
-- /Since: 1.2/
data SettingIP6ConfigAddrGenMode = 
      SettingIP6ConfigAddrGenModeEui64
    -- ^ The Interface Identifier is derived
    -- from the interface hardware address.
    | SettingIP6ConfigAddrGenModeStablePrivacy
    -- ^ The Interface Identifier
    -- is created by using a cryptographically secure hash of a secret host-specific
    -- key along with the connection identification and the network address as
    -- specified by RFC7217.
    | SettingIP6ConfigAddrGenModeDefaultOrEui64
    -- ^ Fallback to the global
    --   default, and if unspecified use \"eui64\". Since: 1.40.
    | SettingIP6ConfigAddrGenModeDefault
    -- ^ Fallback to the global
    --   default, and if unspecified use \"stable-privacy\". Since: 1.40.
    | AnotherSettingIP6ConfigAddrGenMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingIP6ConfigAddrGenMode -> ShowS
[SettingIP6ConfigAddrGenMode] -> ShowS
SettingIP6ConfigAddrGenMode -> String
(Int -> SettingIP6ConfigAddrGenMode -> ShowS)
-> (SettingIP6ConfigAddrGenMode -> String)
-> ([SettingIP6ConfigAddrGenMode] -> ShowS)
-> Show SettingIP6ConfigAddrGenMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingIP6ConfigAddrGenMode -> ShowS
showsPrec :: Int -> SettingIP6ConfigAddrGenMode -> ShowS
$cshow :: SettingIP6ConfigAddrGenMode -> String
show :: SettingIP6ConfigAddrGenMode -> String
$cshowList :: [SettingIP6ConfigAddrGenMode] -> ShowS
showList :: [SettingIP6ConfigAddrGenMode] -> ShowS
Show, SettingIP6ConfigAddrGenMode -> SettingIP6ConfigAddrGenMode -> Bool
(SettingIP6ConfigAddrGenMode
 -> SettingIP6ConfigAddrGenMode -> Bool)
-> (SettingIP6ConfigAddrGenMode
    -> SettingIP6ConfigAddrGenMode -> Bool)
-> Eq SettingIP6ConfigAddrGenMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingIP6ConfigAddrGenMode -> SettingIP6ConfigAddrGenMode -> Bool
== :: SettingIP6ConfigAddrGenMode -> SettingIP6ConfigAddrGenMode -> Bool
$c/= :: SettingIP6ConfigAddrGenMode -> SettingIP6ConfigAddrGenMode -> Bool
/= :: SettingIP6ConfigAddrGenMode -> SettingIP6ConfigAddrGenMode -> Bool
Eq)

instance P.Enum SettingIP6ConfigAddrGenMode where
    fromEnum :: SettingIP6ConfigAddrGenMode -> Int
fromEnum SettingIP6ConfigAddrGenMode
SettingIP6ConfigAddrGenModeEui64 = Int
0
    fromEnum SettingIP6ConfigAddrGenMode
SettingIP6ConfigAddrGenModeStablePrivacy = Int
1
    fromEnum SettingIP6ConfigAddrGenMode
SettingIP6ConfigAddrGenModeDefaultOrEui64 = Int
2
    fromEnum SettingIP6ConfigAddrGenMode
SettingIP6ConfigAddrGenModeDefault = Int
3
    fromEnum (AnotherSettingIP6ConfigAddrGenMode Int
k) = Int
k

    toEnum :: Int -> SettingIP6ConfigAddrGenMode
toEnum Int
0 = SettingIP6ConfigAddrGenMode
SettingIP6ConfigAddrGenModeEui64
    toEnum Int
1 = SettingIP6ConfigAddrGenMode
SettingIP6ConfigAddrGenModeStablePrivacy
    toEnum Int
2 = SettingIP6ConfigAddrGenMode
SettingIP6ConfigAddrGenModeDefaultOrEui64
    toEnum Int
3 = SettingIP6ConfigAddrGenMode
SettingIP6ConfigAddrGenModeDefault
    toEnum Int
k = Int -> SettingIP6ConfigAddrGenMode
AnotherSettingIP6ConfigAddrGenMode Int
k

instance P.Ord SettingIP6ConfigAddrGenMode where
    compare :: SettingIP6ConfigAddrGenMode
-> SettingIP6ConfigAddrGenMode -> Ordering
compare SettingIP6ConfigAddrGenMode
a SettingIP6ConfigAddrGenMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingIP6ConfigAddrGenMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingIP6ConfigAddrGenMode
a) (SettingIP6ConfigAddrGenMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingIP6ConfigAddrGenMode
b)

type instance O.ParentTypes SettingIP6ConfigAddrGenMode = '[]
instance O.HasParentTypes SettingIP6ConfigAddrGenMode

foreign import ccall "nm_setting_ip6_config_addr_gen_mode_get_type" c_nm_setting_ip6_config_addr_gen_mode_get_type :: 
    IO GType

instance B.Types.TypedObject SettingIP6ConfigAddrGenMode where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_ip6_config_addr_gen_mode_get_type

instance B.Types.BoxedEnum SettingIP6ConfigAddrGenMode

-- Enum SettingIP4LinkLocal
-- | t'GI.NM.Enums.SettingIP4LinkLocal' values indicate whether IPv4 link-local address protocol should be enabled.
-- 
-- /Since: 1.40/
data SettingIP4LinkLocal = 
      SettingIP4LinkLocalDefault
    -- ^ Allow fallback to a globally configured default. If unspecified,
    --   fallback to \"auto\". Note that if \"ipv4.method\" is \"disabled\", this always implies link-local
    --   addresses disabled too.
    | SettingIP4LinkLocalAuto
    -- ^ Special value which enables LL if \"ipv4.method\" is set to
    --   \"link-local\".
    | SettingIP4LinkLocalDisabled
    -- ^ Disable IPv4 link-local protocol.
    | SettingIP4LinkLocalEnabled
    -- ^ Enable the IPv4 link-local protocol regardless what other protocols
    -- such as DHCP or manually assigned IP addresses might be active.
    | AnotherSettingIP4LinkLocal Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingIP4LinkLocal -> ShowS
[SettingIP4LinkLocal] -> ShowS
SettingIP4LinkLocal -> String
(Int -> SettingIP4LinkLocal -> ShowS)
-> (SettingIP4LinkLocal -> String)
-> ([SettingIP4LinkLocal] -> ShowS)
-> Show SettingIP4LinkLocal
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingIP4LinkLocal -> ShowS
showsPrec :: Int -> SettingIP4LinkLocal -> ShowS
$cshow :: SettingIP4LinkLocal -> String
show :: SettingIP4LinkLocal -> String
$cshowList :: [SettingIP4LinkLocal] -> ShowS
showList :: [SettingIP4LinkLocal] -> ShowS
Show, SettingIP4LinkLocal -> SettingIP4LinkLocal -> Bool
(SettingIP4LinkLocal -> SettingIP4LinkLocal -> Bool)
-> (SettingIP4LinkLocal -> SettingIP4LinkLocal -> Bool)
-> Eq SettingIP4LinkLocal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingIP4LinkLocal -> SettingIP4LinkLocal -> Bool
== :: SettingIP4LinkLocal -> SettingIP4LinkLocal -> Bool
$c/= :: SettingIP4LinkLocal -> SettingIP4LinkLocal -> Bool
/= :: SettingIP4LinkLocal -> SettingIP4LinkLocal -> Bool
Eq)

instance P.Enum SettingIP4LinkLocal where
    fromEnum :: SettingIP4LinkLocal -> Int
fromEnum SettingIP4LinkLocal
SettingIP4LinkLocalDefault = Int
0
    fromEnum SettingIP4LinkLocal
SettingIP4LinkLocalAuto = Int
1
    fromEnum SettingIP4LinkLocal
SettingIP4LinkLocalDisabled = Int
2
    fromEnum SettingIP4LinkLocal
SettingIP4LinkLocalEnabled = Int
3
    fromEnum (AnotherSettingIP4LinkLocal Int
k) = Int
k

    toEnum :: Int -> SettingIP4LinkLocal
toEnum Int
0 = SettingIP4LinkLocal
SettingIP4LinkLocalDefault
    toEnum Int
1 = SettingIP4LinkLocal
SettingIP4LinkLocalAuto
    toEnum Int
2 = SettingIP4LinkLocal
SettingIP4LinkLocalDisabled
    toEnum Int
3 = SettingIP4LinkLocal
SettingIP4LinkLocalEnabled
    toEnum Int
k = Int -> SettingIP4LinkLocal
AnotherSettingIP4LinkLocal Int
k

instance P.Ord SettingIP4LinkLocal where
    compare :: SettingIP4LinkLocal -> SettingIP4LinkLocal -> Ordering
compare SettingIP4LinkLocal
a SettingIP4LinkLocal
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingIP4LinkLocal -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingIP4LinkLocal
a) (SettingIP4LinkLocal -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingIP4LinkLocal
b)

type instance O.ParentTypes SettingIP4LinkLocal = '[]
instance O.HasParentTypes SettingIP4LinkLocal

foreign import ccall "nm_setting_ip4_link_local_get_type" c_nm_setting_ip4_link_local_get_type :: 
    IO GType

instance B.Types.TypedObject SettingIP4LinkLocal where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_ip4_link_local_get_type

instance B.Types.BoxedEnum SettingIP4LinkLocal

-- Enum SettingDiffResult
-- | These values indicate the result of a setting difference operation.
data SettingDiffResult = 
      SettingDiffResultUnknown
    -- ^ unknown result
    | SettingDiffResultInA
    -- ^ the property is present in setting A
    | SettingDiffResultInB
    -- ^ the property is present in setting B
    | SettingDiffResultInADefault
    -- ^ the property is present in
    -- setting A but is set to the default value. This flag is only set,
    -- if you specify /@nMSETTINGCOMPAREFLAGDIFFRESULTWITHDEFAULT@/.
    | SettingDiffResultInBDefault
    -- ^ analog to /@nMSETTINGDIFFRESULTINADEFAULT@/.
    | AnotherSettingDiffResult Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingDiffResult -> ShowS
[SettingDiffResult] -> ShowS
SettingDiffResult -> String
(Int -> SettingDiffResult -> ShowS)
-> (SettingDiffResult -> String)
-> ([SettingDiffResult] -> ShowS)
-> Show SettingDiffResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingDiffResult -> ShowS
showsPrec :: Int -> SettingDiffResult -> ShowS
$cshow :: SettingDiffResult -> String
show :: SettingDiffResult -> String
$cshowList :: [SettingDiffResult] -> ShowS
showList :: [SettingDiffResult] -> ShowS
Show, SettingDiffResult -> SettingDiffResult -> Bool
(SettingDiffResult -> SettingDiffResult -> Bool)
-> (SettingDiffResult -> SettingDiffResult -> Bool)
-> Eq SettingDiffResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingDiffResult -> SettingDiffResult -> Bool
== :: SettingDiffResult -> SettingDiffResult -> Bool
$c/= :: SettingDiffResult -> SettingDiffResult -> Bool
/= :: SettingDiffResult -> SettingDiffResult -> Bool
Eq)

instance P.Enum SettingDiffResult where
    fromEnum :: SettingDiffResult -> Int
fromEnum SettingDiffResult
SettingDiffResultUnknown = Int
0
    fromEnum SettingDiffResult
SettingDiffResultInA = Int
1
    fromEnum SettingDiffResult
SettingDiffResultInB = Int
2
    fromEnum SettingDiffResult
SettingDiffResultInADefault = Int
4
    fromEnum SettingDiffResult
SettingDiffResultInBDefault = Int
8
    fromEnum (AnotherSettingDiffResult Int
k) = Int
k

    toEnum :: Int -> SettingDiffResult
toEnum Int
0 = SettingDiffResult
SettingDiffResultUnknown
    toEnum Int
1 = SettingDiffResult
SettingDiffResultInA
    toEnum Int
2 = SettingDiffResult
SettingDiffResultInB
    toEnum Int
4 = SettingDiffResult
SettingDiffResultInADefault
    toEnum Int
8 = SettingDiffResult
SettingDiffResultInBDefault
    toEnum Int
k = Int -> SettingDiffResult
AnotherSettingDiffResult Int
k

instance P.Ord SettingDiffResult where
    compare :: SettingDiffResult -> SettingDiffResult -> Ordering
compare SettingDiffResult
a SettingDiffResult
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingDiffResult -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingDiffResult
a) (SettingDiffResult -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingDiffResult
b)

type instance O.ParentTypes SettingDiffResult = '[]
instance O.HasParentTypes SettingDiffResult

foreign import ccall "nm_setting_diff_result_get_type" c_nm_setting_diff_result_get_type :: 
    IO GType

instance B.Types.TypedObject SettingDiffResult where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_diff_result_get_type

instance B.Types.BoxedEnum SettingDiffResult

-- Enum SettingConnectionMdns
-- | t'GI.NM.Enums.SettingConnectionMdns' values indicate whether mDNS should be enabled.
-- 
-- /Since: 1.12/
data SettingConnectionMdns = 
      SettingConnectionMdnsDefault
    -- ^ default value
    | SettingConnectionMdnsNo
    -- ^ disable mDNS
    | SettingConnectionMdnsResolve
    -- ^ support only resolving, do not register hostname
    | SettingConnectionMdnsYes
    -- ^ enable mDNS
    | AnotherSettingConnectionMdns Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingConnectionMdns -> ShowS
[SettingConnectionMdns] -> ShowS
SettingConnectionMdns -> String
(Int -> SettingConnectionMdns -> ShowS)
-> (SettingConnectionMdns -> String)
-> ([SettingConnectionMdns] -> ShowS)
-> Show SettingConnectionMdns
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingConnectionMdns -> ShowS
showsPrec :: Int -> SettingConnectionMdns -> ShowS
$cshow :: SettingConnectionMdns -> String
show :: SettingConnectionMdns -> String
$cshowList :: [SettingConnectionMdns] -> ShowS
showList :: [SettingConnectionMdns] -> ShowS
Show, SettingConnectionMdns -> SettingConnectionMdns -> Bool
(SettingConnectionMdns -> SettingConnectionMdns -> Bool)
-> (SettingConnectionMdns -> SettingConnectionMdns -> Bool)
-> Eq SettingConnectionMdns
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingConnectionMdns -> SettingConnectionMdns -> Bool
== :: SettingConnectionMdns -> SettingConnectionMdns -> Bool
$c/= :: SettingConnectionMdns -> SettingConnectionMdns -> Bool
/= :: SettingConnectionMdns -> SettingConnectionMdns -> Bool
Eq)

instance P.Enum SettingConnectionMdns where
    fromEnum :: SettingConnectionMdns -> Int
fromEnum SettingConnectionMdns
SettingConnectionMdnsDefault = Int
-1
    fromEnum SettingConnectionMdns
SettingConnectionMdnsNo = Int
0
    fromEnum SettingConnectionMdns
SettingConnectionMdnsResolve = Int
1
    fromEnum SettingConnectionMdns
SettingConnectionMdnsYes = Int
2
    fromEnum (AnotherSettingConnectionMdns Int
k) = Int
k

    toEnum :: Int -> SettingConnectionMdns
toEnum Int
-1 = SettingConnectionMdns
SettingConnectionMdnsDefault
    toEnum Int
0 = SettingConnectionMdns
SettingConnectionMdnsNo
    toEnum Int
1 = SettingConnectionMdns
SettingConnectionMdnsResolve
    toEnum Int
2 = SettingConnectionMdns
SettingConnectionMdnsYes
    toEnum Int
k = Int -> SettingConnectionMdns
AnotherSettingConnectionMdns Int
k

instance P.Ord SettingConnectionMdns where
    compare :: SettingConnectionMdns -> SettingConnectionMdns -> Ordering
compare SettingConnectionMdns
a SettingConnectionMdns
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingConnectionMdns -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingConnectionMdns
a) (SettingConnectionMdns -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingConnectionMdns
b)

type instance O.ParentTypes SettingConnectionMdns = '[]
instance O.HasParentTypes SettingConnectionMdns

foreign import ccall "nm_setting_connection_mdns_get_type" c_nm_setting_connection_mdns_get_type :: 
    IO GType

instance B.Types.TypedObject SettingConnectionMdns where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_connection_mdns_get_type

instance B.Types.BoxedEnum SettingConnectionMdns

-- Enum SettingConnectionLlmnr
-- | t'GI.NM.Enums.SettingConnectionLlmnr' values indicate whether LLMNR should be enabled.
-- 
-- /Since: 1.14/
data SettingConnectionLlmnr = 
      SettingConnectionLlmnrDefault
    -- ^ default value
    | SettingConnectionLlmnrNo
    -- ^ disable LLMNR
    | SettingConnectionLlmnrResolve
    -- ^ support only resolving, do not register hostname
    | SettingConnectionLlmnrYes
    -- ^ enable LLMNR
    | AnotherSettingConnectionLlmnr Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingConnectionLlmnr -> ShowS
[SettingConnectionLlmnr] -> ShowS
SettingConnectionLlmnr -> String
(Int -> SettingConnectionLlmnr -> ShowS)
-> (SettingConnectionLlmnr -> String)
-> ([SettingConnectionLlmnr] -> ShowS)
-> Show SettingConnectionLlmnr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingConnectionLlmnr -> ShowS
showsPrec :: Int -> SettingConnectionLlmnr -> ShowS
$cshow :: SettingConnectionLlmnr -> String
show :: SettingConnectionLlmnr -> String
$cshowList :: [SettingConnectionLlmnr] -> ShowS
showList :: [SettingConnectionLlmnr] -> ShowS
Show, SettingConnectionLlmnr -> SettingConnectionLlmnr -> Bool
(SettingConnectionLlmnr -> SettingConnectionLlmnr -> Bool)
-> (SettingConnectionLlmnr -> SettingConnectionLlmnr -> Bool)
-> Eq SettingConnectionLlmnr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingConnectionLlmnr -> SettingConnectionLlmnr -> Bool
== :: SettingConnectionLlmnr -> SettingConnectionLlmnr -> Bool
$c/= :: SettingConnectionLlmnr -> SettingConnectionLlmnr -> Bool
/= :: SettingConnectionLlmnr -> SettingConnectionLlmnr -> Bool
Eq)

instance P.Enum SettingConnectionLlmnr where
    fromEnum :: SettingConnectionLlmnr -> Int
fromEnum SettingConnectionLlmnr
SettingConnectionLlmnrDefault = Int
-1
    fromEnum SettingConnectionLlmnr
SettingConnectionLlmnrNo = Int
0
    fromEnum SettingConnectionLlmnr
SettingConnectionLlmnrResolve = Int
1
    fromEnum SettingConnectionLlmnr
SettingConnectionLlmnrYes = Int
2
    fromEnum (AnotherSettingConnectionLlmnr Int
k) = Int
k

    toEnum :: Int -> SettingConnectionLlmnr
toEnum Int
-1 = SettingConnectionLlmnr
SettingConnectionLlmnrDefault
    toEnum Int
0 = SettingConnectionLlmnr
SettingConnectionLlmnrNo
    toEnum Int
1 = SettingConnectionLlmnr
SettingConnectionLlmnrResolve
    toEnum Int
2 = SettingConnectionLlmnr
SettingConnectionLlmnrYes
    toEnum Int
k = Int -> SettingConnectionLlmnr
AnotherSettingConnectionLlmnr Int
k

instance P.Ord SettingConnectionLlmnr where
    compare :: SettingConnectionLlmnr -> SettingConnectionLlmnr -> Ordering
compare SettingConnectionLlmnr
a SettingConnectionLlmnr
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingConnectionLlmnr -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingConnectionLlmnr
a) (SettingConnectionLlmnr -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingConnectionLlmnr
b)

type instance O.ParentTypes SettingConnectionLlmnr = '[]
instance O.HasParentTypes SettingConnectionLlmnr

foreign import ccall "nm_setting_connection_llmnr_get_type" c_nm_setting_connection_llmnr_get_type :: 
    IO GType

instance B.Types.TypedObject SettingConnectionLlmnr where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_connection_llmnr_get_type

instance B.Types.BoxedEnum SettingConnectionLlmnr

-- Enum SettingConnectionLldp
-- | t'GI.NM.Enums.SettingConnectionLldp' values indicate whether LLDP should be enabled.
-- 
-- /Since: 1.2/
data SettingConnectionLldp = 
      SettingConnectionLldpDefault
    -- ^ default value
    | SettingConnectionLldpDisable
    -- ^ disable LLDP
    | SettingConnectionLldpEnableRx
    -- ^ enable reception of LLDP frames
    | AnotherSettingConnectionLldp Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingConnectionLldp -> ShowS
[SettingConnectionLldp] -> ShowS
SettingConnectionLldp -> String
(Int -> SettingConnectionLldp -> ShowS)
-> (SettingConnectionLldp -> String)
-> ([SettingConnectionLldp] -> ShowS)
-> Show SettingConnectionLldp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingConnectionLldp -> ShowS
showsPrec :: Int -> SettingConnectionLldp -> ShowS
$cshow :: SettingConnectionLldp -> String
show :: SettingConnectionLldp -> String
$cshowList :: [SettingConnectionLldp] -> ShowS
showList :: [SettingConnectionLldp] -> ShowS
Show, SettingConnectionLldp -> SettingConnectionLldp -> Bool
(SettingConnectionLldp -> SettingConnectionLldp -> Bool)
-> (SettingConnectionLldp -> SettingConnectionLldp -> Bool)
-> Eq SettingConnectionLldp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingConnectionLldp -> SettingConnectionLldp -> Bool
== :: SettingConnectionLldp -> SettingConnectionLldp -> Bool
$c/= :: SettingConnectionLldp -> SettingConnectionLldp -> Bool
/= :: SettingConnectionLldp -> SettingConnectionLldp -> Bool
Eq)

instance P.Enum SettingConnectionLldp where
    fromEnum :: SettingConnectionLldp -> Int
fromEnum SettingConnectionLldp
SettingConnectionLldpDefault = Int
-1
    fromEnum SettingConnectionLldp
SettingConnectionLldpDisable = Int
0
    fromEnum SettingConnectionLldp
SettingConnectionLldpEnableRx = Int
1
    fromEnum (AnotherSettingConnectionLldp Int
k) = Int
k

    toEnum :: Int -> SettingConnectionLldp
toEnum Int
-1 = SettingConnectionLldp
SettingConnectionLldpDefault
    toEnum Int
0 = SettingConnectionLldp
SettingConnectionLldpDisable
    toEnum Int
1 = SettingConnectionLldp
SettingConnectionLldpEnableRx
    toEnum Int
k = Int -> SettingConnectionLldp
AnotherSettingConnectionLldp Int
k

instance P.Ord SettingConnectionLldp where
    compare :: SettingConnectionLldp -> SettingConnectionLldp -> Ordering
compare SettingConnectionLldp
a SettingConnectionLldp
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingConnectionLldp -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingConnectionLldp
a) (SettingConnectionLldp -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingConnectionLldp
b)

type instance O.ParentTypes SettingConnectionLldp = '[]
instance O.HasParentTypes SettingConnectionLldp

foreign import ccall "nm_setting_connection_lldp_get_type" c_nm_setting_connection_lldp_get_type :: 
    IO GType

instance B.Types.TypedObject SettingConnectionLldp where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_connection_lldp_get_type

instance B.Types.BoxedEnum SettingConnectionLldp

-- Enum SettingConnectionDownOnPoweroff
-- | t'GI.NM.Enums.SettingConnectionDownOnPoweroff' indicates whether the connection will be
-- brought down before the system is powered off.
-- 
-- /Since: 1.48/
data SettingConnectionDownOnPoweroff = 
      SettingConnectionDownOnPoweroffDefault
    -- ^ default value
    | SettingConnectionDownOnPoweroffNo
    -- ^ disable down-on-poweroff
    | SettingConnectionDownOnPoweroffYes
    -- ^ enable down-on-poweroff
    | AnotherSettingConnectionDownOnPoweroff Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingConnectionDownOnPoweroff -> ShowS
[SettingConnectionDownOnPoweroff] -> ShowS
SettingConnectionDownOnPoweroff -> String
(Int -> SettingConnectionDownOnPoweroff -> ShowS)
-> (SettingConnectionDownOnPoweroff -> String)
-> ([SettingConnectionDownOnPoweroff] -> ShowS)
-> Show SettingConnectionDownOnPoweroff
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingConnectionDownOnPoweroff -> ShowS
showsPrec :: Int -> SettingConnectionDownOnPoweroff -> ShowS
$cshow :: SettingConnectionDownOnPoweroff -> String
show :: SettingConnectionDownOnPoweroff -> String
$cshowList :: [SettingConnectionDownOnPoweroff] -> ShowS
showList :: [SettingConnectionDownOnPoweroff] -> ShowS
Show, SettingConnectionDownOnPoweroff
-> SettingConnectionDownOnPoweroff -> Bool
(SettingConnectionDownOnPoweroff
 -> SettingConnectionDownOnPoweroff -> Bool)
-> (SettingConnectionDownOnPoweroff
    -> SettingConnectionDownOnPoweroff -> Bool)
-> Eq SettingConnectionDownOnPoweroff
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingConnectionDownOnPoweroff
-> SettingConnectionDownOnPoweroff -> Bool
== :: SettingConnectionDownOnPoweroff
-> SettingConnectionDownOnPoweroff -> Bool
$c/= :: SettingConnectionDownOnPoweroff
-> SettingConnectionDownOnPoweroff -> Bool
/= :: SettingConnectionDownOnPoweroff
-> SettingConnectionDownOnPoweroff -> Bool
Eq)

instance P.Enum SettingConnectionDownOnPoweroff where
    fromEnum :: SettingConnectionDownOnPoweroff -> Int
fromEnum SettingConnectionDownOnPoweroff
SettingConnectionDownOnPoweroffDefault = Int
-1
    fromEnum SettingConnectionDownOnPoweroff
SettingConnectionDownOnPoweroffNo = Int
0
    fromEnum SettingConnectionDownOnPoweroff
SettingConnectionDownOnPoweroffYes = Int
1
    fromEnum (AnotherSettingConnectionDownOnPoweroff Int
k) = Int
k

    toEnum :: Int -> SettingConnectionDownOnPoweroff
toEnum Int
-1 = SettingConnectionDownOnPoweroff
SettingConnectionDownOnPoweroffDefault
    toEnum Int
0 = SettingConnectionDownOnPoweroff
SettingConnectionDownOnPoweroffNo
    toEnum Int
1 = SettingConnectionDownOnPoweroff
SettingConnectionDownOnPoweroffYes
    toEnum Int
k = Int -> SettingConnectionDownOnPoweroff
AnotherSettingConnectionDownOnPoweroff Int
k

instance P.Ord SettingConnectionDownOnPoweroff where
    compare :: SettingConnectionDownOnPoweroff
-> SettingConnectionDownOnPoweroff -> Ordering
compare SettingConnectionDownOnPoweroff
a SettingConnectionDownOnPoweroff
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingConnectionDownOnPoweroff -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingConnectionDownOnPoweroff
a) (SettingConnectionDownOnPoweroff -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingConnectionDownOnPoweroff
b)

type instance O.ParentTypes SettingConnectionDownOnPoweroff = '[]
instance O.HasParentTypes SettingConnectionDownOnPoweroff

foreign import ccall "nm_setting_connection_down_on_poweroff_get_type" c_nm_setting_connection_down_on_poweroff_get_type :: 
    IO GType

instance B.Types.TypedObject SettingConnectionDownOnPoweroff where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_connection_down_on_poweroff_get_type

instance B.Types.BoxedEnum SettingConnectionDownOnPoweroff

-- Enum SettingConnectionDnsOverTls
-- | t'GI.NM.Enums.SettingConnectionDnsOverTls' values indicate whether DNSOverTls should be enabled.
-- 
-- /Since: 1.34/
data SettingConnectionDnsOverTls = 
      SettingConnectionDnsOverTlsDefault
    -- ^ default value
    | SettingConnectionDnsOverTlsNo
    -- ^ disable DNSOverTls
    | SettingConnectionDnsOverTlsOpportunistic
    -- ^ enable opportunistic mode
    | SettingConnectionDnsOverTlsYes
    -- ^ enable strict mode
    | AnotherSettingConnectionDnsOverTls Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingConnectionDnsOverTls -> ShowS
[SettingConnectionDnsOverTls] -> ShowS
SettingConnectionDnsOverTls -> String
(Int -> SettingConnectionDnsOverTls -> ShowS)
-> (SettingConnectionDnsOverTls -> String)
-> ([SettingConnectionDnsOverTls] -> ShowS)
-> Show SettingConnectionDnsOverTls
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingConnectionDnsOverTls -> ShowS
showsPrec :: Int -> SettingConnectionDnsOverTls -> ShowS
$cshow :: SettingConnectionDnsOverTls -> String
show :: SettingConnectionDnsOverTls -> String
$cshowList :: [SettingConnectionDnsOverTls] -> ShowS
showList :: [SettingConnectionDnsOverTls] -> ShowS
Show, SettingConnectionDnsOverTls -> SettingConnectionDnsOverTls -> Bool
(SettingConnectionDnsOverTls
 -> SettingConnectionDnsOverTls -> Bool)
-> (SettingConnectionDnsOverTls
    -> SettingConnectionDnsOverTls -> Bool)
-> Eq SettingConnectionDnsOverTls
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingConnectionDnsOverTls -> SettingConnectionDnsOverTls -> Bool
== :: SettingConnectionDnsOverTls -> SettingConnectionDnsOverTls -> Bool
$c/= :: SettingConnectionDnsOverTls -> SettingConnectionDnsOverTls -> Bool
/= :: SettingConnectionDnsOverTls -> SettingConnectionDnsOverTls -> Bool
Eq)

instance P.Enum SettingConnectionDnsOverTls where
    fromEnum :: SettingConnectionDnsOverTls -> Int
fromEnum SettingConnectionDnsOverTls
SettingConnectionDnsOverTlsDefault = Int
-1
    fromEnum SettingConnectionDnsOverTls
SettingConnectionDnsOverTlsNo = Int
0
    fromEnum SettingConnectionDnsOverTls
SettingConnectionDnsOverTlsOpportunistic = Int
1
    fromEnum SettingConnectionDnsOverTls
SettingConnectionDnsOverTlsYes = Int
2
    fromEnum (AnotherSettingConnectionDnsOverTls Int
k) = Int
k

    toEnum :: Int -> SettingConnectionDnsOverTls
toEnum Int
-1 = SettingConnectionDnsOverTls
SettingConnectionDnsOverTlsDefault
    toEnum Int
0 = SettingConnectionDnsOverTls
SettingConnectionDnsOverTlsNo
    toEnum Int
1 = SettingConnectionDnsOverTls
SettingConnectionDnsOverTlsOpportunistic
    toEnum Int
2 = SettingConnectionDnsOverTls
SettingConnectionDnsOverTlsYes
    toEnum Int
k = Int -> SettingConnectionDnsOverTls
AnotherSettingConnectionDnsOverTls Int
k

instance P.Ord SettingConnectionDnsOverTls where
    compare :: SettingConnectionDnsOverTls
-> SettingConnectionDnsOverTls -> Ordering
compare SettingConnectionDnsOverTls
a SettingConnectionDnsOverTls
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingConnectionDnsOverTls -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingConnectionDnsOverTls
a) (SettingConnectionDnsOverTls -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingConnectionDnsOverTls
b)

type instance O.ParentTypes SettingConnectionDnsOverTls = '[]
instance O.HasParentTypes SettingConnectionDnsOverTls

foreign import ccall "nm_setting_connection_dns_over_tls_get_type" c_nm_setting_connection_dns_over_tls_get_type :: 
    IO GType

instance B.Types.TypedObject SettingConnectionDnsOverTls where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_connection_dns_over_tls_get_type

instance B.Types.BoxedEnum SettingConnectionDnsOverTls

-- Enum SettingConnectionAutoconnectSlaves
{-# DEPRECATED SettingConnectionAutoconnectSlaves ["(Since version 1.46)"] #-}
-- | t'GI.NM.Enums.SettingConnectionAutoconnectSlaves' values indicate whether slave connections
-- should be activated when controller is activated.
-- 
-- /Since: 1.2/
data SettingConnectionAutoconnectSlaves = 
      SettingConnectionAutoconnectSlavesDefault
    -- ^ default value
    | SettingConnectionAutoconnectSlavesNo
    -- ^ slaves are not brought up when
    --   controller is activated
    | SettingConnectionAutoconnectSlavesYes
    -- ^ slaves are brought up when
    --   controller is activated
    | AnotherSettingConnectionAutoconnectSlaves Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingConnectionAutoconnectSlaves -> ShowS
[SettingConnectionAutoconnectSlaves] -> ShowS
SettingConnectionAutoconnectSlaves -> String
(Int -> SettingConnectionAutoconnectSlaves -> ShowS)
-> (SettingConnectionAutoconnectSlaves -> String)
-> ([SettingConnectionAutoconnectSlaves] -> ShowS)
-> Show SettingConnectionAutoconnectSlaves
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingConnectionAutoconnectSlaves -> ShowS
showsPrec :: Int -> SettingConnectionAutoconnectSlaves -> ShowS
$cshow :: SettingConnectionAutoconnectSlaves -> String
show :: SettingConnectionAutoconnectSlaves -> String
$cshowList :: [SettingConnectionAutoconnectSlaves] -> ShowS
showList :: [SettingConnectionAutoconnectSlaves] -> ShowS
Show, SettingConnectionAutoconnectSlaves
-> SettingConnectionAutoconnectSlaves -> Bool
(SettingConnectionAutoconnectSlaves
 -> SettingConnectionAutoconnectSlaves -> Bool)
-> (SettingConnectionAutoconnectSlaves
    -> SettingConnectionAutoconnectSlaves -> Bool)
-> Eq SettingConnectionAutoconnectSlaves
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingConnectionAutoconnectSlaves
-> SettingConnectionAutoconnectSlaves -> Bool
== :: SettingConnectionAutoconnectSlaves
-> SettingConnectionAutoconnectSlaves -> Bool
$c/= :: SettingConnectionAutoconnectSlaves
-> SettingConnectionAutoconnectSlaves -> Bool
/= :: SettingConnectionAutoconnectSlaves
-> SettingConnectionAutoconnectSlaves -> Bool
Eq)

instance P.Enum SettingConnectionAutoconnectSlaves where
    fromEnum :: SettingConnectionAutoconnectSlaves -> Int
fromEnum SettingConnectionAutoconnectSlaves
SettingConnectionAutoconnectSlavesDefault = Int
-1
    fromEnum SettingConnectionAutoconnectSlaves
SettingConnectionAutoconnectSlavesNo = Int
0
    fromEnum SettingConnectionAutoconnectSlaves
SettingConnectionAutoconnectSlavesYes = Int
1
    fromEnum (AnotherSettingConnectionAutoconnectSlaves Int
k) = Int
k

    toEnum :: Int -> SettingConnectionAutoconnectSlaves
toEnum Int
-1 = SettingConnectionAutoconnectSlaves
SettingConnectionAutoconnectSlavesDefault
    toEnum Int
0 = SettingConnectionAutoconnectSlaves
SettingConnectionAutoconnectSlavesNo
    toEnum Int
1 = SettingConnectionAutoconnectSlaves
SettingConnectionAutoconnectSlavesYes
    toEnum Int
k = Int -> SettingConnectionAutoconnectSlaves
AnotherSettingConnectionAutoconnectSlaves Int
k

instance P.Ord SettingConnectionAutoconnectSlaves where
    compare :: SettingConnectionAutoconnectSlaves
-> SettingConnectionAutoconnectSlaves -> Ordering
compare SettingConnectionAutoconnectSlaves
a SettingConnectionAutoconnectSlaves
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingConnectionAutoconnectSlaves -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingConnectionAutoconnectSlaves
a) (SettingConnectionAutoconnectSlaves -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingConnectionAutoconnectSlaves
b)

type instance O.ParentTypes SettingConnectionAutoconnectSlaves = '[]
instance O.HasParentTypes SettingConnectionAutoconnectSlaves

foreign import ccall "nm_setting_connection_autoconnect_slaves_get_type" c_nm_setting_connection_autoconnect_slaves_get_type :: 
    IO GType

instance B.Types.TypedObject SettingConnectionAutoconnectSlaves where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_connection_autoconnect_slaves_get_type

instance B.Types.BoxedEnum SettingConnectionAutoconnectSlaves

-- Enum SettingCompareFlags
-- | These flags modify the comparison behavior when comparing two settings or
-- two connections.
data SettingCompareFlags = 
      SettingCompareFlagsExact
    -- ^ match all properties exactly
    | SettingCompareFlagsFuzzy
    -- ^ match only important attributes, like SSID,
    --   type, security settings, etc.  Does not match, for example, connection ID
    --   or UUID.
    | SettingCompareFlagsIgnoreId
    -- ^ ignore the connection\'s ID
    | SettingCompareFlagsIgnoreSecrets
    -- ^ ignore all secrets
    | SettingCompareFlagsIgnoreAgentOwnedSecrets
    -- ^ ignore secrets for which
    --   the secret\'s flags indicate the secret is owned by a user secret agent
    --   (ie, the secret\'s flag includes /@nMSETTINGSECRETFLAGAGENTOWNED@/)
    | SettingCompareFlagsIgnoreNotSavedSecrets
    -- ^ ignore secrets for which
    --   the secret\'s flags indicate the secret should not be saved to persistent
    --   storage (ie, the secret\'s flag includes /@nMSETTINGSECRETFLAGNOTSAVED@/)
    | SettingCompareFlagsDiffResultWithDefault
    -- ^ if this flag is set,
    --   'GI.NM.Objects.Setting.settingDiff' and @/nm_connection_diff()/@ will also include properties that
    --   are set to their default value. See also /@nMSETTINGCOMPAREFLAGDIFFRESULTNODEFAULT@/.
    | SettingCompareFlagsDiffResultNoDefault
    -- ^ if this flag is set,
    --   'GI.NM.Objects.Setting.settingDiff' and @/nm_connection_diff()/@ will not include properties that
    --   are set to their default value. This is the opposite of
    --   /@nMSETTINGCOMPAREFLAGDIFFRESULTWITHDEFAULT@/. If both flags are set together,
    --   /@nMSETTINGCOMPAREFLAGDIFFRESULTWITHDEFAULT@/ wins. If both flags are unset,
    --   this means to exclude default properties if there is a setting to compare,
    --   but include all properties, if the setting \'b\' is missing. This is the legacy
    --   behaviour of libnm-util, where 'GI.NM.Objects.Setting.settingDiff' behaved differently depending
    --   on whether the setting \'b\' was available. If /@nMSETTINGCOMPAREFLAGDIFFRESULTWITHDEFAULT@/
    --   is set, 'GI.NM.Objects.Setting.settingDiff' will also set the flags /@nMSETTINGDIFFRESULTINADEFAULT@/
    --   and /@nMSETTINGDIFFRESULTINBDEFAULT@/, if the values are default values.
    | SettingCompareFlagsIgnoreTimestamp
    -- ^ ignore the connection\'s timestamp
    | AnotherSettingCompareFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingCompareFlags -> ShowS
[SettingCompareFlags] -> ShowS
SettingCompareFlags -> String
(Int -> SettingCompareFlags -> ShowS)
-> (SettingCompareFlags -> String)
-> ([SettingCompareFlags] -> ShowS)
-> Show SettingCompareFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingCompareFlags -> ShowS
showsPrec :: Int -> SettingCompareFlags -> ShowS
$cshow :: SettingCompareFlags -> String
show :: SettingCompareFlags -> String
$cshowList :: [SettingCompareFlags] -> ShowS
showList :: [SettingCompareFlags] -> ShowS
Show, SettingCompareFlags -> SettingCompareFlags -> Bool
(SettingCompareFlags -> SettingCompareFlags -> Bool)
-> (SettingCompareFlags -> SettingCompareFlags -> Bool)
-> Eq SettingCompareFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingCompareFlags -> SettingCompareFlags -> Bool
== :: SettingCompareFlags -> SettingCompareFlags -> Bool
$c/= :: SettingCompareFlags -> SettingCompareFlags -> Bool
/= :: SettingCompareFlags -> SettingCompareFlags -> Bool
Eq)

instance P.Enum SettingCompareFlags where
    fromEnum :: SettingCompareFlags -> Int
fromEnum SettingCompareFlags
SettingCompareFlagsExact = Int
0
    fromEnum SettingCompareFlags
SettingCompareFlagsFuzzy = Int
1
    fromEnum SettingCompareFlags
SettingCompareFlagsIgnoreId = Int
2
    fromEnum SettingCompareFlags
SettingCompareFlagsIgnoreSecrets = Int
4
    fromEnum SettingCompareFlags
SettingCompareFlagsIgnoreAgentOwnedSecrets = Int
8
    fromEnum SettingCompareFlags
SettingCompareFlagsIgnoreNotSavedSecrets = Int
16
    fromEnum SettingCompareFlags
SettingCompareFlagsDiffResultWithDefault = Int
32
    fromEnum SettingCompareFlags
SettingCompareFlagsDiffResultNoDefault = Int
64
    fromEnum SettingCompareFlags
SettingCompareFlagsIgnoreTimestamp = Int
128
    fromEnum (AnotherSettingCompareFlags Int
k) = Int
k

    toEnum :: Int -> SettingCompareFlags
toEnum Int
0 = SettingCompareFlags
SettingCompareFlagsExact
    toEnum Int
1 = SettingCompareFlags
SettingCompareFlagsFuzzy
    toEnum Int
2 = SettingCompareFlags
SettingCompareFlagsIgnoreId
    toEnum Int
4 = SettingCompareFlags
SettingCompareFlagsIgnoreSecrets
    toEnum Int
8 = SettingCompareFlags
SettingCompareFlagsIgnoreAgentOwnedSecrets
    toEnum Int
16 = SettingCompareFlags
SettingCompareFlagsIgnoreNotSavedSecrets
    toEnum Int
32 = SettingCompareFlags
SettingCompareFlagsDiffResultWithDefault
    toEnum Int
64 = SettingCompareFlags
SettingCompareFlagsDiffResultNoDefault
    toEnum Int
128 = SettingCompareFlags
SettingCompareFlagsIgnoreTimestamp
    toEnum Int
k = Int -> SettingCompareFlags
AnotherSettingCompareFlags Int
k

instance P.Ord SettingCompareFlags where
    compare :: SettingCompareFlags -> SettingCompareFlags -> Ordering
compare SettingCompareFlags
a SettingCompareFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingCompareFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingCompareFlags
a) (SettingCompareFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingCompareFlags
b)

type instance O.ParentTypes SettingCompareFlags = '[]
instance O.HasParentTypes SettingCompareFlags

foreign import ccall "nm_setting_compare_flags_get_type" c_nm_setting_compare_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SettingCompareFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_compare_flags_get_type

instance B.Types.BoxedEnum SettingCompareFlags

-- Enum Setting8021xCKScheme
-- | t'GI.NM.Enums.Setting8021xCKScheme' values indicate how a certificate or private key is
-- stored in the setting properties, either as a blob of the item\'s data, or as
-- a path to a certificate or private key file on the filesystem
data Setting8021xCKScheme = 
      Setting8021xCKSchemeUnknown
    -- ^ unknown certificate or private key
    -- scheme
    | Setting8021xCKSchemeBlob
    -- ^ certificate or key is stored as the raw
    -- item data
    | Setting8021xCKSchemePath
    -- ^ certificate or key is stored as a path
    -- to a file containing the certificate or key data
    | Setting8021xCKSchemePkcs11
    -- ^ certificate or key is stored as a
    -- URI of an object on a PKCS@/11/@ token
    | AnotherSetting8021xCKScheme Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Setting8021xCKScheme -> ShowS
[Setting8021xCKScheme] -> ShowS
Setting8021xCKScheme -> String
(Int -> Setting8021xCKScheme -> ShowS)
-> (Setting8021xCKScheme -> String)
-> ([Setting8021xCKScheme] -> ShowS)
-> Show Setting8021xCKScheme
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Setting8021xCKScheme -> ShowS
showsPrec :: Int -> Setting8021xCKScheme -> ShowS
$cshow :: Setting8021xCKScheme -> String
show :: Setting8021xCKScheme -> String
$cshowList :: [Setting8021xCKScheme] -> ShowS
showList :: [Setting8021xCKScheme] -> ShowS
Show, Setting8021xCKScheme -> Setting8021xCKScheme -> Bool
(Setting8021xCKScheme -> Setting8021xCKScheme -> Bool)
-> (Setting8021xCKScheme -> Setting8021xCKScheme -> Bool)
-> Eq Setting8021xCKScheme
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Setting8021xCKScheme -> Setting8021xCKScheme -> Bool
== :: Setting8021xCKScheme -> Setting8021xCKScheme -> Bool
$c/= :: Setting8021xCKScheme -> Setting8021xCKScheme -> Bool
/= :: Setting8021xCKScheme -> Setting8021xCKScheme -> Bool
Eq)

instance P.Enum Setting8021xCKScheme where
    fromEnum :: Setting8021xCKScheme -> Int
fromEnum Setting8021xCKScheme
Setting8021xCKSchemeUnknown = Int
0
    fromEnum Setting8021xCKScheme
Setting8021xCKSchemeBlob = Int
1
    fromEnum Setting8021xCKScheme
Setting8021xCKSchemePath = Int
2
    fromEnum Setting8021xCKScheme
Setting8021xCKSchemePkcs11 = Int
3
    fromEnum (AnotherSetting8021xCKScheme Int
k) = Int
k

    toEnum :: Int -> Setting8021xCKScheme
toEnum Int
0 = Setting8021xCKScheme
Setting8021xCKSchemeUnknown
    toEnum Int
1 = Setting8021xCKScheme
Setting8021xCKSchemeBlob
    toEnum Int
2 = Setting8021xCKScheme
Setting8021xCKSchemePath
    toEnum Int
3 = Setting8021xCKScheme
Setting8021xCKSchemePkcs11
    toEnum Int
k = Int -> Setting8021xCKScheme
AnotherSetting8021xCKScheme Int
k

instance P.Ord Setting8021xCKScheme where
    compare :: Setting8021xCKScheme -> Setting8021xCKScheme -> Ordering
compare Setting8021xCKScheme
a Setting8021xCKScheme
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Setting8021xCKScheme -> Int
forall a. Enum a => a -> Int
P.fromEnum Setting8021xCKScheme
a) (Setting8021xCKScheme -> Int
forall a. Enum a => a -> Int
P.fromEnum Setting8021xCKScheme
b)

type instance O.ParentTypes Setting8021xCKScheme = '[]
instance O.HasParentTypes Setting8021xCKScheme

foreign import ccall "nm_setting_802_1x_ck_scheme_get_type" c_nm_setting_802_1x_ck_scheme_get_type :: 
    IO GType

instance B.Types.TypedObject Setting8021xCKScheme where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_802_1x_ck_scheme_get_type

instance B.Types.BoxedEnum Setting8021xCKScheme

-- Enum Setting8021xCKFormat
-- | t'GI.NM.Enums.Setting8021xCKFormat' values indicate the general type of a certificate
-- or private key
data Setting8021xCKFormat = 
      Setting8021xCKFormatUnknown
    -- ^ unknown file format
    | Setting8021xCKFormatX509
    -- ^ file contains an X.509 format certificate
    | Setting8021xCKFormatRawKey
    -- ^ file contains an old-style OpenSSL PEM
    -- or DER private key
    | Setting8021xCKFormatPkcs12
    -- ^ file contains a PKCS#\<!-- -->12 certificate
    -- and private key
    | AnotherSetting8021xCKFormat Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Setting8021xCKFormat -> ShowS
[Setting8021xCKFormat] -> ShowS
Setting8021xCKFormat -> String
(Int -> Setting8021xCKFormat -> ShowS)
-> (Setting8021xCKFormat -> String)
-> ([Setting8021xCKFormat] -> ShowS)
-> Show Setting8021xCKFormat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Setting8021xCKFormat -> ShowS
showsPrec :: Int -> Setting8021xCKFormat -> ShowS
$cshow :: Setting8021xCKFormat -> String
show :: Setting8021xCKFormat -> String
$cshowList :: [Setting8021xCKFormat] -> ShowS
showList :: [Setting8021xCKFormat] -> ShowS
Show, Setting8021xCKFormat -> Setting8021xCKFormat -> Bool
(Setting8021xCKFormat -> Setting8021xCKFormat -> Bool)
-> (Setting8021xCKFormat -> Setting8021xCKFormat -> Bool)
-> Eq Setting8021xCKFormat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Setting8021xCKFormat -> Setting8021xCKFormat -> Bool
== :: Setting8021xCKFormat -> Setting8021xCKFormat -> Bool
$c/= :: Setting8021xCKFormat -> Setting8021xCKFormat -> Bool
/= :: Setting8021xCKFormat -> Setting8021xCKFormat -> Bool
Eq)

instance P.Enum Setting8021xCKFormat where
    fromEnum :: Setting8021xCKFormat -> Int
fromEnum Setting8021xCKFormat
Setting8021xCKFormatUnknown = Int
0
    fromEnum Setting8021xCKFormat
Setting8021xCKFormatX509 = Int
1
    fromEnum Setting8021xCKFormat
Setting8021xCKFormatRawKey = Int
2
    fromEnum Setting8021xCKFormat
Setting8021xCKFormatPkcs12 = Int
3
    fromEnum (AnotherSetting8021xCKFormat Int
k) = Int
k

    toEnum :: Int -> Setting8021xCKFormat
toEnum Int
0 = Setting8021xCKFormat
Setting8021xCKFormatUnknown
    toEnum Int
1 = Setting8021xCKFormat
Setting8021xCKFormatX509
    toEnum Int
2 = Setting8021xCKFormat
Setting8021xCKFormatRawKey
    toEnum Int
3 = Setting8021xCKFormat
Setting8021xCKFormatPkcs12
    toEnum Int
k = Int -> Setting8021xCKFormat
AnotherSetting8021xCKFormat Int
k

instance P.Ord Setting8021xCKFormat where
    compare :: Setting8021xCKFormat -> Setting8021xCKFormat -> Ordering
compare Setting8021xCKFormat
a Setting8021xCKFormat
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Setting8021xCKFormat -> Int
forall a. Enum a => a -> Int
P.fromEnum Setting8021xCKFormat
a) (Setting8021xCKFormat -> Int
forall a. Enum a => a -> Int
P.fromEnum Setting8021xCKFormat
b)

type instance O.ParentTypes Setting8021xCKFormat = '[]
instance O.HasParentTypes Setting8021xCKFormat

foreign import ccall "nm_setting_802_1x_ck_format_get_type" c_nm_setting_802_1x_ck_format_get_type :: 
    IO GType

instance B.Types.TypedObject Setting8021xCKFormat where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_802_1x_ck_format_get_type

instance B.Types.BoxedEnum Setting8021xCKFormat

-- Enum SecretAgentError
-- | t'GI.NM.Enums.SecretAgentError' values are passed by secret agents back to NetworkManager
-- when they encounter problems retrieving secrets on behalf of NM. They
-- correspond to errors in the \"org.freedesktop.NetworkManager.SecretManager\"
-- namespace.
-- 
-- Client APIs such as @/nm_client_activate_connection()/@ will not see these error
-- codes; instead, the secret agent manager will translate them to the
-- corresponding t'GI.NM.Enums.AgentManagerError' codes.
data SecretAgentError = 
      SecretAgentErrorFailed
    -- ^ unknown or unclassified error
    | SecretAgentErrorPermissionDenied
    -- ^ the caller (ie, NetworkManager) is
    --   not authorized to make this request
    | SecretAgentErrorInvalidConnection
    -- ^ the connection for which secrets
    --   were requested is invalid
    | SecretAgentErrorUserCanceled
    -- ^ the request was canceled by the user
    | SecretAgentErrorAgentCanceled
    -- ^ the agent canceled the request
    --   because it was requested to do so by NetworkManager
    | SecretAgentErrorNoSecrets
    -- ^ the agent cannot find any secrets for this
    --   connection
    | AnotherSecretAgentError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SecretAgentError -> ShowS
[SecretAgentError] -> ShowS
SecretAgentError -> String
(Int -> SecretAgentError -> ShowS)
-> (SecretAgentError -> String)
-> ([SecretAgentError] -> ShowS)
-> Show SecretAgentError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SecretAgentError -> ShowS
showsPrec :: Int -> SecretAgentError -> ShowS
$cshow :: SecretAgentError -> String
show :: SecretAgentError -> String
$cshowList :: [SecretAgentError] -> ShowS
showList :: [SecretAgentError] -> ShowS
Show, SecretAgentError -> SecretAgentError -> Bool
(SecretAgentError -> SecretAgentError -> Bool)
-> (SecretAgentError -> SecretAgentError -> Bool)
-> Eq SecretAgentError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SecretAgentError -> SecretAgentError -> Bool
== :: SecretAgentError -> SecretAgentError -> Bool
$c/= :: SecretAgentError -> SecretAgentError -> Bool
/= :: SecretAgentError -> SecretAgentError -> Bool
Eq)

instance P.Enum SecretAgentError where
    fromEnum :: SecretAgentError -> Int
fromEnum SecretAgentError
SecretAgentErrorFailed = Int
0
    fromEnum SecretAgentError
SecretAgentErrorPermissionDenied = Int
1
    fromEnum SecretAgentError
SecretAgentErrorInvalidConnection = Int
2
    fromEnum SecretAgentError
SecretAgentErrorUserCanceled = Int
3
    fromEnum SecretAgentError
SecretAgentErrorAgentCanceled = Int
4
    fromEnum SecretAgentError
SecretAgentErrorNoSecrets = Int
5
    fromEnum (AnotherSecretAgentError Int
k) = Int
k

    toEnum :: Int -> SecretAgentError
toEnum Int
0 = SecretAgentError
SecretAgentErrorFailed
    toEnum Int
1 = SecretAgentError
SecretAgentErrorPermissionDenied
    toEnum Int
2 = SecretAgentError
SecretAgentErrorInvalidConnection
    toEnum Int
3 = SecretAgentError
SecretAgentErrorUserCanceled
    toEnum Int
4 = SecretAgentError
SecretAgentErrorAgentCanceled
    toEnum Int
5 = SecretAgentError
SecretAgentErrorNoSecrets
    toEnum Int
k = Int -> SecretAgentError
AnotherSecretAgentError Int
k

instance P.Ord SecretAgentError where
    compare :: SecretAgentError -> SecretAgentError -> Ordering
compare SecretAgentError
a SecretAgentError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SecretAgentError -> Int
forall a. Enum a => a -> Int
P.fromEnum SecretAgentError
a) (SecretAgentError -> Int
forall a. Enum a => a -> Int
P.fromEnum SecretAgentError
b)

instance GErrorClass SecretAgentError where
    gerrorClassDomain :: SecretAgentError -> Text
gerrorClassDomain SecretAgentError
_ = Text
"nm-secret-agent-error-quark"

-- | Catch exceptions of type `SecretAgentError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchSecretAgentError ::
    IO a ->
    (SecretAgentError -> GErrorMessage -> IO a) ->
    IO a
catchSecretAgentError :: forall a. IO a -> (SecretAgentError -> Text -> IO a) -> IO a
catchSecretAgentError = IO a -> (SecretAgentError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `SecretAgentError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleSecretAgentError ::
    (SecretAgentError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleSecretAgentError :: forall a. (SecretAgentError -> Text -> IO a) -> IO a -> IO a
handleSecretAgentError = (SecretAgentError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes SecretAgentError = '[]
instance O.HasParentTypes SecretAgentError

foreign import ccall "nm_secret_agent_error_get_type" c_nm_secret_agent_error_get_type :: 
    IO GType

instance B.Types.TypedObject SecretAgentError where
    glibType :: IO GType
glibType = IO GType
c_nm_secret_agent_error_get_type

instance B.Types.BoxedEnum SecretAgentError

-- Enum RollbackResult
-- | The result of a checkpoint @/Rollback()/@ operation for a specific device.
-- 
-- /Since: 1.4/
data RollbackResult = 
      RollbackResultOk
    -- ^ the rollback succeeded.
    | RollbackResultErrNoDevice
    -- ^ the device no longer exists.
    | RollbackResultErrDeviceUnmanaged
    -- ^ the device is now unmanaged.
    | RollbackResultErrFailed
    -- ^ other errors during rollback.
    | AnotherRollbackResult Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RollbackResult -> ShowS
[RollbackResult] -> ShowS
RollbackResult -> String
(Int -> RollbackResult -> ShowS)
-> (RollbackResult -> String)
-> ([RollbackResult] -> ShowS)
-> Show RollbackResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RollbackResult -> ShowS
showsPrec :: Int -> RollbackResult -> ShowS
$cshow :: RollbackResult -> String
show :: RollbackResult -> String
$cshowList :: [RollbackResult] -> ShowS
showList :: [RollbackResult] -> ShowS
Show, RollbackResult -> RollbackResult -> Bool
(RollbackResult -> RollbackResult -> Bool)
-> (RollbackResult -> RollbackResult -> Bool) -> Eq RollbackResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RollbackResult -> RollbackResult -> Bool
== :: RollbackResult -> RollbackResult -> Bool
$c/= :: RollbackResult -> RollbackResult -> Bool
/= :: RollbackResult -> RollbackResult -> Bool
Eq)

instance P.Enum RollbackResult where
    fromEnum :: RollbackResult -> Int
fromEnum RollbackResult
RollbackResultOk = Int
0
    fromEnum RollbackResult
RollbackResultErrNoDevice = Int
1
    fromEnum RollbackResult
RollbackResultErrDeviceUnmanaged = Int
2
    fromEnum RollbackResult
RollbackResultErrFailed = Int
3
    fromEnum (AnotherRollbackResult Int
k) = Int
k

    toEnum :: Int -> RollbackResult
toEnum Int
0 = RollbackResult
RollbackResultOk
    toEnum Int
1 = RollbackResult
RollbackResultErrNoDevice
    toEnum Int
2 = RollbackResult
RollbackResultErrDeviceUnmanaged
    toEnum Int
3 = RollbackResult
RollbackResultErrFailed
    toEnum Int
k = Int -> RollbackResult
AnotherRollbackResult Int
k

instance P.Ord RollbackResult where
    compare :: RollbackResult -> RollbackResult -> Ordering
compare RollbackResult
a RollbackResult
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RollbackResult -> Int
forall a. Enum a => a -> Int
P.fromEnum RollbackResult
a) (RollbackResult -> Int
forall a. Enum a => a -> Int
P.fromEnum RollbackResult
b)

-- Enum Metered
-- | The NMMetered enum has two different purposes: one is to configure
-- \"connection.metered\" setting of a connection profile in t'GI.NM.Objects.SettingConnection.SettingConnection', and
-- the other is to express the actual metered state of the t'GI.NM.Objects.Device.Device' at a given moment.
-- 
-- For the connection profile only @/NM_METERED_UNKNOWN/@, @/NM_METERED_NO/@
-- and @/NM_METERED_YES/@ are allowed.
-- 
-- The device\'s metered state at runtime is determined by the profile
-- which is currently active. If the profile explicitly specifies @/NM_METERED_NO/@
-- or @/NM_METERED_YES/@, then the device\'s metered state is as such.
-- If the connection profile leaves it undecided at @/NM_METERED_UNKNOWN/@ (the default),
-- then NetworkManager tries to guess the metered state, for example based on the
-- device type or on DHCP options (like Android devices exposing a \"ANDROID_METERED\"
-- DHCP vendor option). This then leads to either @/NM_METERED_GUESS_NO/@ or @/NM_METERED_GUESS_YES/@.
-- 
-- Most applications probably should treat the runtime state @/NM_METERED_GUESS_YES/@
-- like @/NM_METERED_YES/@, and all other states as not metered.
-- 
-- Note that the per-device metered states are then combined to a global metered
-- state. This is basically the metered state of the device with the best default
-- route. However, that generalization of a global metered state may not be correct
-- if the default routes for IPv4 and IPv6 are on different devices, or if policy
-- routing is configured. In general, the global metered state tries to express whether
-- the traffic is likely metered, but since that depends on the traffic itself,
-- there is not one answer in all cases. Hence, an application may want to consider
-- the per-device\'s metered states.
-- 
-- /Since: 1.2/
data Metered = 
      MeteredUnknown
    -- ^ The metered status is unknown
    | MeteredYes
    -- ^ Metered, the value was explicitly configured
    | MeteredNo
    -- ^ Not metered, the value was explicitly configured
    | MeteredGuessYes
    -- ^ Metered, the value was guessed
    | MeteredGuessNo
    -- ^ Not metered, the value was guessed
    | AnotherMetered Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Metered -> ShowS
[Metered] -> ShowS
Metered -> String
(Int -> Metered -> ShowS)
-> (Metered -> String) -> ([Metered] -> ShowS) -> Show Metered
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Metered -> ShowS
showsPrec :: Int -> Metered -> ShowS
$cshow :: Metered -> String
show :: Metered -> String
$cshowList :: [Metered] -> ShowS
showList :: [Metered] -> ShowS
Show, Metered -> Metered -> Bool
(Metered -> Metered -> Bool)
-> (Metered -> Metered -> Bool) -> Eq Metered
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Metered -> Metered -> Bool
== :: Metered -> Metered -> Bool
$c/= :: Metered -> Metered -> Bool
/= :: Metered -> Metered -> Bool
Eq)

instance P.Enum Metered where
    fromEnum :: Metered -> Int
fromEnum Metered
MeteredUnknown = Int
0
    fromEnum Metered
MeteredYes = Int
1
    fromEnum Metered
MeteredNo = Int
2
    fromEnum Metered
MeteredGuessYes = Int
3
    fromEnum Metered
MeteredGuessNo = Int
4
    fromEnum (AnotherMetered Int
k) = Int
k

    toEnum :: Int -> Metered
toEnum Int
0 = Metered
MeteredUnknown
    toEnum Int
1 = Metered
MeteredYes
    toEnum Int
2 = Metered
MeteredNo
    toEnum Int
3 = Metered
MeteredGuessYes
    toEnum Int
4 = Metered
MeteredGuessNo
    toEnum Int
k = Int -> Metered
AnotherMetered Int
k

instance P.Ord Metered where
    compare :: Metered -> Metered -> Ordering
compare Metered
a Metered
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Metered -> Int
forall a. Enum a => a -> Int
P.fromEnum Metered
a) (Metered -> Int
forall a. Enum a => a -> Int
P.fromEnum Metered
b)

type instance O.ParentTypes Metered = '[]
instance O.HasParentTypes Metered

foreign import ccall "nm_metered_get_type" c_nm_metered_get_type :: 
    IO GType

instance B.Types.TypedObject Metered where
    glibType :: IO GType
glibType = IO GType
c_nm_metered_get_type

instance B.Types.BoxedEnum Metered

-- Enum ManagerError
-- | Errors related to the main \"network management\" interface of NetworkManager.
-- These may be returned from t'GI.NM.Objects.Client.Client' methods that invoke D-Bus operations on
-- the \"org.freedesktop.NetworkManager\" interface, and correspond to D-Bus
-- errors in that namespace.
data ManagerError = 
      ManagerErrorFailed
    -- ^ unknown or unclassified error
    | ManagerErrorPermissionDenied
    -- ^ Permission denied.
    | ManagerErrorUnknownConnection
    -- ^ The requested connection is not known.
    | ManagerErrorUnknownDevice
    -- ^ The requested device is not known.
    | ManagerErrorConnectionNotAvailable
    -- ^ The requested connection cannot be
    --   activated at this time.
    | ManagerErrorConnectionNotActive
    -- ^ The request could not be completed
    --   because a required connection is not active.
    | ManagerErrorConnectionAlreadyActive
    -- ^ The connection to be activated was
    --   already active on another device.
    | ManagerErrorDependencyFailed
    -- ^ An activation request failed due to a
    --   dependency being unavailable.
    | ManagerErrorAlreadyAsleepOrAwake
    -- ^ The manager is already in the requested
    --   sleep\/wake state.
    | ManagerErrorAlreadyEnabledOrDisabled
    -- ^ The network is already
    --   enabled\/disabled.
    | ManagerErrorUnknownLogLevel
    -- ^ Unknown log level in SetLogging
    | ManagerErrorUnknownLogDomain
    -- ^ Unknown log domain in SetLogging
    | ManagerErrorInvalidArguments
    -- ^ Invalid arguments for D-Bus request
    | ManagerErrorMissingPlugin
    -- ^ A plug-in was needed to complete the
    --   activation but is not available.
    | AnotherManagerError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ManagerError -> ShowS
[ManagerError] -> ShowS
ManagerError -> String
(Int -> ManagerError -> ShowS)
-> (ManagerError -> String)
-> ([ManagerError] -> ShowS)
-> Show ManagerError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ManagerError -> ShowS
showsPrec :: Int -> ManagerError -> ShowS
$cshow :: ManagerError -> String
show :: ManagerError -> String
$cshowList :: [ManagerError] -> ShowS
showList :: [ManagerError] -> ShowS
Show, ManagerError -> ManagerError -> Bool
(ManagerError -> ManagerError -> Bool)
-> (ManagerError -> ManagerError -> Bool) -> Eq ManagerError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ManagerError -> ManagerError -> Bool
== :: ManagerError -> ManagerError -> Bool
$c/= :: ManagerError -> ManagerError -> Bool
/= :: ManagerError -> ManagerError -> Bool
Eq)

instance P.Enum ManagerError where
    fromEnum :: ManagerError -> Int
fromEnum ManagerError
ManagerErrorFailed = Int
0
    fromEnum ManagerError
ManagerErrorPermissionDenied = Int
1
    fromEnum ManagerError
ManagerErrorUnknownConnection = Int
2
    fromEnum ManagerError
ManagerErrorUnknownDevice = Int
3
    fromEnum ManagerError
ManagerErrorConnectionNotAvailable = Int
4
    fromEnum ManagerError
ManagerErrorConnectionNotActive = Int
5
    fromEnum ManagerError
ManagerErrorConnectionAlreadyActive = Int
6
    fromEnum ManagerError
ManagerErrorDependencyFailed = Int
7
    fromEnum ManagerError
ManagerErrorAlreadyAsleepOrAwake = Int
8
    fromEnum ManagerError
ManagerErrorAlreadyEnabledOrDisabled = Int
9
    fromEnum ManagerError
ManagerErrorUnknownLogLevel = Int
10
    fromEnum ManagerError
ManagerErrorUnknownLogDomain = Int
11
    fromEnum ManagerError
ManagerErrorInvalidArguments = Int
12
    fromEnum ManagerError
ManagerErrorMissingPlugin = Int
13
    fromEnum (AnotherManagerError Int
k) = Int
k

    toEnum :: Int -> ManagerError
toEnum Int
0 = ManagerError
ManagerErrorFailed
    toEnum Int
1 = ManagerError
ManagerErrorPermissionDenied
    toEnum Int
2 = ManagerError
ManagerErrorUnknownConnection
    toEnum Int
3 = ManagerError
ManagerErrorUnknownDevice
    toEnum Int
4 = ManagerError
ManagerErrorConnectionNotAvailable
    toEnum Int
5 = ManagerError
ManagerErrorConnectionNotActive
    toEnum Int
6 = ManagerError
ManagerErrorConnectionAlreadyActive
    toEnum Int
7 = ManagerError
ManagerErrorDependencyFailed
    toEnum Int
8 = ManagerError
ManagerErrorAlreadyAsleepOrAwake
    toEnum Int
9 = ManagerError
ManagerErrorAlreadyEnabledOrDisabled
    toEnum Int
10 = ManagerError
ManagerErrorUnknownLogLevel
    toEnum Int
11 = ManagerError
ManagerErrorUnknownLogDomain
    toEnum Int
12 = ManagerError
ManagerErrorInvalidArguments
    toEnum Int
13 = ManagerError
ManagerErrorMissingPlugin
    toEnum Int
k = Int -> ManagerError
AnotherManagerError Int
k

instance P.Ord ManagerError where
    compare :: ManagerError -> ManagerError -> Ordering
compare ManagerError
a ManagerError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ManagerError -> Int
forall a. Enum a => a -> Int
P.fromEnum ManagerError
a) (ManagerError -> Int
forall a. Enum a => a -> Int
P.fromEnum ManagerError
b)

instance GErrorClass ManagerError where
    gerrorClassDomain :: ManagerError -> Text
gerrorClassDomain ManagerError
_ = Text
"nm-manager-error-quark"

-- | Catch exceptions of type `ManagerError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchManagerError ::
    IO a ->
    (ManagerError -> GErrorMessage -> IO a) ->
    IO a
catchManagerError :: forall a. IO a -> (ManagerError -> Text -> IO a) -> IO a
catchManagerError = IO a -> (ManagerError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `ManagerError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleManagerError ::
    (ManagerError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleManagerError :: forall a. (ManagerError -> Text -> IO a) -> IO a -> IO a
handleManagerError = (ManagerError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes ManagerError = '[]
instance O.HasParentTypes ManagerError

foreign import ccall "nm_manager_error_get_type" c_nm_manager_error_get_type :: 
    IO GType

instance B.Types.TypedObject ManagerError where
    glibType :: IO GType
glibType = IO GType
c_nm_manager_error_get_type

instance B.Types.BoxedEnum ManagerError

-- Enum KeyfileWarnSeverity
-- | The severity level of 'GI.NM.Enums.KeyfileHandlerTypeWarn' events.
-- 
-- /Since: 1.30/
data KeyfileWarnSeverity = 
      KeyfileWarnSeverityDebug
    -- ^ debug message
    | KeyfileWarnSeverityInfo
    -- ^ info message
    | KeyfileWarnSeverityInfoMissingFile
    -- ^ info message about a missing file
    | KeyfileWarnSeverityWarn
    -- ^ a warning message
    | AnotherKeyfileWarnSeverity Int
    -- ^ Catch-all for unknown values
    deriving (Int -> KeyfileWarnSeverity -> ShowS
[KeyfileWarnSeverity] -> ShowS
KeyfileWarnSeverity -> String
(Int -> KeyfileWarnSeverity -> ShowS)
-> (KeyfileWarnSeverity -> String)
-> ([KeyfileWarnSeverity] -> ShowS)
-> Show KeyfileWarnSeverity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyfileWarnSeverity -> ShowS
showsPrec :: Int -> KeyfileWarnSeverity -> ShowS
$cshow :: KeyfileWarnSeverity -> String
show :: KeyfileWarnSeverity -> String
$cshowList :: [KeyfileWarnSeverity] -> ShowS
showList :: [KeyfileWarnSeverity] -> ShowS
Show, KeyfileWarnSeverity -> KeyfileWarnSeverity -> Bool
(KeyfileWarnSeverity -> KeyfileWarnSeverity -> Bool)
-> (KeyfileWarnSeverity -> KeyfileWarnSeverity -> Bool)
-> Eq KeyfileWarnSeverity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyfileWarnSeverity -> KeyfileWarnSeverity -> Bool
== :: KeyfileWarnSeverity -> KeyfileWarnSeverity -> Bool
$c/= :: KeyfileWarnSeverity -> KeyfileWarnSeverity -> Bool
/= :: KeyfileWarnSeverity -> KeyfileWarnSeverity -> Bool
Eq)

instance P.Enum KeyfileWarnSeverity where
    fromEnum :: KeyfileWarnSeverity -> Int
fromEnum KeyfileWarnSeverity
KeyfileWarnSeverityDebug = Int
1000
    fromEnum KeyfileWarnSeverity
KeyfileWarnSeverityInfo = Int
2000
    fromEnum KeyfileWarnSeverity
KeyfileWarnSeverityInfoMissingFile = Int
2901
    fromEnum KeyfileWarnSeverity
KeyfileWarnSeverityWarn = Int
3000
    fromEnum (AnotherKeyfileWarnSeverity Int
k) = Int
k

    toEnum :: Int -> KeyfileWarnSeverity
toEnum Int
1000 = KeyfileWarnSeverity
KeyfileWarnSeverityDebug
    toEnum Int
2000 = KeyfileWarnSeverity
KeyfileWarnSeverityInfo
    toEnum Int
2901 = KeyfileWarnSeverity
KeyfileWarnSeverityInfoMissingFile
    toEnum Int
3000 = KeyfileWarnSeverity
KeyfileWarnSeverityWarn
    toEnum Int
k = Int -> KeyfileWarnSeverity
AnotherKeyfileWarnSeverity Int
k

instance P.Ord KeyfileWarnSeverity where
    compare :: KeyfileWarnSeverity -> KeyfileWarnSeverity -> Ordering
compare KeyfileWarnSeverity
a KeyfileWarnSeverity
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (KeyfileWarnSeverity -> Int
forall a. Enum a => a -> Int
P.fromEnum KeyfileWarnSeverity
a) (KeyfileWarnSeverity -> Int
forall a. Enum a => a -> Int
P.fromEnum KeyfileWarnSeverity
b)

type instance O.ParentTypes KeyfileWarnSeverity = '[]
instance O.HasParentTypes KeyfileWarnSeverity

foreign import ccall "nm_keyfile_warn_severity_get_type" c_nm_keyfile_warn_severity_get_type :: 
    IO GType

instance B.Types.TypedObject KeyfileWarnSeverity where
    glibType :: IO GType
glibType = IO GType
c_nm_keyfile_warn_severity_get_type

instance B.Types.BoxedEnum KeyfileWarnSeverity

-- Enum KeyfileHandlerType
-- | The type of the callback for @/NMKeyfileReadHandler/@ and @/NMKeyfileWriteHandler/@.
-- Depending on the type, you can interpret @/NMKeyfileHandlerData/@.
-- 
-- /Since: 1.30/
data KeyfileHandlerType = 
      KeyfileHandlerTypeWarn
    -- ^ a warning.
    | KeyfileHandlerTypeWriteCert
    -- ^ for handling certificates while writing
    --   a connection to keyfile.
    | AnotherKeyfileHandlerType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> KeyfileHandlerType -> ShowS
[KeyfileHandlerType] -> ShowS
KeyfileHandlerType -> String
(Int -> KeyfileHandlerType -> ShowS)
-> (KeyfileHandlerType -> String)
-> ([KeyfileHandlerType] -> ShowS)
-> Show KeyfileHandlerType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyfileHandlerType -> ShowS
showsPrec :: Int -> KeyfileHandlerType -> ShowS
$cshow :: KeyfileHandlerType -> String
show :: KeyfileHandlerType -> String
$cshowList :: [KeyfileHandlerType] -> ShowS
showList :: [KeyfileHandlerType] -> ShowS
Show, KeyfileHandlerType -> KeyfileHandlerType -> Bool
(KeyfileHandlerType -> KeyfileHandlerType -> Bool)
-> (KeyfileHandlerType -> KeyfileHandlerType -> Bool)
-> Eq KeyfileHandlerType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyfileHandlerType -> KeyfileHandlerType -> Bool
== :: KeyfileHandlerType -> KeyfileHandlerType -> Bool
$c/= :: KeyfileHandlerType -> KeyfileHandlerType -> Bool
/= :: KeyfileHandlerType -> KeyfileHandlerType -> Bool
Eq)

instance P.Enum KeyfileHandlerType where
    fromEnum :: KeyfileHandlerType -> Int
fromEnum KeyfileHandlerType
KeyfileHandlerTypeWarn = Int
1
    fromEnum KeyfileHandlerType
KeyfileHandlerTypeWriteCert = Int
2
    fromEnum (AnotherKeyfileHandlerType Int
k) = Int
k

    toEnum :: Int -> KeyfileHandlerType
toEnum Int
1 = KeyfileHandlerType
KeyfileHandlerTypeWarn
    toEnum Int
2 = KeyfileHandlerType
KeyfileHandlerTypeWriteCert
    toEnum Int
k = Int -> KeyfileHandlerType
AnotherKeyfileHandlerType Int
k

instance P.Ord KeyfileHandlerType where
    compare :: KeyfileHandlerType -> KeyfileHandlerType -> Ordering
compare KeyfileHandlerType
a KeyfileHandlerType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (KeyfileHandlerType -> Int
forall a. Enum a => a -> Int
P.fromEnum KeyfileHandlerType
a) (KeyfileHandlerType -> Int
forall a. Enum a => a -> Int
P.fromEnum KeyfileHandlerType
b)

type instance O.ParentTypes KeyfileHandlerType = '[]
instance O.HasParentTypes KeyfileHandlerType

foreign import ccall "nm_keyfile_handler_type_get_type" c_nm_keyfile_handler_type_get_type :: 
    IO GType

instance B.Types.TypedObject KeyfileHandlerType where
    glibType :: IO GType
glibType = IO GType
c_nm_keyfile_handler_type_get_type

instance B.Types.BoxedEnum KeyfileHandlerType

-- Enum IPTunnelMode
-- | The tunneling mode.
-- 
-- /Since: 1.2/
data IPTunnelMode = 
      IPTunnelModeUnknown
    -- ^ Unknown\/unset tunnel mode
    | IPTunnelModeIpip
    -- ^ IP in IP tunnel
    | IPTunnelModeGre
    -- ^ GRE tunnel
    | IPTunnelModeSit
    -- ^ SIT tunnel
    | IPTunnelModeIsatap
    -- ^ ISATAP tunnel
    | IPTunnelModeVti
    -- ^ VTI tunnel
    | IPTunnelModeIp6ip6
    -- ^ IPv6 in IPv6 tunnel
    | IPTunnelModeIpip6
    -- ^ IPv4 in IPv6 tunnel
    | IPTunnelModeIp6gre
    -- ^ IPv6 GRE tunnel
    | IPTunnelModeVti6
    -- ^ IPv6 VTI tunnel
    | IPTunnelModeGretap
    -- ^ GRETAP tunnel
    | IPTunnelModeIp6gretap
    -- ^ IPv6 GRETAP tunnel
    | AnotherIPTunnelMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> IPTunnelMode -> ShowS
[IPTunnelMode] -> ShowS
IPTunnelMode -> String
(Int -> IPTunnelMode -> ShowS)
-> (IPTunnelMode -> String)
-> ([IPTunnelMode] -> ShowS)
-> Show IPTunnelMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IPTunnelMode -> ShowS
showsPrec :: Int -> IPTunnelMode -> ShowS
$cshow :: IPTunnelMode -> String
show :: IPTunnelMode -> String
$cshowList :: [IPTunnelMode] -> ShowS
showList :: [IPTunnelMode] -> ShowS
Show, IPTunnelMode -> IPTunnelMode -> Bool
(IPTunnelMode -> IPTunnelMode -> Bool)
-> (IPTunnelMode -> IPTunnelMode -> Bool) -> Eq IPTunnelMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IPTunnelMode -> IPTunnelMode -> Bool
== :: IPTunnelMode -> IPTunnelMode -> Bool
$c/= :: IPTunnelMode -> IPTunnelMode -> Bool
/= :: IPTunnelMode -> IPTunnelMode -> Bool
Eq)

instance P.Enum IPTunnelMode where
    fromEnum :: IPTunnelMode -> Int
fromEnum IPTunnelMode
IPTunnelModeUnknown = Int
0
    fromEnum IPTunnelMode
IPTunnelModeIpip = Int
1
    fromEnum IPTunnelMode
IPTunnelModeGre = Int
2
    fromEnum IPTunnelMode
IPTunnelModeSit = Int
3
    fromEnum IPTunnelMode
IPTunnelModeIsatap = Int
4
    fromEnum IPTunnelMode
IPTunnelModeVti = Int
5
    fromEnum IPTunnelMode
IPTunnelModeIp6ip6 = Int
6
    fromEnum IPTunnelMode
IPTunnelModeIpip6 = Int
7
    fromEnum IPTunnelMode
IPTunnelModeIp6gre = Int
8
    fromEnum IPTunnelMode
IPTunnelModeVti6 = Int
9
    fromEnum IPTunnelMode
IPTunnelModeGretap = Int
10
    fromEnum IPTunnelMode
IPTunnelModeIp6gretap = Int
11
    fromEnum (AnotherIPTunnelMode Int
k) = Int
k

    toEnum :: Int -> IPTunnelMode
toEnum Int
0 = IPTunnelMode
IPTunnelModeUnknown
    toEnum Int
1 = IPTunnelMode
IPTunnelModeIpip
    toEnum Int
2 = IPTunnelMode
IPTunnelModeGre
    toEnum Int
3 = IPTunnelMode
IPTunnelModeSit
    toEnum Int
4 = IPTunnelMode
IPTunnelModeIsatap
    toEnum Int
5 = IPTunnelMode
IPTunnelModeVti
    toEnum Int
6 = IPTunnelMode
IPTunnelModeIp6ip6
    toEnum Int
7 = IPTunnelMode
IPTunnelModeIpip6
    toEnum Int
8 = IPTunnelMode
IPTunnelModeIp6gre
    toEnum Int
9 = IPTunnelMode
IPTunnelModeVti6
    toEnum Int
10 = IPTunnelMode
IPTunnelModeGretap
    toEnum Int
11 = IPTunnelMode
IPTunnelModeIp6gretap
    toEnum Int
k = Int -> IPTunnelMode
AnotherIPTunnelMode Int
k

instance P.Ord IPTunnelMode where
    compare :: IPTunnelMode -> IPTunnelMode -> Ordering
compare IPTunnelMode
a IPTunnelMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (IPTunnelMode -> Int
forall a. Enum a => a -> Int
P.fromEnum IPTunnelMode
a) (IPTunnelMode -> Int
forall a. Enum a => a -> Int
P.fromEnum IPTunnelMode
b)

type instance O.ParentTypes IPTunnelMode = '[]
instance O.HasParentTypes IPTunnelMode

foreign import ccall "nm_ip_tunnel_mode_get_type" c_nm_ip_tunnel_mode_get_type :: 
    IO GType

instance B.Types.TypedObject IPTunnelMode where
    glibType :: IO GType
glibType = IO GType
c_nm_ip_tunnel_mode_get_type

instance B.Types.BoxedEnum IPTunnelMode

-- Enum DeviceType
-- | t'GI.NM.Enums.DeviceType' values indicate the type of hardware represented by a
-- device object.
data DeviceType = 
      DeviceTypeUnknown
    -- ^ unknown device
    | DeviceTypeEthernet
    -- ^ a wired ethernet device
    | DeviceTypeWifi
    -- ^ an 802.11 Wi-Fi device
    | DeviceTypeUnused1
    -- ^ not used
    | DeviceTypeUnused2
    -- ^ not used
    | DeviceTypeBt
    -- ^ a Bluetooth device supporting PAN or DUN access protocols
    | DeviceTypeOlpcMesh
    -- ^ an OLPC XO mesh networking device
    | DeviceTypeWimax
    -- ^ an 802.16e Mobile WiMAX broadband device
    | DeviceTypeModem
    -- ^ a modem supporting analog telephone, CDMA\/EVDO,
    -- GSM\/UMTS, or LTE network access protocols
    | DeviceTypeInfiniband
    -- ^ an IP-over-InfiniBand device
    | DeviceTypeBond
    -- ^ a bond controller interface
    | DeviceTypeVlan
    -- ^ an 802.1Q VLAN interface
    | DeviceTypeAdsl
    -- ^ ADSL modem
    | DeviceTypeBridge
    -- ^ a bridge controller interface
    | DeviceTypeGeneric
    -- ^ generic support for unrecognized device types
    | DeviceTypeTeam
    -- ^ a team controller interface
    | DeviceTypeTun
    -- ^ a TUN or TAP interface
    | DeviceTypeIpTunnel
    -- ^ a IP tunnel interface
    | DeviceTypeMacvlan
    -- ^ a MACVLAN interface
    | DeviceTypeVxlan
    -- ^ a VXLAN interface
    | DeviceTypeVeth
    -- ^ a VETH interface
    | DeviceTypeMacsec
    -- ^ a MACsec interface
    | DeviceTypeDummy
    -- ^ a dummy interface
    | DeviceTypePpp
    -- ^ a PPP interface
    | DeviceTypeOvsInterface
    -- ^ a Open vSwitch interface
    | DeviceTypeOvsPort
    -- ^ a Open vSwitch port
    | DeviceTypeOvsBridge
    -- ^ a Open vSwitch bridge
    | DeviceTypeWpan
    -- ^ a IEEE 802.15.4 (WPAN) MAC Layer Device
    | DeviceType6lowpan
    -- ^ 6LoWPAN interface
    | DeviceTypeWireguard
    -- ^ a WireGuard interface
    | DeviceTypeWifiP2p
    -- ^ an 802.11 Wi-Fi P2P device. Since: 1.16.
    | DeviceTypeVrf
    -- ^ A VRF (Virtual Routing and Forwarding) interface. Since: 1.24.
    | DeviceTypeLoopback
    -- ^ a loopback interface. Since: 1.42.
    | DeviceTypeHsr
    -- ^ A HSR\/PRP device. Since: 1.46.
    | AnotherDeviceType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DeviceType -> ShowS
[DeviceType] -> ShowS
DeviceType -> String
(Int -> DeviceType -> ShowS)
-> (DeviceType -> String)
-> ([DeviceType] -> ShowS)
-> Show DeviceType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DeviceType -> ShowS
showsPrec :: Int -> DeviceType -> ShowS
$cshow :: DeviceType -> String
show :: DeviceType -> String
$cshowList :: [DeviceType] -> ShowS
showList :: [DeviceType] -> ShowS
Show, DeviceType -> DeviceType -> Bool
(DeviceType -> DeviceType -> Bool)
-> (DeviceType -> DeviceType -> Bool) -> Eq DeviceType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeviceType -> DeviceType -> Bool
== :: DeviceType -> DeviceType -> Bool
$c/= :: DeviceType -> DeviceType -> Bool
/= :: DeviceType -> DeviceType -> Bool
Eq)

instance P.Enum DeviceType where
    fromEnum :: DeviceType -> Int
fromEnum DeviceType
DeviceTypeUnknown = Int
0
    fromEnum DeviceType
DeviceTypeEthernet = Int
1
    fromEnum DeviceType
DeviceTypeWifi = Int
2
    fromEnum DeviceType
DeviceTypeUnused1 = Int
3
    fromEnum DeviceType
DeviceTypeUnused2 = Int
4
    fromEnum DeviceType
DeviceTypeBt = Int
5
    fromEnum DeviceType
DeviceTypeOlpcMesh = Int
6
    fromEnum DeviceType
DeviceTypeWimax = Int
7
    fromEnum DeviceType
DeviceTypeModem = Int
8
    fromEnum DeviceType
DeviceTypeInfiniband = Int
9
    fromEnum DeviceType
DeviceTypeBond = Int
10
    fromEnum DeviceType
DeviceTypeVlan = Int
11
    fromEnum DeviceType
DeviceTypeAdsl = Int
12
    fromEnum DeviceType
DeviceTypeBridge = Int
13
    fromEnum DeviceType
DeviceTypeGeneric = Int
14
    fromEnum DeviceType
DeviceTypeTeam = Int
15
    fromEnum DeviceType
DeviceTypeTun = Int
16
    fromEnum DeviceType
DeviceTypeIpTunnel = Int
17
    fromEnum DeviceType
DeviceTypeMacvlan = Int
18
    fromEnum DeviceType
DeviceTypeVxlan = Int
19
    fromEnum DeviceType
DeviceTypeVeth = Int
20
    fromEnum DeviceType
DeviceTypeMacsec = Int
21
    fromEnum DeviceType
DeviceTypeDummy = Int
22
    fromEnum DeviceType
DeviceTypePpp = Int
23
    fromEnum DeviceType
DeviceTypeOvsInterface = Int
24
    fromEnum DeviceType
DeviceTypeOvsPort = Int
25
    fromEnum DeviceType
DeviceTypeOvsBridge = Int
26
    fromEnum DeviceType
DeviceTypeWpan = Int
27
    fromEnum DeviceType
DeviceType6lowpan = Int
28
    fromEnum DeviceType
DeviceTypeWireguard = Int
29
    fromEnum DeviceType
DeviceTypeWifiP2p = Int
30
    fromEnum DeviceType
DeviceTypeVrf = Int
31
    fromEnum DeviceType
DeviceTypeLoopback = Int
32
    fromEnum DeviceType
DeviceTypeHsr = Int
33
    fromEnum (AnotherDeviceType Int
k) = Int
k

    toEnum :: Int -> DeviceType
toEnum Int
0 = DeviceType
DeviceTypeUnknown
    toEnum Int
1 = DeviceType
DeviceTypeEthernet
    toEnum Int
2 = DeviceType
DeviceTypeWifi
    toEnum Int
3 = DeviceType
DeviceTypeUnused1
    toEnum Int
4 = DeviceType
DeviceTypeUnused2
    toEnum Int
5 = DeviceType
DeviceTypeBt
    toEnum Int
6 = DeviceType
DeviceTypeOlpcMesh
    toEnum Int
7 = DeviceType
DeviceTypeWimax
    toEnum Int
8 = DeviceType
DeviceTypeModem
    toEnum Int
9 = DeviceType
DeviceTypeInfiniband
    toEnum Int
10 = DeviceType
DeviceTypeBond
    toEnum Int
11 = DeviceType
DeviceTypeVlan
    toEnum Int
12 = DeviceType
DeviceTypeAdsl
    toEnum Int
13 = DeviceType
DeviceTypeBridge
    toEnum Int
14 = DeviceType
DeviceTypeGeneric
    toEnum Int
15 = DeviceType
DeviceTypeTeam
    toEnum Int
16 = DeviceType
DeviceTypeTun
    toEnum Int
17 = DeviceType
DeviceTypeIpTunnel
    toEnum Int
18 = DeviceType
DeviceTypeMacvlan
    toEnum Int
19 = DeviceType
DeviceTypeVxlan
    toEnum Int
20 = DeviceType
DeviceTypeVeth
    toEnum Int
21 = DeviceType
DeviceTypeMacsec
    toEnum Int
22 = DeviceType
DeviceTypeDummy
    toEnum Int
23 = DeviceType
DeviceTypePpp
    toEnum Int
24 = DeviceType
DeviceTypeOvsInterface
    toEnum Int
25 = DeviceType
DeviceTypeOvsPort
    toEnum Int
26 = DeviceType
DeviceTypeOvsBridge
    toEnum Int
27 = DeviceType
DeviceTypeWpan
    toEnum Int
28 = DeviceType
DeviceType6lowpan
    toEnum Int
29 = DeviceType
DeviceTypeWireguard
    toEnum Int
30 = DeviceType
DeviceTypeWifiP2p
    toEnum Int
31 = DeviceType
DeviceTypeVrf
    toEnum Int
32 = DeviceType
DeviceTypeLoopback
    toEnum Int
33 = DeviceType
DeviceTypeHsr
    toEnum Int
k = Int -> DeviceType
AnotherDeviceType Int
k

instance P.Ord DeviceType where
    compare :: DeviceType -> DeviceType -> Ordering
compare DeviceType
a DeviceType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DeviceType -> Int
forall a. Enum a => a -> Int
P.fromEnum DeviceType
a) (DeviceType -> Int
forall a. Enum a => a -> Int
P.fromEnum DeviceType
b)

type instance O.ParentTypes DeviceType = '[]
instance O.HasParentTypes DeviceType

foreign import ccall "nm_device_type_get_type" c_nm_device_type_get_type :: 
    IO GType

instance B.Types.TypedObject DeviceType where
    glibType :: IO GType
glibType = IO GType
c_nm_device_type_get_type

instance B.Types.BoxedEnum DeviceType

-- Enum DeviceStateReason
-- | Device state change reason codes
data DeviceStateReason = 
      DeviceStateReasonNone
    -- ^ No reason given
    | DeviceStateReasonUnknown
    -- ^ Unknown error
    | DeviceStateReasonNowManaged
    -- ^ Device is now managed
    | DeviceStateReasonNowUnmanaged
    -- ^ Device is now unmanaged
    | DeviceStateReasonConfigFailed
    -- ^ The device could not be readied for configuration
    | DeviceStateReasonIpConfigUnavailable
    -- ^ IP configuration could not be reserved (no available address, timeout, etc)
    | DeviceStateReasonIpConfigExpired
    -- ^ The IP config is no longer valid
    | DeviceStateReasonNoSecrets
    -- ^ Secrets were required, but not provided
    | DeviceStateReasonSupplicantDisconnect
    -- ^ 802.1x supplicant disconnected
    | DeviceStateReasonSupplicantConfigFailed
    -- ^ 802.1x supplicant configuration failed
    | DeviceStateReasonSupplicantFailed
    -- ^ 802.1x supplicant failed
    | DeviceStateReasonSupplicantTimeout
    -- ^ 802.1x supplicant took too long to authenticate
    | DeviceStateReasonPppStartFailed
    -- ^ PPP service failed to start
    | DeviceStateReasonPppDisconnect
    -- ^ PPP service disconnected
    | DeviceStateReasonPppFailed
    -- ^ PPP failed
    | DeviceStateReasonDhcpStartFailed
    -- ^ DHCP client failed to start
    | DeviceStateReasonDhcpError
    -- ^ DHCP client error
    | DeviceStateReasonDhcpFailed
    -- ^ DHCP client failed
    | DeviceStateReasonSharedStartFailed
    -- ^ Shared connection service failed to start
    | DeviceStateReasonSharedFailed
    -- ^ Shared connection service failed
    | DeviceStateReasonAutoipStartFailed
    -- ^ AutoIP service failed to start
    | DeviceStateReasonAutoipError
    -- ^ AutoIP service error
    | DeviceStateReasonAutoipFailed
    -- ^ AutoIP service failed
    | DeviceStateReasonModemBusy
    -- ^ The line is busy
    | DeviceStateReasonModemNoDialTone
    -- ^ No dial tone
    | DeviceStateReasonModemNoCarrier
    -- ^ No carrier could be established
    | DeviceStateReasonModemDialTimeout
    -- ^ The dialing request timed out
    | DeviceStateReasonModemDialFailed
    -- ^ The dialing attempt failed
    | DeviceStateReasonModemInitFailed
    -- ^ Modem initialization failed
    | DeviceStateReasonGsmApnFailed
    -- ^ Failed to select the specified APN
    | DeviceStateReasonGsmRegistrationNotSearching
    -- ^ Not searching for networks
    | DeviceStateReasonGsmRegistrationDenied
    -- ^ Network registration denied
    | DeviceStateReasonGsmRegistrationTimeout
    -- ^ Network registration timed out
    | DeviceStateReasonGsmRegistrationFailed
    -- ^ Failed to register with the requested network
    | DeviceStateReasonGsmPinCheckFailed
    -- ^ PIN check failed
    | DeviceStateReasonFirmwareMissing
    -- ^ Necessary firmware for the device may be missing
    | DeviceStateReasonRemoved
    -- ^ The device was removed
    | DeviceStateReasonSleeping
    -- ^ NetworkManager went to sleep
    | DeviceStateReasonConnectionRemoved
    -- ^ The device\'s active connection disappeared
    | DeviceStateReasonUserRequested
    -- ^ Device disconnected by user or client
    | DeviceStateReasonCarrier
    -- ^ Carrier\/link changed
    | DeviceStateReasonConnectionAssumed
    -- ^ The device\'s existing connection was assumed
    | DeviceStateReasonSupplicantAvailable
    -- ^ The supplicant is now available
    | DeviceStateReasonModemNotFound
    -- ^ The modem could not be found
    | DeviceStateReasonBtFailed
    -- ^ The Bluetooth connection failed or timed out
    | DeviceStateReasonGsmSimNotInserted
    -- ^ GSM Modem\'s SIM Card not inserted
    | DeviceStateReasonGsmSimPinRequired
    -- ^ GSM Modem\'s SIM Pin required
    | DeviceStateReasonGsmSimPukRequired
    -- ^ GSM Modem\'s SIM Puk required
    | DeviceStateReasonGsmSimWrong
    -- ^ GSM Modem\'s SIM wrong
    | DeviceStateReasonInfinibandMode
    -- ^ InfiniBand device does not support connected mode
    | DeviceStateReasonDependencyFailed
    -- ^ A dependency of the connection failed
    | DeviceStateReasonBr2684Failed
    -- ^ Problem with the RFC 2684 Ethernet over ADSL bridge
    | DeviceStateReasonModemManagerUnavailable
    -- ^ ModemManager not running
    | DeviceStateReasonSsidNotFound
    -- ^ The Wi-Fi network could not be found
    | DeviceStateReasonSecondaryConnectionFailed
    -- ^ A secondary connection of the base connection failed
    | DeviceStateReasonDcbFcoeFailed
    -- ^ DCB or FCoE setup failed
    | DeviceStateReasonTeamdControlFailed
    -- ^ teamd control failed
    | DeviceStateReasonModemFailed
    -- ^ Modem failed or no longer available
    | DeviceStateReasonModemAvailable
    -- ^ Modem now ready and available
    | DeviceStateReasonSimPinIncorrect
    -- ^ SIM PIN was incorrect
    | DeviceStateReasonNewActivation
    -- ^ New connection activation was enqueued
    | DeviceStateReasonParentChanged
    -- ^ the device\'s parent changed
    | DeviceStateReasonParentManagedChanged
    -- ^ the device parent\'s management changed
    | DeviceStateReasonOvsdbFailed
    -- ^ problem communicating with Open vSwitch database
    | DeviceStateReasonIpAddressDuplicate
    -- ^ a duplicate IP address was detected
    | DeviceStateReasonIpMethodUnsupported
    -- ^ The selected IP method is not supported
    | DeviceStateReasonSriovConfigurationFailed
    -- ^ configuration of SR-IOV parameters failed
    | DeviceStateReasonPeerNotFound
    -- ^ The Wi-Fi P2P peer could not be found
    | DeviceStateReasonDeviceHandlerFailed
    -- ^ The device handler dispatcher returned an
    --   error. Since: 1.46
    | DeviceStateReasonUnmanagedByDefault
    -- ^ The device is unmanaged because the device type
    --   is unmanaged by default. Since: 1.48
    | DeviceStateReasonUnmanagedExternalDown
    -- ^ The device is unmanaged because it is an
    --   external device and is unconfigured (down or without addresses). Since: 1.48
    | DeviceStateReasonUnmanagedLinkNotInit
    -- ^ The device is unmanaged because the link is
    --   not initialized by udev. Since: 1.48
    | DeviceStateReasonUnmanagedQuitting
    -- ^ The device is unmanaged because NetworkManager is
    --   quitting. Since: 1.48
    | DeviceStateReasonUnmanagedSleeping
    -- ^ The device is unmanaged because networking is
    --   disabled or the system is suspended. Since: 1.48
    | DeviceStateReasonUnmanagedUserConf
    -- ^ The device is unmanaged by user decision in
    --   NetworkManager.conf (\'unmanaged\' in a [device*] section). Since: 1.48
    | DeviceStateReasonUnmanagedUserExplicit
    -- ^ The device is unmanaged by explicit user
    --   decision (e.g. \'nmcli device set $DEV managed no\'). Since: 1.48
    | DeviceStateReasonUnmanagedUserSettings
    -- ^ The device is unmanaged by user decision
    --   via settings plugin (\'unmanaged-devices\' for keyfile or \'NM_CONTROLLED=no\' for ifcfg-rh).
    --   Since: 1.48
    | DeviceStateReasonUnmanagedUserUdev
    -- ^ The device is unmanaged via udev rule. Since: 1.48
    | AnotherDeviceStateReason Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DeviceStateReason -> ShowS
[DeviceStateReason] -> ShowS
DeviceStateReason -> String
(Int -> DeviceStateReason -> ShowS)
-> (DeviceStateReason -> String)
-> ([DeviceStateReason] -> ShowS)
-> Show DeviceStateReason
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DeviceStateReason -> ShowS
showsPrec :: Int -> DeviceStateReason -> ShowS
$cshow :: DeviceStateReason -> String
show :: DeviceStateReason -> String
$cshowList :: [DeviceStateReason] -> ShowS
showList :: [DeviceStateReason] -> ShowS
Show, DeviceStateReason -> DeviceStateReason -> Bool
(DeviceStateReason -> DeviceStateReason -> Bool)
-> (DeviceStateReason -> DeviceStateReason -> Bool)
-> Eq DeviceStateReason
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeviceStateReason -> DeviceStateReason -> Bool
== :: DeviceStateReason -> DeviceStateReason -> Bool
$c/= :: DeviceStateReason -> DeviceStateReason -> Bool
/= :: DeviceStateReason -> DeviceStateReason -> Bool
Eq)

instance P.Enum DeviceStateReason where
    fromEnum :: DeviceStateReason -> Int
fromEnum DeviceStateReason
DeviceStateReasonNone = Int
0
    fromEnum DeviceStateReason
DeviceStateReasonUnknown = Int
1
    fromEnum DeviceStateReason
DeviceStateReasonNowManaged = Int
2
    fromEnum DeviceStateReason
DeviceStateReasonNowUnmanaged = Int
3
    fromEnum DeviceStateReason
DeviceStateReasonConfigFailed = Int
4
    fromEnum DeviceStateReason
DeviceStateReasonIpConfigUnavailable = Int
5
    fromEnum DeviceStateReason
DeviceStateReasonIpConfigExpired = Int
6
    fromEnum DeviceStateReason
DeviceStateReasonNoSecrets = Int
7
    fromEnum DeviceStateReason
DeviceStateReasonSupplicantDisconnect = Int
8
    fromEnum DeviceStateReason
DeviceStateReasonSupplicantConfigFailed = Int
9
    fromEnum DeviceStateReason
DeviceStateReasonSupplicantFailed = Int
10
    fromEnum DeviceStateReason
DeviceStateReasonSupplicantTimeout = Int
11
    fromEnum DeviceStateReason
DeviceStateReasonPppStartFailed = Int
12
    fromEnum DeviceStateReason
DeviceStateReasonPppDisconnect = Int
13
    fromEnum DeviceStateReason
DeviceStateReasonPppFailed = Int
14
    fromEnum DeviceStateReason
DeviceStateReasonDhcpStartFailed = Int
15
    fromEnum DeviceStateReason
DeviceStateReasonDhcpError = Int
16
    fromEnum DeviceStateReason
DeviceStateReasonDhcpFailed = Int
17
    fromEnum DeviceStateReason
DeviceStateReasonSharedStartFailed = Int
18
    fromEnum DeviceStateReason
DeviceStateReasonSharedFailed = Int
19
    fromEnum DeviceStateReason
DeviceStateReasonAutoipStartFailed = Int
20
    fromEnum DeviceStateReason
DeviceStateReasonAutoipError = Int
21
    fromEnum DeviceStateReason
DeviceStateReasonAutoipFailed = Int
22
    fromEnum DeviceStateReason
DeviceStateReasonModemBusy = Int
23
    fromEnum DeviceStateReason
DeviceStateReasonModemNoDialTone = Int
24
    fromEnum DeviceStateReason
DeviceStateReasonModemNoCarrier = Int
25
    fromEnum DeviceStateReason
DeviceStateReasonModemDialTimeout = Int
26
    fromEnum DeviceStateReason
DeviceStateReasonModemDialFailed = Int
27
    fromEnum DeviceStateReason
DeviceStateReasonModemInitFailed = Int
28
    fromEnum DeviceStateReason
DeviceStateReasonGsmApnFailed = Int
29
    fromEnum DeviceStateReason
DeviceStateReasonGsmRegistrationNotSearching = Int
30
    fromEnum DeviceStateReason
DeviceStateReasonGsmRegistrationDenied = Int
31
    fromEnum DeviceStateReason
DeviceStateReasonGsmRegistrationTimeout = Int
32
    fromEnum DeviceStateReason
DeviceStateReasonGsmRegistrationFailed = Int
33
    fromEnum DeviceStateReason
DeviceStateReasonGsmPinCheckFailed = Int
34
    fromEnum DeviceStateReason
DeviceStateReasonFirmwareMissing = Int
35
    fromEnum DeviceStateReason
DeviceStateReasonRemoved = Int
36
    fromEnum DeviceStateReason
DeviceStateReasonSleeping = Int
37
    fromEnum DeviceStateReason
DeviceStateReasonConnectionRemoved = Int
38
    fromEnum DeviceStateReason
DeviceStateReasonUserRequested = Int
39
    fromEnum DeviceStateReason
DeviceStateReasonCarrier = Int
40
    fromEnum DeviceStateReason
DeviceStateReasonConnectionAssumed = Int
41
    fromEnum DeviceStateReason
DeviceStateReasonSupplicantAvailable = Int
42
    fromEnum DeviceStateReason
DeviceStateReasonModemNotFound = Int
43
    fromEnum DeviceStateReason
DeviceStateReasonBtFailed = Int
44
    fromEnum DeviceStateReason
DeviceStateReasonGsmSimNotInserted = Int
45
    fromEnum DeviceStateReason
DeviceStateReasonGsmSimPinRequired = Int
46
    fromEnum DeviceStateReason
DeviceStateReasonGsmSimPukRequired = Int
47
    fromEnum DeviceStateReason
DeviceStateReasonGsmSimWrong = Int
48
    fromEnum DeviceStateReason
DeviceStateReasonInfinibandMode = Int
49
    fromEnum DeviceStateReason
DeviceStateReasonDependencyFailed = Int
50
    fromEnum DeviceStateReason
DeviceStateReasonBr2684Failed = Int
51
    fromEnum DeviceStateReason
DeviceStateReasonModemManagerUnavailable = Int
52
    fromEnum DeviceStateReason
DeviceStateReasonSsidNotFound = Int
53
    fromEnum DeviceStateReason
DeviceStateReasonSecondaryConnectionFailed = Int
54
    fromEnum DeviceStateReason
DeviceStateReasonDcbFcoeFailed = Int
55
    fromEnum DeviceStateReason
DeviceStateReasonTeamdControlFailed = Int
56
    fromEnum DeviceStateReason
DeviceStateReasonModemFailed = Int
57
    fromEnum DeviceStateReason
DeviceStateReasonModemAvailable = Int
58
    fromEnum DeviceStateReason
DeviceStateReasonSimPinIncorrect = Int
59
    fromEnum DeviceStateReason
DeviceStateReasonNewActivation = Int
60
    fromEnum DeviceStateReason
DeviceStateReasonParentChanged = Int
61
    fromEnum DeviceStateReason
DeviceStateReasonParentManagedChanged = Int
62
    fromEnum DeviceStateReason
DeviceStateReasonOvsdbFailed = Int
63
    fromEnum DeviceStateReason
DeviceStateReasonIpAddressDuplicate = Int
64
    fromEnum DeviceStateReason
DeviceStateReasonIpMethodUnsupported = Int
65
    fromEnum DeviceStateReason
DeviceStateReasonSriovConfigurationFailed = Int
66
    fromEnum DeviceStateReason
DeviceStateReasonPeerNotFound = Int
67
    fromEnum DeviceStateReason
DeviceStateReasonDeviceHandlerFailed = Int
68
    fromEnum DeviceStateReason
DeviceStateReasonUnmanagedByDefault = Int
69
    fromEnum DeviceStateReason
DeviceStateReasonUnmanagedExternalDown = Int
70
    fromEnum DeviceStateReason
DeviceStateReasonUnmanagedLinkNotInit = Int
71
    fromEnum DeviceStateReason
DeviceStateReasonUnmanagedQuitting = Int
72
    fromEnum DeviceStateReason
DeviceStateReasonUnmanagedSleeping = Int
73
    fromEnum DeviceStateReason
DeviceStateReasonUnmanagedUserConf = Int
74
    fromEnum DeviceStateReason
DeviceStateReasonUnmanagedUserExplicit = Int
75
    fromEnum DeviceStateReason
DeviceStateReasonUnmanagedUserSettings = Int
76
    fromEnum DeviceStateReason
DeviceStateReasonUnmanagedUserUdev = Int
77
    fromEnum (AnotherDeviceStateReason Int
k) = Int
k

    toEnum :: Int -> DeviceStateReason
toEnum Int
0 = DeviceStateReason
DeviceStateReasonNone
    toEnum Int
1 = DeviceStateReason
DeviceStateReasonUnknown
    toEnum Int
2 = DeviceStateReason
DeviceStateReasonNowManaged
    toEnum Int
3 = DeviceStateReason
DeviceStateReasonNowUnmanaged
    toEnum Int
4 = DeviceStateReason
DeviceStateReasonConfigFailed
    toEnum Int
5 = DeviceStateReason
DeviceStateReasonIpConfigUnavailable
    toEnum Int
6 = DeviceStateReason
DeviceStateReasonIpConfigExpired
    toEnum Int
7 = DeviceStateReason
DeviceStateReasonNoSecrets
    toEnum Int
8 = DeviceStateReason
DeviceStateReasonSupplicantDisconnect
    toEnum Int
9 = DeviceStateReason
DeviceStateReasonSupplicantConfigFailed
    toEnum Int
10 = DeviceStateReason
DeviceStateReasonSupplicantFailed
    toEnum Int
11 = DeviceStateReason
DeviceStateReasonSupplicantTimeout
    toEnum Int
12 = DeviceStateReason
DeviceStateReasonPppStartFailed
    toEnum Int
13 = DeviceStateReason
DeviceStateReasonPppDisconnect
    toEnum Int
14 = DeviceStateReason
DeviceStateReasonPppFailed
    toEnum Int
15 = DeviceStateReason
DeviceStateReasonDhcpStartFailed
    toEnum Int
16 = DeviceStateReason
DeviceStateReasonDhcpError
    toEnum Int
17 = DeviceStateReason
DeviceStateReasonDhcpFailed
    toEnum Int
18 = DeviceStateReason
DeviceStateReasonSharedStartFailed
    toEnum Int
19 = DeviceStateReason
DeviceStateReasonSharedFailed
    toEnum Int
20 = DeviceStateReason
DeviceStateReasonAutoipStartFailed
    toEnum Int
21 = DeviceStateReason
DeviceStateReasonAutoipError
    toEnum Int
22 = DeviceStateReason
DeviceStateReasonAutoipFailed
    toEnum Int
23 = DeviceStateReason
DeviceStateReasonModemBusy
    toEnum Int
24 = DeviceStateReason
DeviceStateReasonModemNoDialTone
    toEnum Int
25 = DeviceStateReason
DeviceStateReasonModemNoCarrier
    toEnum Int
26 = DeviceStateReason
DeviceStateReasonModemDialTimeout
    toEnum Int
27 = DeviceStateReason
DeviceStateReasonModemDialFailed
    toEnum Int
28 = DeviceStateReason
DeviceStateReasonModemInitFailed
    toEnum Int
29 = DeviceStateReason
DeviceStateReasonGsmApnFailed
    toEnum Int
30 = DeviceStateReason
DeviceStateReasonGsmRegistrationNotSearching
    toEnum Int
31 = DeviceStateReason
DeviceStateReasonGsmRegistrationDenied
    toEnum Int
32 = DeviceStateReason
DeviceStateReasonGsmRegistrationTimeout
    toEnum Int
33 = DeviceStateReason
DeviceStateReasonGsmRegistrationFailed
    toEnum Int
34 = DeviceStateReason
DeviceStateReasonGsmPinCheckFailed
    toEnum Int
35 = DeviceStateReason
DeviceStateReasonFirmwareMissing
    toEnum Int
36 = DeviceStateReason
DeviceStateReasonRemoved
    toEnum Int
37 = DeviceStateReason
DeviceStateReasonSleeping
    toEnum Int
38 = DeviceStateReason
DeviceStateReasonConnectionRemoved
    toEnum Int
39 = DeviceStateReason
DeviceStateReasonUserRequested
    toEnum Int
40 = DeviceStateReason
DeviceStateReasonCarrier
    toEnum Int
41 = DeviceStateReason
DeviceStateReasonConnectionAssumed
    toEnum Int
42 = DeviceStateReason
DeviceStateReasonSupplicantAvailable
    toEnum Int
43 = DeviceStateReason
DeviceStateReasonModemNotFound
    toEnum Int
44 = DeviceStateReason
DeviceStateReasonBtFailed
    toEnum Int
45 = DeviceStateReason
DeviceStateReasonGsmSimNotInserted
    toEnum Int
46 = DeviceStateReason
DeviceStateReasonGsmSimPinRequired
    toEnum Int
47 = DeviceStateReason
DeviceStateReasonGsmSimPukRequired
    toEnum Int
48 = DeviceStateReason
DeviceStateReasonGsmSimWrong
    toEnum Int
49 = DeviceStateReason
DeviceStateReasonInfinibandMode
    toEnum Int
50 = DeviceStateReason
DeviceStateReasonDependencyFailed
    toEnum Int
51 = DeviceStateReason
DeviceStateReasonBr2684Failed
    toEnum Int
52 = DeviceStateReason
DeviceStateReasonModemManagerUnavailable
    toEnum Int
53 = DeviceStateReason
DeviceStateReasonSsidNotFound
    toEnum Int
54 = DeviceStateReason
DeviceStateReasonSecondaryConnectionFailed
    toEnum Int
55 = DeviceStateReason
DeviceStateReasonDcbFcoeFailed
    toEnum Int
56 = DeviceStateReason
DeviceStateReasonTeamdControlFailed
    toEnum Int
57 = DeviceStateReason
DeviceStateReasonModemFailed
    toEnum Int
58 = DeviceStateReason
DeviceStateReasonModemAvailable
    toEnum Int
59 = DeviceStateReason
DeviceStateReasonSimPinIncorrect
    toEnum Int
60 = DeviceStateReason
DeviceStateReasonNewActivation
    toEnum Int
61 = DeviceStateReason
DeviceStateReasonParentChanged
    toEnum Int
62 = DeviceStateReason
DeviceStateReasonParentManagedChanged
    toEnum Int
63 = DeviceStateReason
DeviceStateReasonOvsdbFailed
    toEnum Int
64 = DeviceStateReason
DeviceStateReasonIpAddressDuplicate
    toEnum Int
65 = DeviceStateReason
DeviceStateReasonIpMethodUnsupported
    toEnum Int
66 = DeviceStateReason
DeviceStateReasonSriovConfigurationFailed
    toEnum Int
67 = DeviceStateReason
DeviceStateReasonPeerNotFound
    toEnum Int
68 = DeviceStateReason
DeviceStateReasonDeviceHandlerFailed
    toEnum Int
69 = DeviceStateReason
DeviceStateReasonUnmanagedByDefault
    toEnum Int
70 = DeviceStateReason
DeviceStateReasonUnmanagedExternalDown
    toEnum Int
71 = DeviceStateReason
DeviceStateReasonUnmanagedLinkNotInit
    toEnum Int
72 = DeviceStateReason
DeviceStateReasonUnmanagedQuitting
    toEnum Int
73 = DeviceStateReason
DeviceStateReasonUnmanagedSleeping
    toEnum Int
74 = DeviceStateReason
DeviceStateReasonUnmanagedUserConf
    toEnum Int
75 = DeviceStateReason
DeviceStateReasonUnmanagedUserExplicit
    toEnum Int
76 = DeviceStateReason
DeviceStateReasonUnmanagedUserSettings
    toEnum Int
77 = DeviceStateReason
DeviceStateReasonUnmanagedUserUdev
    toEnum Int
k = Int -> DeviceStateReason
AnotherDeviceStateReason Int
k

instance P.Ord DeviceStateReason where
    compare :: DeviceStateReason -> DeviceStateReason -> Ordering
compare DeviceStateReason
a DeviceStateReason
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DeviceStateReason -> Int
forall a. Enum a => a -> Int
P.fromEnum DeviceStateReason
a) (DeviceStateReason -> Int
forall a. Enum a => a -> Int
P.fromEnum DeviceStateReason
b)

type instance O.ParentTypes DeviceStateReason = '[]
instance O.HasParentTypes DeviceStateReason

foreign import ccall "nm_device_state_reason_get_type" c_nm_device_state_reason_get_type :: 
    IO GType

instance B.Types.TypedObject DeviceStateReason where
    glibType :: IO GType
glibType = IO GType
c_nm_device_state_reason_get_type

instance B.Types.BoxedEnum DeviceStateReason

-- Enum DeviceState
-- | /No description available in the introspection data./
data DeviceState = 
      DeviceStateUnknown
    -- ^ the device\'s state is unknown
    | DeviceStateUnmanaged
    -- ^ the device is recognized, but not managed by
    --   NetworkManager
    | DeviceStateUnavailable
    -- ^ the device is managed by NetworkManager, but
    --   is not available for use.  Reasons may include the wireless switched off,
    --   missing firmware, no ethernet carrier, missing supplicant or modem manager,
    --   etc.
    | DeviceStateDisconnected
    -- ^ the device can be activated, but is currently
    --   idle and not connected to a network.
    | DeviceStatePrepare
    -- ^ the device is preparing the connection to the
    --   network.  This may include operations like changing the MAC address,
    --   setting physical link properties, and anything else required to connect
    --   to the requested network.
    | DeviceStateConfig
    -- ^ the device is connecting to the requested network.
    --   This may include operations like associating with the Wi-Fi AP, dialing
    --   the modem, connecting to the remote Bluetooth device, etc.
    | DeviceStateNeedAuth
    -- ^ the device requires more information to continue
    --   connecting to the requested network.  This includes secrets like WiFi
    --   passphrases, login passwords, PIN codes, etc.
    | DeviceStateIpConfig
    -- ^ the device is requesting IPv4 and\/or IPv6
    --   addresses and routing information from the network.
    | DeviceStateIpCheck
    -- ^ the device is checking whether further action is
    --   required for the requested network connection.  This may include checking
    --   whether only local network access is available, whether a captive portal
    --   is blocking access to the Internet, etc.
    | DeviceStateSecondaries
    -- ^ the device is waiting for a secondary
    --   connection (like a VPN) which must activated before the device can be
    --   activated
    | DeviceStateActivated
    -- ^ the device has a network connection, either local
    --   or global.
    | DeviceStateDeactivating
    -- ^ a disconnection from the current network
    --   connection was requested, and the device is cleaning up resources used for
    --   that connection.  The network connection may still be valid.
    | DeviceStateFailed
    -- ^ the device failed to connect to the requested
    --   network and is cleaning up the connection request
    | AnotherDeviceState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DeviceState -> ShowS
[DeviceState] -> ShowS
DeviceState -> String
(Int -> DeviceState -> ShowS)
-> (DeviceState -> String)
-> ([DeviceState] -> ShowS)
-> Show DeviceState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DeviceState -> ShowS
showsPrec :: Int -> DeviceState -> ShowS
$cshow :: DeviceState -> String
show :: DeviceState -> String
$cshowList :: [DeviceState] -> ShowS
showList :: [DeviceState] -> ShowS
Show, DeviceState -> DeviceState -> Bool
(DeviceState -> DeviceState -> Bool)
-> (DeviceState -> DeviceState -> Bool) -> Eq DeviceState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeviceState -> DeviceState -> Bool
== :: DeviceState -> DeviceState -> Bool
$c/= :: DeviceState -> DeviceState -> Bool
/= :: DeviceState -> DeviceState -> Bool
Eq)

instance P.Enum DeviceState where
    fromEnum :: DeviceState -> Int
fromEnum DeviceState
DeviceStateUnknown = Int
0
    fromEnum DeviceState
DeviceStateUnmanaged = Int
10
    fromEnum DeviceState
DeviceStateUnavailable = Int
20
    fromEnum DeviceState
DeviceStateDisconnected = Int
30
    fromEnum DeviceState
DeviceStatePrepare = Int
40
    fromEnum DeviceState
DeviceStateConfig = Int
50
    fromEnum DeviceState
DeviceStateNeedAuth = Int
60
    fromEnum DeviceState
DeviceStateIpConfig = Int
70
    fromEnum DeviceState
DeviceStateIpCheck = Int
80
    fromEnum DeviceState
DeviceStateSecondaries = Int
90
    fromEnum DeviceState
DeviceStateActivated = Int
100
    fromEnum DeviceState
DeviceStateDeactivating = Int
110
    fromEnum DeviceState
DeviceStateFailed = Int
120
    fromEnum (AnotherDeviceState Int
k) = Int
k

    toEnum :: Int -> DeviceState
toEnum Int
0 = DeviceState
DeviceStateUnknown
    toEnum Int
10 = DeviceState
DeviceStateUnmanaged
    toEnum Int
20 = DeviceState
DeviceStateUnavailable
    toEnum Int
30 = DeviceState
DeviceStateDisconnected
    toEnum Int
40 = DeviceState
DeviceStatePrepare
    toEnum Int
50 = DeviceState
DeviceStateConfig
    toEnum Int
60 = DeviceState
DeviceStateNeedAuth
    toEnum Int
70 = DeviceState
DeviceStateIpConfig
    toEnum Int
80 = DeviceState
DeviceStateIpCheck
    toEnum Int
90 = DeviceState
DeviceStateSecondaries
    toEnum Int
100 = DeviceState
DeviceStateActivated
    toEnum Int
110 = DeviceState
DeviceStateDeactivating
    toEnum Int
120 = DeviceState
DeviceStateFailed
    toEnum Int
k = Int -> DeviceState
AnotherDeviceState Int
k

instance P.Ord DeviceState where
    compare :: DeviceState -> DeviceState -> Ordering
compare DeviceState
a DeviceState
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DeviceState -> Int
forall a. Enum a => a -> Int
P.fromEnum DeviceState
a) (DeviceState -> Int
forall a. Enum a => a -> Int
P.fromEnum DeviceState
b)

type instance O.ParentTypes DeviceState = '[]
instance O.HasParentTypes DeviceState

foreign import ccall "nm_device_state_get_type" c_nm_device_state_get_type :: 
    IO GType

instance B.Types.TypedObject DeviceState where
    glibType :: IO GType
glibType = IO GType
c_nm_device_state_get_type

instance B.Types.BoxedEnum DeviceState

-- Enum DeviceError
-- | Device-related errors.
-- 
-- These errors may be returned directly from t'GI.NM.Objects.Device.Device' methods, or may be
-- returned from D-Bus operations (where they correspond to errors in the
-- \"org.freedesktop.NetworkManager.Device\" namespace).
data DeviceError = 
      DeviceErrorFailed
    -- ^ unknown or unclassified error
    | DeviceErrorCreationFailed
    -- ^ NetworkManager failed to create the device
    | DeviceErrorInvalidConnection
    -- ^ the specified connection is not valid
    | DeviceErrorIncompatibleConnection
    -- ^ the specified connection is not
    --   compatible with this device.
    | DeviceErrorNotActive
    -- ^ the device does not have an active connection
    | DeviceErrorNotSoftware
    -- ^ the requested operation is only valid on
    --   software devices.
    | DeviceErrorNotAllowed
    -- ^ the requested operation is not allowed at
    --   this time.
    | DeviceErrorSpecificObjectNotFound
    -- ^ the \"specific object\" in the
    --   activation request (eg, the t'GI.NM.Objects.AccessPoint.AccessPoint' or t'GI.NM.Objects.WimaxNsp.WimaxNsp') was not
    --   found.
    | DeviceErrorVersionIdMismatch
    -- ^ the version id did not match.
    | DeviceErrorMissingDependencies
    -- ^ the requested operation could not
    --   be completed due to missing dependencies.
    | DeviceErrorInvalidArgument
    -- ^ invalid argument. Since: 1.16.
    | AnotherDeviceError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DeviceError -> ShowS
[DeviceError] -> ShowS
DeviceError -> String
(Int -> DeviceError -> ShowS)
-> (DeviceError -> String)
-> ([DeviceError] -> ShowS)
-> Show DeviceError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DeviceError -> ShowS
showsPrec :: Int -> DeviceError -> ShowS
$cshow :: DeviceError -> String
show :: DeviceError -> String
$cshowList :: [DeviceError] -> ShowS
showList :: [DeviceError] -> ShowS
Show, DeviceError -> DeviceError -> Bool
(DeviceError -> DeviceError -> Bool)
-> (DeviceError -> DeviceError -> Bool) -> Eq DeviceError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeviceError -> DeviceError -> Bool
== :: DeviceError -> DeviceError -> Bool
$c/= :: DeviceError -> DeviceError -> Bool
/= :: DeviceError -> DeviceError -> Bool
Eq)

instance P.Enum DeviceError where
    fromEnum :: DeviceError -> Int
fromEnum DeviceError
DeviceErrorFailed = Int
0
    fromEnum DeviceError
DeviceErrorCreationFailed = Int
1
    fromEnum DeviceError
DeviceErrorInvalidConnection = Int
2
    fromEnum DeviceError
DeviceErrorIncompatibleConnection = Int
3
    fromEnum DeviceError
DeviceErrorNotActive = Int
4
    fromEnum DeviceError
DeviceErrorNotSoftware = Int
5
    fromEnum DeviceError
DeviceErrorNotAllowed = Int
6
    fromEnum DeviceError
DeviceErrorSpecificObjectNotFound = Int
7
    fromEnum DeviceError
DeviceErrorVersionIdMismatch = Int
8
    fromEnum DeviceError
DeviceErrorMissingDependencies = Int
9
    fromEnum DeviceError
DeviceErrorInvalidArgument = Int
10
    fromEnum (AnotherDeviceError Int
k) = Int
k

    toEnum :: Int -> DeviceError
toEnum Int
0 = DeviceError
DeviceErrorFailed
    toEnum Int
1 = DeviceError
DeviceErrorCreationFailed
    toEnum Int
2 = DeviceError
DeviceErrorInvalidConnection
    toEnum Int
3 = DeviceError
DeviceErrorIncompatibleConnection
    toEnum Int
4 = DeviceError
DeviceErrorNotActive
    toEnum Int
5 = DeviceError
DeviceErrorNotSoftware
    toEnum Int
6 = DeviceError
DeviceErrorNotAllowed
    toEnum Int
7 = DeviceError
DeviceErrorSpecificObjectNotFound
    toEnum Int
8 = DeviceError
DeviceErrorVersionIdMismatch
    toEnum Int
9 = DeviceError
DeviceErrorMissingDependencies
    toEnum Int
10 = DeviceError
DeviceErrorInvalidArgument
    toEnum Int
k = Int -> DeviceError
AnotherDeviceError Int
k

instance P.Ord DeviceError where
    compare :: DeviceError -> DeviceError -> Ordering
compare DeviceError
a DeviceError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DeviceError -> Int
forall a. Enum a => a -> Int
P.fromEnum DeviceError
a) (DeviceError -> Int
forall a. Enum a => a -> Int
P.fromEnum DeviceError
b)

instance GErrorClass DeviceError where
    gerrorClassDomain :: DeviceError -> Text
gerrorClassDomain DeviceError
_ = Text
"nm-device-error-quark"

-- | Catch exceptions of type `DeviceError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchDeviceError ::
    IO a ->
    (DeviceError -> GErrorMessage -> IO a) ->
    IO a
catchDeviceError :: forall a. IO a -> (DeviceError -> Text -> IO a) -> IO a
catchDeviceError = IO a -> (DeviceError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `DeviceError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleDeviceError ::
    (DeviceError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleDeviceError :: forall a. (DeviceError -> Text -> IO a) -> IO a -> IO a
handleDeviceError = (DeviceError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes DeviceError = '[]
instance O.HasParentTypes DeviceError

foreign import ccall "nm_device_error_get_type" c_nm_device_error_get_type :: 
    IO GType

instance B.Types.TypedObject DeviceError where
    glibType :: IO GType
glibType = IO GType
c_nm_device_error_get_type

instance B.Types.BoxedEnum DeviceError

-- Enum CryptoError
-- | Cryptography-related errors that can be returned from some nm-utils methods,
-- and some t'GI.NM.Objects.Setting8021x.Setting8021x' operations.
data CryptoError = 
      CryptoErrorFailed
    -- ^ generic failure
    | CryptoErrorInvalidData
    -- ^ the certificate or key data provided
    --   was invalid
    | CryptoErrorInvalidPassword
    -- ^ the password was invalid
    | CryptoErrorUnknownCipher
    -- ^ the data uses an unknown cipher
    | CryptoErrorDecryptionFailed
    -- ^ decryption failed
    | CryptoErrorEncryptionFailed
    -- ^ encryption failed
    | AnotherCryptoError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CryptoError -> ShowS
[CryptoError] -> ShowS
CryptoError -> String
(Int -> CryptoError -> ShowS)
-> (CryptoError -> String)
-> ([CryptoError] -> ShowS)
-> Show CryptoError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CryptoError -> ShowS
showsPrec :: Int -> CryptoError -> ShowS
$cshow :: CryptoError -> String
show :: CryptoError -> String
$cshowList :: [CryptoError] -> ShowS
showList :: [CryptoError] -> ShowS
Show, CryptoError -> CryptoError -> Bool
(CryptoError -> CryptoError -> Bool)
-> (CryptoError -> CryptoError -> Bool) -> Eq CryptoError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CryptoError -> CryptoError -> Bool
== :: CryptoError -> CryptoError -> Bool
$c/= :: CryptoError -> CryptoError -> Bool
/= :: CryptoError -> CryptoError -> Bool
Eq)

instance P.Enum CryptoError where
    fromEnum :: CryptoError -> Int
fromEnum CryptoError
CryptoErrorFailed = Int
0
    fromEnum CryptoError
CryptoErrorInvalidData = Int
1
    fromEnum CryptoError
CryptoErrorInvalidPassword = Int
2
    fromEnum CryptoError
CryptoErrorUnknownCipher = Int
3
    fromEnum CryptoError
CryptoErrorDecryptionFailed = Int
4
    fromEnum CryptoError
CryptoErrorEncryptionFailed = Int
5
    fromEnum (AnotherCryptoError Int
k) = Int
k

    toEnum :: Int -> CryptoError
toEnum Int
0 = CryptoError
CryptoErrorFailed
    toEnum Int
1 = CryptoError
CryptoErrorInvalidData
    toEnum Int
2 = CryptoError
CryptoErrorInvalidPassword
    toEnum Int
3 = CryptoError
CryptoErrorUnknownCipher
    toEnum Int
4 = CryptoError
CryptoErrorDecryptionFailed
    toEnum Int
5 = CryptoError
CryptoErrorEncryptionFailed
    toEnum Int
k = Int -> CryptoError
AnotherCryptoError Int
k

instance P.Ord CryptoError where
    compare :: CryptoError -> CryptoError -> Ordering
compare CryptoError
a CryptoError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CryptoError -> Int
forall a. Enum a => a -> Int
P.fromEnum CryptoError
a) (CryptoError -> Int
forall a. Enum a => a -> Int
P.fromEnum CryptoError
b)

instance GErrorClass CryptoError where
    gerrorClassDomain :: CryptoError -> Text
gerrorClassDomain CryptoError
_ = Text
"nm-crypto-error-quark"

-- | Catch exceptions of type `CryptoError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchCryptoError ::
    IO a ->
    (CryptoError -> GErrorMessage -> IO a) ->
    IO a
catchCryptoError :: forall a. IO a -> (CryptoError -> Text -> IO a) -> IO a
catchCryptoError = IO a -> (CryptoError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `CryptoError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleCryptoError ::
    (CryptoError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleCryptoError :: forall a. (CryptoError -> Text -> IO a) -> IO a -> IO a
handleCryptoError = (CryptoError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes CryptoError = '[]
instance O.HasParentTypes CryptoError

foreign import ccall "nm_crypto_error_get_type" c_nm_crypto_error_get_type :: 
    IO GType

instance B.Types.TypedObject CryptoError where
    glibType :: IO GType
glibType = IO GType
c_nm_crypto_error_get_type

instance B.Types.BoxedEnum CryptoError

-- Enum ConnectivityState
-- | /No description available in the introspection data./
data ConnectivityState = 
      ConnectivityStateUnknown
    -- ^ Network connectivity is unknown. This means the
    --   connectivity checks are disabled (e.g. on server installations) or has
    --   not run yet. The graphical shell should assume the Internet connection
    --   might be available and not present a captive portal window.
    | ConnectivityStateNone
    -- ^ The host is not connected to any network. There\'s
    --   no active connection that contains a default route to the internet and
    --   thus it makes no sense to even attempt a connectivity check. The graphical
    --   shell should use this state to indicate the network connection is unavailable.
    | ConnectivityStatePortal
    -- ^ The Internet connection is hijacked by a captive
    --   portal gateway. The graphical shell may open a sandboxed web browser window
    --   (because the captive portals typically attempt a man-in-the-middle attacks
    --   against the https connections) for the purpose of authenticating to a gateway
    --   and retrigger the connectivity check with @/CheckConnectivity()/@ when the
    --   browser window is dismissed.
    | ConnectivityStateLimited
    -- ^ The host is connected to a network, does not appear
    --   to be able to reach the full Internet, but a captive portal has not been
    --   detected.
    | ConnectivityStateFull
    -- ^ The host is connected to a network, and
    --   appears to be able to reach the full Internet.
    | AnotherConnectivityState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ConnectivityState -> ShowS
[ConnectivityState] -> ShowS
ConnectivityState -> String
(Int -> ConnectivityState -> ShowS)
-> (ConnectivityState -> String)
-> ([ConnectivityState] -> ShowS)
-> Show ConnectivityState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ConnectivityState -> ShowS
showsPrec :: Int -> ConnectivityState -> ShowS
$cshow :: ConnectivityState -> String
show :: ConnectivityState -> String
$cshowList :: [ConnectivityState] -> ShowS
showList :: [ConnectivityState] -> ShowS
Show, ConnectivityState -> ConnectivityState -> Bool
(ConnectivityState -> ConnectivityState -> Bool)
-> (ConnectivityState -> ConnectivityState -> Bool)
-> Eq ConnectivityState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConnectivityState -> ConnectivityState -> Bool
== :: ConnectivityState -> ConnectivityState -> Bool
$c/= :: ConnectivityState -> ConnectivityState -> Bool
/= :: ConnectivityState -> ConnectivityState -> Bool
Eq)

instance P.Enum ConnectivityState where
    fromEnum :: ConnectivityState -> Int
fromEnum ConnectivityState
ConnectivityStateUnknown = Int
0
    fromEnum ConnectivityState
ConnectivityStateNone = Int
1
    fromEnum ConnectivityState
ConnectivityStatePortal = Int
2
    fromEnum ConnectivityState
ConnectivityStateLimited = Int
3
    fromEnum ConnectivityState
ConnectivityStateFull = Int
4
    fromEnum (AnotherConnectivityState Int
k) = Int
k

    toEnum :: Int -> ConnectivityState
toEnum Int
0 = ConnectivityState
ConnectivityStateUnknown
    toEnum Int
1 = ConnectivityState
ConnectivityStateNone
    toEnum Int
2 = ConnectivityState
ConnectivityStatePortal
    toEnum Int
3 = ConnectivityState
ConnectivityStateLimited
    toEnum Int
4 = ConnectivityState
ConnectivityStateFull
    toEnum Int
k = Int -> ConnectivityState
AnotherConnectivityState Int
k

instance P.Ord ConnectivityState where
    compare :: ConnectivityState -> ConnectivityState -> Ordering
compare ConnectivityState
a ConnectivityState
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ConnectivityState -> Int
forall a. Enum a => a -> Int
P.fromEnum ConnectivityState
a) (ConnectivityState -> Int
forall a. Enum a => a -> Int
P.fromEnum ConnectivityState
b)

type instance O.ParentTypes ConnectivityState = '[]
instance O.HasParentTypes ConnectivityState

foreign import ccall "nm_connectivity_state_get_type" c_nm_connectivity_state_get_type :: 
    IO GType

instance B.Types.TypedObject ConnectivityState where
    glibType :: IO GType
glibType = IO GType
c_nm_connectivity_state_get_type

instance B.Types.BoxedEnum ConnectivityState

-- Enum ConnectionMultiConnect
-- | /No description available in the introspection data./
-- 
-- /Since: 1.14/
data ConnectionMultiConnect = 
      ConnectionMultiConnectDefault
    -- ^ indicates that the per-connection
    --   setting is unspecified. In this case, it will fallback to the default
    --   value, which is 'GI.NM.Enums.ConnectionMultiConnectSingle'.
    | ConnectionMultiConnectSingle
    -- ^ the connection profile can only
    --   be active once at each moment. Activating a profile that is already active,
    --   will first deactivate it.
    | ConnectionMultiConnectManualMultiple
    -- ^ the profile can
    --   be manually activated multiple times on different devices. However,
    --   regarding autoconnect, the profile will autoconnect only if it is
    --   currently not connected otherwise.
    | ConnectionMultiConnectMultiple
    -- ^ the profile can autoactivate
    --   and be manually activated multiple times together.
    | AnotherConnectionMultiConnect Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ConnectionMultiConnect -> ShowS
[ConnectionMultiConnect] -> ShowS
ConnectionMultiConnect -> String
(Int -> ConnectionMultiConnect -> ShowS)
-> (ConnectionMultiConnect -> String)
-> ([ConnectionMultiConnect] -> ShowS)
-> Show ConnectionMultiConnect
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ConnectionMultiConnect -> ShowS
showsPrec :: Int -> ConnectionMultiConnect -> ShowS
$cshow :: ConnectionMultiConnect -> String
show :: ConnectionMultiConnect -> String
$cshowList :: [ConnectionMultiConnect] -> ShowS
showList :: [ConnectionMultiConnect] -> ShowS
Show, ConnectionMultiConnect -> ConnectionMultiConnect -> Bool
(ConnectionMultiConnect -> ConnectionMultiConnect -> Bool)
-> (ConnectionMultiConnect -> ConnectionMultiConnect -> Bool)
-> Eq ConnectionMultiConnect
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConnectionMultiConnect -> ConnectionMultiConnect -> Bool
== :: ConnectionMultiConnect -> ConnectionMultiConnect -> Bool
$c/= :: ConnectionMultiConnect -> ConnectionMultiConnect -> Bool
/= :: ConnectionMultiConnect -> ConnectionMultiConnect -> Bool
Eq)

instance P.Enum ConnectionMultiConnect where
    fromEnum :: ConnectionMultiConnect -> Int
fromEnum ConnectionMultiConnect
ConnectionMultiConnectDefault = Int
0
    fromEnum ConnectionMultiConnect
ConnectionMultiConnectSingle = Int
1
    fromEnum ConnectionMultiConnect
ConnectionMultiConnectManualMultiple = Int
2
    fromEnum ConnectionMultiConnect
ConnectionMultiConnectMultiple = Int
3
    fromEnum (AnotherConnectionMultiConnect Int
k) = Int
k

    toEnum :: Int -> ConnectionMultiConnect
toEnum Int
0 = ConnectionMultiConnect
ConnectionMultiConnectDefault
    toEnum Int
1 = ConnectionMultiConnect
ConnectionMultiConnectSingle
    toEnum Int
2 = ConnectionMultiConnect
ConnectionMultiConnectManualMultiple
    toEnum Int
3 = ConnectionMultiConnect
ConnectionMultiConnectMultiple
    toEnum Int
k = Int -> ConnectionMultiConnect
AnotherConnectionMultiConnect Int
k

instance P.Ord ConnectionMultiConnect where
    compare :: ConnectionMultiConnect -> ConnectionMultiConnect -> Ordering
compare ConnectionMultiConnect
a ConnectionMultiConnect
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ConnectionMultiConnect -> Int
forall a. Enum a => a -> Int
P.fromEnum ConnectionMultiConnect
a) (ConnectionMultiConnect -> Int
forall a. Enum a => a -> Int
P.fromEnum ConnectionMultiConnect
b)

type instance O.ParentTypes ConnectionMultiConnect = '[]
instance O.HasParentTypes ConnectionMultiConnect

foreign import ccall "nm_connection_multi_connect_get_type" c_nm_connection_multi_connect_get_type :: 
    IO GType

instance B.Types.TypedObject ConnectionMultiConnect where
    glibType :: IO GType
glibType = IO GType
c_nm_connection_multi_connect_get_type

instance B.Types.BoxedEnum ConnectionMultiConnect

-- Enum ConnectionError
-- | Describes errors that may result from operations involving a t'GI.NM.Interfaces.Connection.Connection'
-- or its @/NMSettings/@.
-- 
-- These errors may be returned directly from t'GI.NM.Interfaces.Connection.Connection' and t'GI.NM.Objects.Setting.Setting'
-- methods, or may be returned from D-Bus operations (eg on t'GI.NM.Objects.Client.Client' or
-- t'GI.NM.Objects.Device.Device'), where they correspond to errors in the
-- \"org.freedesktop.NetworkManager.Settings.Connection\" namespace.
data ConnectionError = 
      ConnectionErrorFailed
    -- ^ unknown or unclassified error
    | ConnectionErrorSettingNotFound
    -- ^ the t'GI.NM.Interfaces.Connection.Connection' object
    --   did not contain the specified t'GI.NM.Objects.Setting.Setting' object
    | ConnectionErrorPropertyNotFound
    -- ^ the t'GI.NM.Interfaces.Connection.Connection' did not contain the
    --   requested t'GI.NM.Objects.Setting.Setting' property
    | ConnectionErrorPropertyNotSecret
    -- ^ an operation which requires a secret
    --   was attempted on a non-secret property
    | ConnectionErrorMissingSetting
    -- ^ the t'GI.NM.Interfaces.Connection.Connection' object is missing an
    --   t'GI.NM.Objects.Setting.Setting' which is required for its configuration. The error message will
    --   always be prefixed with \"&lt;setting-name>: \", where \"&lt;setting-name>\" is the
    --   name of the setting that is missing.
    | ConnectionErrorInvalidSetting
    -- ^ the t'GI.NM.Interfaces.Connection.Connection' object contains an
    --   invalid or inappropriate t'GI.NM.Objects.Setting.Setting'. The error message will always be
    --   prefixed with \"&lt;setting-name>: \", where \"&lt;setting-name>\" is the name of the
    --   setting that is invalid.
    | ConnectionErrorMissingProperty
    -- ^ the t'GI.NM.Interfaces.Connection.Connection' object is invalid
    --   because it is missing a required property. The error message will always be
    --   prefixed with \"&lt;setting-name>.&lt;property-name>: \", where \"&lt;setting-name>\" is
    --   the name of the setting with the missing property, and \"&lt;property-name>\" is
    --   the property that is missing.
    | ConnectionErrorInvalidProperty
    -- ^ the t'GI.NM.Interfaces.Connection.Connection' object is invalid
    --   because a property has an invalid value. The error message will always be
    --   prefixed with \"&lt;setting-name>.&lt;property-name>: \", where \"&lt;setting-name>\" is
    --   the name of the setting with the invalid property, and \"&lt;property-name>\" is
    --   the property that is invalid.
    | AnotherConnectionError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ConnectionError -> ShowS
[ConnectionError] -> ShowS
ConnectionError -> String
(Int -> ConnectionError -> ShowS)
-> (ConnectionError -> String)
-> ([ConnectionError] -> ShowS)
-> Show ConnectionError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ConnectionError -> ShowS
showsPrec :: Int -> ConnectionError -> ShowS
$cshow :: ConnectionError -> String
show :: ConnectionError -> String
$cshowList :: [ConnectionError] -> ShowS
showList :: [ConnectionError] -> ShowS
Show, ConnectionError -> ConnectionError -> Bool
(ConnectionError -> ConnectionError -> Bool)
-> (ConnectionError -> ConnectionError -> Bool)
-> Eq ConnectionError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConnectionError -> ConnectionError -> Bool
== :: ConnectionError -> ConnectionError -> Bool
$c/= :: ConnectionError -> ConnectionError -> Bool
/= :: ConnectionError -> ConnectionError -> Bool
Eq)

instance P.Enum ConnectionError where
    fromEnum :: ConnectionError -> Int
fromEnum ConnectionError
ConnectionErrorFailed = Int
0
    fromEnum ConnectionError
ConnectionErrorSettingNotFound = Int
1
    fromEnum ConnectionError
ConnectionErrorPropertyNotFound = Int
2
    fromEnum ConnectionError
ConnectionErrorPropertyNotSecret = Int
3
    fromEnum ConnectionError
ConnectionErrorMissingSetting = Int
4
    fromEnum ConnectionError
ConnectionErrorInvalidSetting = Int
5
    fromEnum ConnectionError
ConnectionErrorMissingProperty = Int
6
    fromEnum ConnectionError
ConnectionErrorInvalidProperty = Int
7
    fromEnum (AnotherConnectionError Int
k) = Int
k

    toEnum :: Int -> ConnectionError
toEnum Int
0 = ConnectionError
ConnectionErrorFailed
    toEnum Int
1 = ConnectionError
ConnectionErrorSettingNotFound
    toEnum Int
2 = ConnectionError
ConnectionErrorPropertyNotFound
    toEnum Int
3 = ConnectionError
ConnectionErrorPropertyNotSecret
    toEnum Int
4 = ConnectionError
ConnectionErrorMissingSetting
    toEnum Int
5 = ConnectionError
ConnectionErrorInvalidSetting
    toEnum Int
6 = ConnectionError
ConnectionErrorMissingProperty
    toEnum Int
7 = ConnectionError
ConnectionErrorInvalidProperty
    toEnum Int
k = Int -> ConnectionError
AnotherConnectionError Int
k

instance P.Ord ConnectionError where
    compare :: ConnectionError -> ConnectionError -> Ordering
compare ConnectionError
a ConnectionError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ConnectionError -> Int
forall a. Enum a => a -> Int
P.fromEnum ConnectionError
a) (ConnectionError -> Int
forall a. Enum a => a -> Int
P.fromEnum ConnectionError
b)

instance GErrorClass ConnectionError where
    gerrorClassDomain :: ConnectionError -> Text
gerrorClassDomain ConnectionError
_ = Text
"nm-connection-error-quark"

-- | Catch exceptions of type `ConnectionError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchConnectionError ::
    IO a ->
    (ConnectionError -> GErrorMessage -> IO a) ->
    IO a
catchConnectionError :: forall a. IO a -> (ConnectionError -> Text -> IO a) -> IO a
catchConnectionError = IO a -> (ConnectionError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `ConnectionError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleConnectionError ::
    (ConnectionError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleConnectionError :: forall a. (ConnectionError -> Text -> IO a) -> IO a -> IO a
handleConnectionError = (ConnectionError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes ConnectionError = '[]
instance O.HasParentTypes ConnectionError

foreign import ccall "nm_connection_error_get_type" c_nm_connection_error_get_type :: 
    IO GType

instance B.Types.TypedObject ConnectionError where
    glibType :: IO GType
glibType = IO GType
c_nm_connection_error_get_type

instance B.Types.BoxedEnum ConnectionError

-- Enum ClientPermissionResult
-- | t'GI.NM.Enums.ClientPermissionResult' values indicate what authorizations and permissions
-- the user requires to obtain a given t'GI.NM.Enums.ClientPermission'
data ClientPermissionResult = 
      ClientPermissionResultUnknown
    -- ^ unknown or no authorization
    | ClientPermissionResultYes
    -- ^ the permission is available
    | ClientPermissionResultAuth
    -- ^ authorization is necessary before the
    --  permission is available
    | ClientPermissionResultNo
    -- ^ permission to perform the operation is
    --  denied by system policy
    | AnotherClientPermissionResult Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ClientPermissionResult -> ShowS
[ClientPermissionResult] -> ShowS
ClientPermissionResult -> String
(Int -> ClientPermissionResult -> ShowS)
-> (ClientPermissionResult -> String)
-> ([ClientPermissionResult] -> ShowS)
-> Show ClientPermissionResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClientPermissionResult -> ShowS
showsPrec :: Int -> ClientPermissionResult -> ShowS
$cshow :: ClientPermissionResult -> String
show :: ClientPermissionResult -> String
$cshowList :: [ClientPermissionResult] -> ShowS
showList :: [ClientPermissionResult] -> ShowS
Show, ClientPermissionResult -> ClientPermissionResult -> Bool
(ClientPermissionResult -> ClientPermissionResult -> Bool)
-> (ClientPermissionResult -> ClientPermissionResult -> Bool)
-> Eq ClientPermissionResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClientPermissionResult -> ClientPermissionResult -> Bool
== :: ClientPermissionResult -> ClientPermissionResult -> Bool
$c/= :: ClientPermissionResult -> ClientPermissionResult -> Bool
/= :: ClientPermissionResult -> ClientPermissionResult -> Bool
Eq)

instance P.Enum ClientPermissionResult where
    fromEnum :: ClientPermissionResult -> Int
fromEnum ClientPermissionResult
ClientPermissionResultUnknown = Int
0
    fromEnum ClientPermissionResult
ClientPermissionResultYes = Int
1
    fromEnum ClientPermissionResult
ClientPermissionResultAuth = Int
2
    fromEnum ClientPermissionResult
ClientPermissionResultNo = Int
3
    fromEnum (AnotherClientPermissionResult Int
k) = Int
k

    toEnum :: Int -> ClientPermissionResult
toEnum Int
0 = ClientPermissionResult
ClientPermissionResultUnknown
    toEnum Int
1 = ClientPermissionResult
ClientPermissionResultYes
    toEnum Int
2 = ClientPermissionResult
ClientPermissionResultAuth
    toEnum Int
3 = ClientPermissionResult
ClientPermissionResultNo
    toEnum Int
k = Int -> ClientPermissionResult
AnotherClientPermissionResult Int
k

instance P.Ord ClientPermissionResult where
    compare :: ClientPermissionResult -> ClientPermissionResult -> Ordering
compare ClientPermissionResult
a ClientPermissionResult
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ClientPermissionResult -> Int
forall a. Enum a => a -> Int
P.fromEnum ClientPermissionResult
a) (ClientPermissionResult -> Int
forall a. Enum a => a -> Int
P.fromEnum ClientPermissionResult
b)

type instance O.ParentTypes ClientPermissionResult = '[]
instance O.HasParentTypes ClientPermissionResult

foreign import ccall "nm_client_permission_result_get_type" c_nm_client_permission_result_get_type :: 
    IO GType

instance B.Types.TypedObject ClientPermissionResult where
    glibType :: IO GType
glibType = IO GType
c_nm_client_permission_result_get_type

instance B.Types.BoxedEnum ClientPermissionResult

-- Enum ClientPermission
-- | t'GI.NM.Enums.ClientPermission' values indicate various permissions that NetworkManager
-- clients can obtain to perform certain tasks on behalf of the current user.
data ClientPermission = 
      ClientPermissionNone
    -- ^ unknown or no permission
    | ClientPermissionEnableDisableNetwork
    -- ^ controls whether networking
    --  can be globally enabled or disabled
    | ClientPermissionEnableDisableWifi
    -- ^ controls whether Wi-Fi can be
    --  globally enabled or disabled
    | ClientPermissionEnableDisableWwan
    -- ^ controls whether WWAN (3G) can be
    --  globally enabled or disabled
    | ClientPermissionEnableDisableWimax
    -- ^ controls whether WiMAX can be
    --  globally enabled or disabled
    | ClientPermissionSleepWake
    -- ^ controls whether the client can ask
    --  NetworkManager to sleep and wake
    | ClientPermissionNetworkControl
    -- ^ controls whether networking connections
    --  can be started, stopped, and changed
    | ClientPermissionWifiShareProtected
    -- ^ controls whether a password
    --  protected Wi-Fi hotspot can be created
    | ClientPermissionWifiShareOpen
    -- ^ controls whether an open Wi-Fi hotspot
    --  can be created
    | ClientPermissionSettingsModifySystem
    -- ^ controls whether connections
    --  that are available to all users can be modified
    | ClientPermissionSettingsModifyOwn
    -- ^ controls whether connections
    --  owned by the current user can be modified
    | ClientPermissionSettingsModifyHostname
    -- ^ controls whether the
    --  persistent hostname can be changed
    | ClientPermissionSettingsModifyGlobalDns
    -- ^ modify persistent global
    --  DNS configuration
    | ClientPermissionReload
    -- ^ controls access to Reload.
    | ClientPermissionCheckpointRollback
    -- ^ permission to create checkpoints.
    | ClientPermissionEnableDisableStatistics
    -- ^ controls whether device
    --  statistics can be globally enabled or disabled
    | ClientPermissionEnableDisableConnectivityCheck
    -- ^ controls whether
    --  connectivity check can be enabled or disabled
    | ClientPermissionWifiScan
    -- ^ controls whether wifi scans can be performed
    | ClientPermissionLast
    -- ^ a reserved boundary value
    | AnotherClientPermission Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ClientPermission -> ShowS
[ClientPermission] -> ShowS
ClientPermission -> String
(Int -> ClientPermission -> ShowS)
-> (ClientPermission -> String)
-> ([ClientPermission] -> ShowS)
-> Show ClientPermission
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClientPermission -> ShowS
showsPrec :: Int -> ClientPermission -> ShowS
$cshow :: ClientPermission -> String
show :: ClientPermission -> String
$cshowList :: [ClientPermission] -> ShowS
showList :: [ClientPermission] -> ShowS
Show, ClientPermission -> ClientPermission -> Bool
(ClientPermission -> ClientPermission -> Bool)
-> (ClientPermission -> ClientPermission -> Bool)
-> Eq ClientPermission
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClientPermission -> ClientPermission -> Bool
== :: ClientPermission -> ClientPermission -> Bool
$c/= :: ClientPermission -> ClientPermission -> Bool
/= :: ClientPermission -> ClientPermission -> Bool
Eq)

instance P.Enum ClientPermission where
    fromEnum :: ClientPermission -> Int
fromEnum ClientPermission
ClientPermissionNone = Int
0
    fromEnum ClientPermission
ClientPermissionEnableDisableNetwork = Int
1
    fromEnum ClientPermission
ClientPermissionEnableDisableWifi = Int
2
    fromEnum ClientPermission
ClientPermissionEnableDisableWwan = Int
3
    fromEnum ClientPermission
ClientPermissionEnableDisableWimax = Int
4
    fromEnum ClientPermission
ClientPermissionSleepWake = Int
5
    fromEnum ClientPermission
ClientPermissionNetworkControl = Int
6
    fromEnum ClientPermission
ClientPermissionWifiShareProtected = Int
7
    fromEnum ClientPermission
ClientPermissionWifiShareOpen = Int
8
    fromEnum ClientPermission
ClientPermissionSettingsModifySystem = Int
9
    fromEnum ClientPermission
ClientPermissionSettingsModifyOwn = Int
10
    fromEnum ClientPermission
ClientPermissionSettingsModifyHostname = Int
11
    fromEnum ClientPermission
ClientPermissionSettingsModifyGlobalDns = Int
12
    fromEnum ClientPermission
ClientPermissionReload = Int
13
    fromEnum ClientPermission
ClientPermissionCheckpointRollback = Int
14
    fromEnum ClientPermission
ClientPermissionEnableDisableStatistics = Int
15
    fromEnum ClientPermission
ClientPermissionEnableDisableConnectivityCheck = Int
16
    fromEnum ClientPermission
ClientPermissionWifiScan = Int
17
    fromEnum ClientPermission
ClientPermissionLast = Int
17
    fromEnum (AnotherClientPermission Int
k) = Int
k

    toEnum :: Int -> ClientPermission
toEnum Int
0 = ClientPermission
ClientPermissionNone
    toEnum Int
1 = ClientPermission
ClientPermissionEnableDisableNetwork
    toEnum Int
2 = ClientPermission
ClientPermissionEnableDisableWifi
    toEnum Int
3 = ClientPermission
ClientPermissionEnableDisableWwan
    toEnum Int
4 = ClientPermission
ClientPermissionEnableDisableWimax
    toEnum Int
5 = ClientPermission
ClientPermissionSleepWake
    toEnum Int
6 = ClientPermission
ClientPermissionNetworkControl
    toEnum Int
7 = ClientPermission
ClientPermissionWifiShareProtected
    toEnum Int
8 = ClientPermission
ClientPermissionWifiShareOpen
    toEnum Int
9 = ClientPermission
ClientPermissionSettingsModifySystem
    toEnum Int
10 = ClientPermission
ClientPermissionSettingsModifyOwn
    toEnum Int
11 = ClientPermission
ClientPermissionSettingsModifyHostname
    toEnum Int
12 = ClientPermission
ClientPermissionSettingsModifyGlobalDns
    toEnum Int
13 = ClientPermission
ClientPermissionReload
    toEnum Int
14 = ClientPermission
ClientPermissionCheckpointRollback
    toEnum Int
15 = ClientPermission
ClientPermissionEnableDisableStatistics
    toEnum Int
16 = ClientPermission
ClientPermissionEnableDisableConnectivityCheck
    toEnum Int
17 = ClientPermission
ClientPermissionWifiScan
    toEnum Int
k = Int -> ClientPermission
AnotherClientPermission Int
k

instance P.Ord ClientPermission where
    compare :: ClientPermission -> ClientPermission -> Ordering
compare ClientPermission
a ClientPermission
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ClientPermission -> Int
forall a. Enum a => a -> Int
P.fromEnum ClientPermission
a) (ClientPermission -> Int
forall a. Enum a => a -> Int
P.fromEnum ClientPermission
b)

type instance O.ParentTypes ClientPermission = '[]
instance O.HasParentTypes ClientPermission

foreign import ccall "nm_client_permission_get_type" c_nm_client_permission_get_type :: 
    IO GType

instance B.Types.TypedObject ClientPermission where
    glibType :: IO GType
glibType = IO GType
c_nm_client_permission_get_type

instance B.Types.BoxedEnum ClientPermission

-- Enum ClientError
-- | Describes errors that may result from operations involving a t'GI.NM.Objects.Client.Client'.
-- 
-- D-Bus operations may also return errors from other domains, including
-- t'GI.NM.Enums.ManagerError', t'GI.NM.Enums.SettingsError', t'GI.NM.Enums.AgentManagerError', and t'GI.NM.Enums.ConnectionError'.
data ClientError = 
      ClientErrorFailed
    -- ^ unknown or unclassified error
    | ClientErrorManagerNotRunning
    -- ^ an operation that requires NetworkManager
    --   failed because NetworkManager is not running
    | ClientErrorObjectCreationFailed
    -- ^ NetworkManager claimed that an
    --   operation succeeded, but the object that was allegedly created (eg,
    --   t'GI.NM.Objects.RemoteConnection.RemoteConnection', t'GI.NM.Objects.ActiveConnection.ActiveConnection') was apparently destroyed before
    --   t'GI.NM.Objects.Client.Client' could create a representation of it.
    | AnotherClientError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ClientError -> ShowS
[ClientError] -> ShowS
ClientError -> String
(Int -> ClientError -> ShowS)
-> (ClientError -> String)
-> ([ClientError] -> ShowS)
-> Show ClientError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClientError -> ShowS
showsPrec :: Int -> ClientError -> ShowS
$cshow :: ClientError -> String
show :: ClientError -> String
$cshowList :: [ClientError] -> ShowS
showList :: [ClientError] -> ShowS
Show, ClientError -> ClientError -> Bool
(ClientError -> ClientError -> Bool)
-> (ClientError -> ClientError -> Bool) -> Eq ClientError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClientError -> ClientError -> Bool
== :: ClientError -> ClientError -> Bool
$c/= :: ClientError -> ClientError -> Bool
/= :: ClientError -> ClientError -> Bool
Eq)

instance P.Enum ClientError where
    fromEnum :: ClientError -> Int
fromEnum ClientError
ClientErrorFailed = Int
0
    fromEnum ClientError
ClientErrorManagerNotRunning = Int
1
    fromEnum ClientError
ClientErrorObjectCreationFailed = Int
2
    fromEnum (AnotherClientError Int
k) = Int
k

    toEnum :: Int -> ClientError
toEnum Int
0 = ClientError
ClientErrorFailed
    toEnum Int
1 = ClientError
ClientErrorManagerNotRunning
    toEnum Int
2 = ClientError
ClientErrorObjectCreationFailed
    toEnum Int
k = Int -> ClientError
AnotherClientError Int
k

instance P.Ord ClientError where
    compare :: ClientError -> ClientError -> Ordering
compare ClientError
a ClientError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ClientError -> Int
forall a. Enum a => a -> Int
P.fromEnum ClientError
a) (ClientError -> Int
forall a. Enum a => a -> Int
P.fromEnum ClientError
b)

instance GErrorClass ClientError where
    gerrorClassDomain :: ClientError -> Text
gerrorClassDomain ClientError
_ = Text
"nm-client-error-quark"

-- | Catch exceptions of type `ClientError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchClientError ::
    IO a ->
    (ClientError -> GErrorMessage -> IO a) ->
    IO a
catchClientError :: forall a. IO a -> (ClientError -> Text -> IO a) -> IO a
catchClientError = IO a -> (ClientError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `ClientError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleClientError ::
    (ClientError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleClientError :: forall a. (ClientError -> Text -> IO a) -> IO a -> IO a
handleClientError = (ClientError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes ClientError = '[]
instance O.HasParentTypes ClientError

foreign import ccall "nm_client_error_get_type" c_nm_client_error_get_type :: 
    IO GType

instance B.Types.TypedObject ClientError where
    glibType :: IO GType
glibType = IO GType
c_nm_client_error_get_type

instance B.Types.BoxedEnum ClientError

-- Enum Capability
-- | t'GI.NM.Enums.Capability' names the numbers in the Capabilities property.
-- Capabilities are positive numbers. They are part of stable API
-- and a certain capability number is guaranteed not to change.
-- 
-- The range 0x7000 - 0x7FFF of capabilities is guaranteed not to be
-- used by upstream NetworkManager. It could thus be used for downstream
-- extensions.
-- 
-- /Since: 1.6/
data Capability = 
      CapabilityTeam
    -- ^ Teams can be managed. This means the team device plugin
    --   is loaded.
    | CapabilityOvs
    -- ^ OpenVSwitch can be managed. This means the OVS device plugin
    --   is loaded. Since: 1.24.
    | AnotherCapability Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Capability -> ShowS
[Capability] -> ShowS
Capability -> String
(Int -> Capability -> ShowS)
-> (Capability -> String)
-> ([Capability] -> ShowS)
-> Show Capability
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Capability -> ShowS
showsPrec :: Int -> Capability -> ShowS
$cshow :: Capability -> String
show :: Capability -> String
$cshowList :: [Capability] -> ShowS
showList :: [Capability] -> ShowS
Show, Capability -> Capability -> Bool
(Capability -> Capability -> Bool)
-> (Capability -> Capability -> Bool) -> Eq Capability
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Capability -> Capability -> Bool
== :: Capability -> Capability -> Bool
$c/= :: Capability -> Capability -> Bool
/= :: Capability -> Capability -> Bool
Eq)

instance P.Enum Capability where
    fromEnum :: Capability -> Int
fromEnum Capability
CapabilityTeam = Int
1
    fromEnum Capability
CapabilityOvs = Int
2
    fromEnum (AnotherCapability Int
k) = Int
k

    toEnum :: Int -> Capability
toEnum Int
1 = Capability
CapabilityTeam
    toEnum Int
2 = Capability
CapabilityOvs
    toEnum Int
k = Int -> Capability
AnotherCapability Int
k

instance P.Ord Capability where
    compare :: Capability -> Capability -> Ordering
compare Capability
a Capability
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Capability -> Int
forall a. Enum a => a -> Int
P.fromEnum Capability
a) (Capability -> Int
forall a. Enum a => a -> Int
P.fromEnum Capability
b)

type instance O.ParentTypes Capability = '[]
instance O.HasParentTypes Capability

foreign import ccall "nm_capability_get_type" c_nm_capability_get_type :: 
    IO GType

instance B.Types.TypedObject Capability where
    glibType :: IO GType
glibType = IO GType
c_nm_capability_get_type

instance B.Types.BoxedEnum Capability

-- Enum AgentManagerError
-- | Errors returned from the secret-agent manager.
-- 
-- These errors may be returned from operations that could cause secrets to be
-- requested (such as @/nm_client_activate_connection()/@), and correspond to D-Bus
-- errors in the \"org.freedesktop.NetworkManager.AgentManager\" namespace.
data AgentManagerError = 
      AgentManagerErrorFailed
    -- ^ unknown or unspecified error
    | AgentManagerErrorPermissionDenied
    -- ^ The caller does not have permission
    --   to register a secret agent, or is trying to register the same secret agent
    --   twice.
    | AgentManagerErrorInvalidIdentifier
    -- ^ The identifier is not a valid
    --   secret agent identifier.
    | AgentManagerErrorNotRegistered
    -- ^ The caller tried to unregister an agent
    --   that was not registered.
    | AgentManagerErrorNoSecrets
    -- ^ No secret agent returned secrets for this
    --   request
    | AgentManagerErrorUserCanceled
    -- ^ The user canceled the secrets request.
    | AnotherAgentManagerError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AgentManagerError -> ShowS
[AgentManagerError] -> ShowS
AgentManagerError -> String
(Int -> AgentManagerError -> ShowS)
-> (AgentManagerError -> String)
-> ([AgentManagerError] -> ShowS)
-> Show AgentManagerError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AgentManagerError -> ShowS
showsPrec :: Int -> AgentManagerError -> ShowS
$cshow :: AgentManagerError -> String
show :: AgentManagerError -> String
$cshowList :: [AgentManagerError] -> ShowS
showList :: [AgentManagerError] -> ShowS
Show, AgentManagerError -> AgentManagerError -> Bool
(AgentManagerError -> AgentManagerError -> Bool)
-> (AgentManagerError -> AgentManagerError -> Bool)
-> Eq AgentManagerError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AgentManagerError -> AgentManagerError -> Bool
== :: AgentManagerError -> AgentManagerError -> Bool
$c/= :: AgentManagerError -> AgentManagerError -> Bool
/= :: AgentManagerError -> AgentManagerError -> Bool
Eq)

instance P.Enum AgentManagerError where
    fromEnum :: AgentManagerError -> Int
fromEnum AgentManagerError
AgentManagerErrorFailed = Int
0
    fromEnum AgentManagerError
AgentManagerErrorPermissionDenied = Int
1
    fromEnum AgentManagerError
AgentManagerErrorInvalidIdentifier = Int
2
    fromEnum AgentManagerError
AgentManagerErrorNotRegistered = Int
3
    fromEnum AgentManagerError
AgentManagerErrorNoSecrets = Int
4
    fromEnum AgentManagerError
AgentManagerErrorUserCanceled = Int
5
    fromEnum (AnotherAgentManagerError Int
k) = Int
k

    toEnum :: Int -> AgentManagerError
toEnum Int
0 = AgentManagerError
AgentManagerErrorFailed
    toEnum Int
1 = AgentManagerError
AgentManagerErrorPermissionDenied
    toEnum Int
2 = AgentManagerError
AgentManagerErrorInvalidIdentifier
    toEnum Int
3 = AgentManagerError
AgentManagerErrorNotRegistered
    toEnum Int
4 = AgentManagerError
AgentManagerErrorNoSecrets
    toEnum Int
5 = AgentManagerError
AgentManagerErrorUserCanceled
    toEnum Int
k = Int -> AgentManagerError
AnotherAgentManagerError Int
k

instance P.Ord AgentManagerError where
    compare :: AgentManagerError -> AgentManagerError -> Ordering
compare AgentManagerError
a AgentManagerError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AgentManagerError -> Int
forall a. Enum a => a -> Int
P.fromEnum AgentManagerError
a) (AgentManagerError -> Int
forall a. Enum a => a -> Int
P.fromEnum AgentManagerError
b)

instance GErrorClass AgentManagerError where
    gerrorClassDomain :: AgentManagerError -> Text
gerrorClassDomain AgentManagerError
_ = Text
"nm-agent-manager-error-quark"

-- | Catch exceptions of type `AgentManagerError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchAgentManagerError ::
    IO a ->
    (AgentManagerError -> GErrorMessage -> IO a) ->
    IO a
catchAgentManagerError :: forall a. IO a -> (AgentManagerError -> Text -> IO a) -> IO a
catchAgentManagerError = IO a -> (AgentManagerError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `AgentManagerError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleAgentManagerError ::
    (AgentManagerError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleAgentManagerError :: forall a. (AgentManagerError -> Text -> IO a) -> IO a -> IO a
handleAgentManagerError = (AgentManagerError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes AgentManagerError = '[]
instance O.HasParentTypes AgentManagerError

foreign import ccall "nm_agent_manager_error_get_type" c_nm_agent_manager_error_get_type :: 
    IO GType

instance B.Types.TypedObject AgentManagerError where
    glibType :: IO GType
glibType = IO GType
c_nm_agent_manager_error_get_type

instance B.Types.BoxedEnum AgentManagerError

-- Enum ActiveConnectionStateReason
-- | Active connection state reasons.
-- 
-- /Since: 1.8/
data ActiveConnectionStateReason = 
      ActiveConnectionStateReasonUnknown
    -- ^ The reason for the active connection
    --   state change is unknown.
    | ActiveConnectionStateReasonNone
    -- ^ No reason was given for the active
    --   connection state change.
    | ActiveConnectionStateReasonUserDisconnected
    -- ^ The active connection changed
    --   state because the user disconnected it.
    | ActiveConnectionStateReasonDeviceDisconnected
    -- ^ The active connection
    --   changed state because the device it was using was disconnected.
    | ActiveConnectionStateReasonServiceStopped
    -- ^ The service providing the
    --   VPN connection was stopped.
    | ActiveConnectionStateReasonIpConfigInvalid
    -- ^ The IP config of the active
    --   connection was invalid.
    | ActiveConnectionStateReasonConnectTimeout
    -- ^ The connection attempt to
    --   the VPN service timed out.
    | ActiveConnectionStateReasonServiceStartTimeout
    -- ^ A timeout occurred
    --   while starting the service providing the VPN connection.
    | ActiveConnectionStateReasonServiceStartFailed
    -- ^ Starting the service
    --   providing the VPN connection failed.
    | ActiveConnectionStateReasonNoSecrets
    -- ^ Necessary secrets for the
    --   connection were not provided.
    | ActiveConnectionStateReasonLoginFailed
    -- ^ Authentication to the
    --   server failed.
    | ActiveConnectionStateReasonConnectionRemoved
    -- ^ The connection was
    --   deleted from settings.
    | ActiveConnectionStateReasonDependencyFailed
    -- ^ Master connection of this
    --   connection failed to activate.
    | ActiveConnectionStateReasonDeviceRealizeFailed
    -- ^ Could not create the
    --   software device link.
    | ActiveConnectionStateReasonDeviceRemoved
    -- ^ The device this connection
    --   depended on disappeared.
    | AnotherActiveConnectionStateReason Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ActiveConnectionStateReason -> ShowS
[ActiveConnectionStateReason] -> ShowS
ActiveConnectionStateReason -> String
(Int -> ActiveConnectionStateReason -> ShowS)
-> (ActiveConnectionStateReason -> String)
-> ([ActiveConnectionStateReason] -> ShowS)
-> Show ActiveConnectionStateReason
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ActiveConnectionStateReason -> ShowS
showsPrec :: Int -> ActiveConnectionStateReason -> ShowS
$cshow :: ActiveConnectionStateReason -> String
show :: ActiveConnectionStateReason -> String
$cshowList :: [ActiveConnectionStateReason] -> ShowS
showList :: [ActiveConnectionStateReason] -> ShowS
Show, ActiveConnectionStateReason -> ActiveConnectionStateReason -> Bool
(ActiveConnectionStateReason
 -> ActiveConnectionStateReason -> Bool)
-> (ActiveConnectionStateReason
    -> ActiveConnectionStateReason -> Bool)
-> Eq ActiveConnectionStateReason
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ActiveConnectionStateReason -> ActiveConnectionStateReason -> Bool
== :: ActiveConnectionStateReason -> ActiveConnectionStateReason -> Bool
$c/= :: ActiveConnectionStateReason -> ActiveConnectionStateReason -> Bool
/= :: ActiveConnectionStateReason -> ActiveConnectionStateReason -> Bool
Eq)

instance P.Enum ActiveConnectionStateReason where
    fromEnum :: ActiveConnectionStateReason -> Int
fromEnum ActiveConnectionStateReason
ActiveConnectionStateReasonUnknown = Int
0
    fromEnum ActiveConnectionStateReason
ActiveConnectionStateReasonNone = Int
1
    fromEnum ActiveConnectionStateReason
ActiveConnectionStateReasonUserDisconnected = Int
2
    fromEnum ActiveConnectionStateReason
ActiveConnectionStateReasonDeviceDisconnected = Int
3
    fromEnum ActiveConnectionStateReason
ActiveConnectionStateReasonServiceStopped = Int
4
    fromEnum ActiveConnectionStateReason
ActiveConnectionStateReasonIpConfigInvalid = Int
5
    fromEnum ActiveConnectionStateReason
ActiveConnectionStateReasonConnectTimeout = Int
6
    fromEnum ActiveConnectionStateReason
ActiveConnectionStateReasonServiceStartTimeout = Int
7
    fromEnum ActiveConnectionStateReason
ActiveConnectionStateReasonServiceStartFailed = Int
8
    fromEnum ActiveConnectionStateReason
ActiveConnectionStateReasonNoSecrets = Int
9
    fromEnum ActiveConnectionStateReason
ActiveConnectionStateReasonLoginFailed = Int
10
    fromEnum ActiveConnectionStateReason
ActiveConnectionStateReasonConnectionRemoved = Int
11
    fromEnum ActiveConnectionStateReason
ActiveConnectionStateReasonDependencyFailed = Int
12
    fromEnum ActiveConnectionStateReason
ActiveConnectionStateReasonDeviceRealizeFailed = Int
13
    fromEnum ActiveConnectionStateReason
ActiveConnectionStateReasonDeviceRemoved = Int
14
    fromEnum (AnotherActiveConnectionStateReason Int
k) = Int
k

    toEnum :: Int -> ActiveConnectionStateReason
toEnum Int
0 = ActiveConnectionStateReason
ActiveConnectionStateReasonUnknown
    toEnum Int
1 = ActiveConnectionStateReason
ActiveConnectionStateReasonNone
    toEnum Int
2 = ActiveConnectionStateReason
ActiveConnectionStateReasonUserDisconnected
    toEnum Int
3 = ActiveConnectionStateReason
ActiveConnectionStateReasonDeviceDisconnected
    toEnum Int
4 = ActiveConnectionStateReason
ActiveConnectionStateReasonServiceStopped
    toEnum Int
5 = ActiveConnectionStateReason
ActiveConnectionStateReasonIpConfigInvalid
    toEnum Int
6 = ActiveConnectionStateReason
ActiveConnectionStateReasonConnectTimeout
    toEnum Int
7 = ActiveConnectionStateReason
ActiveConnectionStateReasonServiceStartTimeout
    toEnum Int
8 = ActiveConnectionStateReason
ActiveConnectionStateReasonServiceStartFailed
    toEnum Int
9 = ActiveConnectionStateReason
ActiveConnectionStateReasonNoSecrets
    toEnum Int
10 = ActiveConnectionStateReason
ActiveConnectionStateReasonLoginFailed
    toEnum Int
11 = ActiveConnectionStateReason
ActiveConnectionStateReasonConnectionRemoved
    toEnum Int
12 = ActiveConnectionStateReason
ActiveConnectionStateReasonDependencyFailed
    toEnum Int
13 = ActiveConnectionStateReason
ActiveConnectionStateReasonDeviceRealizeFailed
    toEnum Int
14 = ActiveConnectionStateReason
ActiveConnectionStateReasonDeviceRemoved
    toEnum Int
k = Int -> ActiveConnectionStateReason
AnotherActiveConnectionStateReason Int
k

instance P.Ord ActiveConnectionStateReason where
    compare :: ActiveConnectionStateReason
-> ActiveConnectionStateReason -> Ordering
compare ActiveConnectionStateReason
a ActiveConnectionStateReason
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ActiveConnectionStateReason -> Int
forall a. Enum a => a -> Int
P.fromEnum ActiveConnectionStateReason
a) (ActiveConnectionStateReason -> Int
forall a. Enum a => a -> Int
P.fromEnum ActiveConnectionStateReason
b)

type instance O.ParentTypes ActiveConnectionStateReason = '[]
instance O.HasParentTypes ActiveConnectionStateReason

foreign import ccall "nm_active_connection_state_reason_get_type" c_nm_active_connection_state_reason_get_type :: 
    IO GType

instance B.Types.TypedObject ActiveConnectionStateReason where
    glibType :: IO GType
glibType = IO GType
c_nm_active_connection_state_reason_get_type

instance B.Types.BoxedEnum ActiveConnectionStateReason

-- Enum ActiveConnectionState
-- | t'GI.NM.Enums.ActiveConnectionState' values indicate the state of a connection to a
-- specific network while it is starting, connected, or disconnecting from that
-- network.
data ActiveConnectionState = 
      ActiveConnectionStateUnknown
    -- ^ the state of the connection is unknown
    | ActiveConnectionStateActivating
    -- ^ a network connection is being prepared
    | ActiveConnectionStateActivated
    -- ^ there is a connection to the network
    | ActiveConnectionStateDeactivating
    -- ^ the network connection is being
    --   torn down and cleaned up
    | ActiveConnectionStateDeactivated
    -- ^ the network connection is disconnected
    --   and will be removed
    | AnotherActiveConnectionState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ActiveConnectionState -> ShowS
[ActiveConnectionState] -> ShowS
ActiveConnectionState -> String
(Int -> ActiveConnectionState -> ShowS)
-> (ActiveConnectionState -> String)
-> ([ActiveConnectionState] -> ShowS)
-> Show ActiveConnectionState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ActiveConnectionState -> ShowS
showsPrec :: Int -> ActiveConnectionState -> ShowS
$cshow :: ActiveConnectionState -> String
show :: ActiveConnectionState -> String
$cshowList :: [ActiveConnectionState] -> ShowS
showList :: [ActiveConnectionState] -> ShowS
Show, ActiveConnectionState -> ActiveConnectionState -> Bool
(ActiveConnectionState -> ActiveConnectionState -> Bool)
-> (ActiveConnectionState -> ActiveConnectionState -> Bool)
-> Eq ActiveConnectionState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ActiveConnectionState -> ActiveConnectionState -> Bool
== :: ActiveConnectionState -> ActiveConnectionState -> Bool
$c/= :: ActiveConnectionState -> ActiveConnectionState -> Bool
/= :: ActiveConnectionState -> ActiveConnectionState -> Bool
Eq)

instance P.Enum ActiveConnectionState where
    fromEnum :: ActiveConnectionState -> Int
fromEnum ActiveConnectionState
ActiveConnectionStateUnknown = Int
0
    fromEnum ActiveConnectionState
ActiveConnectionStateActivating = Int
1
    fromEnum ActiveConnectionState
ActiveConnectionStateActivated = Int
2
    fromEnum ActiveConnectionState
ActiveConnectionStateDeactivating = Int
3
    fromEnum ActiveConnectionState
ActiveConnectionStateDeactivated = Int
4
    fromEnum (AnotherActiveConnectionState Int
k) = Int
k

    toEnum :: Int -> ActiveConnectionState
toEnum Int
0 = ActiveConnectionState
ActiveConnectionStateUnknown
    toEnum Int
1 = ActiveConnectionState
ActiveConnectionStateActivating
    toEnum Int
2 = ActiveConnectionState
ActiveConnectionStateActivated
    toEnum Int
3 = ActiveConnectionState
ActiveConnectionStateDeactivating
    toEnum Int
4 = ActiveConnectionState
ActiveConnectionStateDeactivated
    toEnum Int
k = Int -> ActiveConnectionState
AnotherActiveConnectionState Int
k

instance P.Ord ActiveConnectionState where
    compare :: ActiveConnectionState -> ActiveConnectionState -> Ordering
compare ActiveConnectionState
a ActiveConnectionState
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ActiveConnectionState -> Int
forall a. Enum a => a -> Int
P.fromEnum ActiveConnectionState
a) (ActiveConnectionState -> Int
forall a. Enum a => a -> Int
P.fromEnum ActiveConnectionState
b)

type instance O.ParentTypes ActiveConnectionState = '[]
instance O.HasParentTypes ActiveConnectionState

foreign import ccall "nm_active_connection_state_get_type" c_nm_active_connection_state_get_type :: 
    IO GType

instance B.Types.TypedObject ActiveConnectionState where
    glibType :: IO GType
glibType = IO GType
c_nm_active_connection_state_get_type

instance B.Types.BoxedEnum ActiveConnectionState

-- Enum 80211Mode
-- | Indicates the 802.11 mode an access point or device is currently in.
data NM80211Mode = 
      NM80211ModeUnknown
    -- ^ the device or access point mode is unknown
    | NM80211ModeAdhoc
    -- ^ for both devices and access point objects, indicates
    --   the object is part of an Ad-Hoc 802.11 network without a central
    --   coordinating access point.
    | NM80211ModeInfra
    -- ^ the device or access point is in infrastructure mode.
    --   For devices, this indicates the device is an 802.11 client\/station.  For
    --   access point objects, this indicates the object is an access point that
    --   provides connectivity to clients.
    | NM80211ModeAp
    -- ^ the device is an access point\/hotspot.  Not valid for
    --   access point objects; used only for hotspot mode on the local machine.
    | NM80211ModeMesh
    -- ^ the device is a 802.11s mesh point. Since: 1.20.
    | AnotherNM80211Mode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> NM80211Mode -> ShowS
[NM80211Mode] -> ShowS
NM80211Mode -> String
(Int -> NM80211Mode -> ShowS)
-> (NM80211Mode -> String)
-> ([NM80211Mode] -> ShowS)
-> Show NM80211Mode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NM80211Mode -> ShowS
showsPrec :: Int -> NM80211Mode -> ShowS
$cshow :: NM80211Mode -> String
show :: NM80211Mode -> String
$cshowList :: [NM80211Mode] -> ShowS
showList :: [NM80211Mode] -> ShowS
Show, NM80211Mode -> NM80211Mode -> Bool
(NM80211Mode -> NM80211Mode -> Bool)
-> (NM80211Mode -> NM80211Mode -> Bool) -> Eq NM80211Mode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NM80211Mode -> NM80211Mode -> Bool
== :: NM80211Mode -> NM80211Mode -> Bool
$c/= :: NM80211Mode -> NM80211Mode -> Bool
/= :: NM80211Mode -> NM80211Mode -> Bool
Eq)

instance P.Enum NM80211Mode where
    fromEnum :: NM80211Mode -> Int
fromEnum NM80211Mode
NM80211ModeUnknown = Int
0
    fromEnum NM80211Mode
NM80211ModeAdhoc = Int
1
    fromEnum NM80211Mode
NM80211ModeInfra = Int
2
    fromEnum NM80211Mode
NM80211ModeAp = Int
3
    fromEnum NM80211Mode
NM80211ModeMesh = Int
4
    fromEnum (AnotherNM80211Mode Int
k) = Int
k

    toEnum :: Int -> NM80211Mode
toEnum Int
0 = NM80211Mode
NM80211ModeUnknown
    toEnum Int
1 = NM80211Mode
NM80211ModeAdhoc
    toEnum Int
2 = NM80211Mode
NM80211ModeInfra
    toEnum Int
3 = NM80211Mode
NM80211ModeAp
    toEnum Int
4 = NM80211Mode
NM80211ModeMesh
    toEnum Int
k = Int -> NM80211Mode
AnotherNM80211Mode Int
k

instance P.Ord NM80211Mode where
    compare :: NM80211Mode -> NM80211Mode -> Ordering
compare NM80211Mode
a NM80211Mode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (NM80211Mode -> Int
forall a. Enum a => a -> Int
P.fromEnum NM80211Mode
a) (NM80211Mode -> Int
forall a. Enum a => a -> Int
P.fromEnum NM80211Mode
b)

type instance O.ParentTypes NM80211Mode = '[]
instance O.HasParentTypes NM80211Mode

foreign import ccall "nm_802_11_mode_get_type" c_nm_802_11_mode_get_type :: 
    IO GType

instance B.Types.TypedObject NM80211Mode where
    glibType :: IO GType
glibType = IO GType
c_nm_802_11_mode_get_type

instance B.Types.BoxedEnum NM80211Mode