-- | 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.Flags
    ( 

 -- * Flags


-- ** ActivationStateFlags #flag:ActivationStateFlags#

    ActivationStateFlags(..)                ,


-- ** BluetoothCapabilities #flag:BluetoothCapabilities#

    BluetoothCapabilities(..)               ,


-- ** CheckpointCreateFlags #flag:CheckpointCreateFlags#

    CheckpointCreateFlags(..)               ,


-- ** ClientInstanceFlags #flag:ClientInstanceFlags#

    ClientInstanceFlags(..)                 ,


-- ** ConnectionSerializationFlags #flag:ConnectionSerializationFlags#

    ConnectionSerializationFlags(..)        ,


-- ** DeviceCapabilities #flag:DeviceCapabilities#

    DeviceCapabilities(..)                  ,


-- ** DeviceInterfaceFlags #flag:DeviceInterfaceFlags#

    DeviceInterfaceFlags(..)                ,


-- ** DeviceModemCapabilities #flag:DeviceModemCapabilities#

    DeviceModemCapabilities(..)             ,


-- ** DeviceReapplyFlags #flag:DeviceReapplyFlags#

    DeviceReapplyFlags(..)                  ,


-- ** DeviceWifiCapabilities #flag:DeviceWifiCapabilities#

    DeviceWifiCapabilities(..)              ,


-- ** DhcpHostnameFlags #flag:DhcpHostnameFlags#

    DhcpHostnameFlags(..)                   ,


-- ** IPAddressCmpFlags #flag:IPAddressCmpFlags#

    IPAddressCmpFlags(..)                   ,


-- ** IPRoutingRuleAsStringFlags #flag:IPRoutingRuleAsStringFlags#

    IPRoutingRuleAsStringFlags(..)          ,


-- ** IPTunnelFlags #flag:IPTunnelFlags#

    IPTunnelFlags(..)                       ,


-- ** KeyfileHandlerFlags #flag:KeyfileHandlerFlags#

    KeyfileHandlerFlags(..)                 ,


-- ** ManagerReloadFlags #flag:ManagerReloadFlags#

    ManagerReloadFlags(..)                  ,


-- ** MptcpFlags #flag:MptcpFlags#

    MptcpFlags(..)                          ,


-- ** NM80211ApFlags #flag:NM80211ApFlags#

    NM80211ApFlags(..)                      ,


-- ** NM80211ApSecurityFlags #flag:NM80211ApSecurityFlags#

    NM80211ApSecurityFlags(..)              ,


-- ** RadioFlags #flag:RadioFlags#

    RadioFlags(..)                          ,


-- ** SecretAgentCapabilities #flag:SecretAgentCapabilities#

    SecretAgentCapabilities(..)             ,


-- ** SecretAgentGetSecretsFlags #flag:SecretAgentGetSecretsFlags#

    SecretAgentGetSecretsFlags(..)          ,


-- ** Setting8021xAuthFlags #flag:Setting8021xAuthFlags#

    Setting8021xAuthFlags(..)               ,


-- ** SettingDcbFlags #flag:SettingDcbFlags#

    SettingDcbFlags(..)                     ,


-- ** SettingSecretFlags #flag:SettingSecretFlags#

    SettingSecretFlags(..)                  ,


-- ** SettingWiredWakeOnLan #flag:SettingWiredWakeOnLan#

    SettingWiredWakeOnLan(..)               ,


-- ** SettingWirelessSecurityWpsMethod #flag:SettingWirelessSecurityWpsMethod#

    SettingWirelessSecurityWpsMethod(..)    ,


-- ** SettingWirelessWakeOnWLan #flag:SettingWirelessWakeOnWLan#

    SettingWirelessWakeOnWLan(..)           ,


-- ** SettingsAddConnection2Flags #flag:SettingsAddConnection2Flags#

    SettingsAddConnection2Flags(..)         ,


-- ** SettingsConnectionFlags #flag:SettingsConnectionFlags#

    SettingsConnectionFlags(..)             ,


-- ** SettingsUpdate2Flags #flag:SettingsUpdate2Flags#

    SettingsUpdate2Flags(..)                ,


-- ** TeamLinkWatcherArpPingFlags #flag:TeamLinkWatcherArpPingFlags#

    TeamLinkWatcherArpPingFlags(..)         ,


-- ** VlanFlags #flag:VlanFlags#

    VlanFlags(..)                           ,


-- ** VpnEditorPluginCapability #flag:VpnEditorPluginCapability#

    VpnEditorPluginCapability(..)           ,




    ) 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

-- Flags VpnEditorPluginCapability
-- | Flags that indicate certain capabilities of the plugin to editor programs.
data VpnEditorPluginCapability = 
      VpnEditorPluginCapabilityNone
    -- ^ unknown or no capability
    | VpnEditorPluginCapabilityImport
    -- ^ the plugin can import new connections
    | VpnEditorPluginCapabilityExport
    -- ^ the plugin can export connections
    | VpnEditorPluginCapabilityIpv6
    -- ^ the plugin supports IPv6 addressing
    | AnotherVpnEditorPluginCapability Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VpnEditorPluginCapability -> ShowS
[VpnEditorPluginCapability] -> ShowS
VpnEditorPluginCapability -> String
(Int -> VpnEditorPluginCapability -> ShowS)
-> (VpnEditorPluginCapability -> String)
-> ([VpnEditorPluginCapability] -> ShowS)
-> Show VpnEditorPluginCapability
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VpnEditorPluginCapability -> ShowS
showsPrec :: Int -> VpnEditorPluginCapability -> ShowS
$cshow :: VpnEditorPluginCapability -> String
show :: VpnEditorPluginCapability -> String
$cshowList :: [VpnEditorPluginCapability] -> ShowS
showList :: [VpnEditorPluginCapability] -> ShowS
Show, VpnEditorPluginCapability -> VpnEditorPluginCapability -> Bool
(VpnEditorPluginCapability -> VpnEditorPluginCapability -> Bool)
-> (VpnEditorPluginCapability -> VpnEditorPluginCapability -> Bool)
-> Eq VpnEditorPluginCapability
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VpnEditorPluginCapability -> VpnEditorPluginCapability -> Bool
== :: VpnEditorPluginCapability -> VpnEditorPluginCapability -> Bool
$c/= :: VpnEditorPluginCapability -> VpnEditorPluginCapability -> Bool
/= :: VpnEditorPluginCapability -> VpnEditorPluginCapability -> Bool
Eq)

instance P.Enum VpnEditorPluginCapability where
    fromEnum :: VpnEditorPluginCapability -> Int
fromEnum VpnEditorPluginCapability
VpnEditorPluginCapabilityNone = Int
0
    fromEnum VpnEditorPluginCapability
VpnEditorPluginCapabilityImport = Int
1
    fromEnum VpnEditorPluginCapability
VpnEditorPluginCapabilityExport = Int
2
    fromEnum VpnEditorPluginCapability
VpnEditorPluginCapabilityIpv6 = Int
4
    fromEnum (AnotherVpnEditorPluginCapability Int
k) = Int
k

    toEnum :: Int -> VpnEditorPluginCapability
toEnum Int
0 = VpnEditorPluginCapability
VpnEditorPluginCapabilityNone
    toEnum Int
1 = VpnEditorPluginCapability
VpnEditorPluginCapabilityImport
    toEnum Int
2 = VpnEditorPluginCapability
VpnEditorPluginCapabilityExport
    toEnum Int
4 = VpnEditorPluginCapability
VpnEditorPluginCapabilityIpv6
    toEnum Int
k = Int -> VpnEditorPluginCapability
AnotherVpnEditorPluginCapability Int
k

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

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

foreign import ccall "nm_vpn_editor_plugin_capability_get_type" c_nm_vpn_editor_plugin_capability_get_type :: 
    IO GType

instance B.Types.TypedObject VpnEditorPluginCapability where
    glibType :: IO GType
glibType = IO GType
c_nm_vpn_editor_plugin_capability_get_type

instance B.Types.BoxedFlags VpnEditorPluginCapability

instance IsGFlag VpnEditorPluginCapability

-- Flags VlanFlags
-- | t'GI.NM.Flags.VlanFlags' values control the behavior of the VLAN interface.
data VlanFlags = 
      VlanFlagsReorderHeaders
    -- ^ indicates that this interface should reorder
    --  outgoing packet headers to look more like a non-VLAN Ethernet interface
    | VlanFlagsGvrp
    -- ^ indicates that this interface should use GVRP to register
    --  itself with its switch
    | VlanFlagsLooseBinding
    -- ^ indicates that this interface\'s operating
    --  state is tied to the underlying network interface but other details
    --  (like routing) are not.
    | VlanFlagsMvrp
    -- ^ indicates that this interface should use MVRP to register
    --  itself with its switch
    | AnotherVlanFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VlanFlags -> ShowS
[VlanFlags] -> ShowS
VlanFlags -> String
(Int -> VlanFlags -> ShowS)
-> (VlanFlags -> String)
-> ([VlanFlags] -> ShowS)
-> Show VlanFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VlanFlags -> ShowS
showsPrec :: Int -> VlanFlags -> ShowS
$cshow :: VlanFlags -> String
show :: VlanFlags -> String
$cshowList :: [VlanFlags] -> ShowS
showList :: [VlanFlags] -> ShowS
Show, VlanFlags -> VlanFlags -> Bool
(VlanFlags -> VlanFlags -> Bool)
-> (VlanFlags -> VlanFlags -> Bool) -> Eq VlanFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VlanFlags -> VlanFlags -> Bool
== :: VlanFlags -> VlanFlags -> Bool
$c/= :: VlanFlags -> VlanFlags -> Bool
/= :: VlanFlags -> VlanFlags -> Bool
Eq)

instance P.Enum VlanFlags where
    fromEnum :: VlanFlags -> Int
fromEnum VlanFlags
VlanFlagsReorderHeaders = Int
1
    fromEnum VlanFlags
VlanFlagsGvrp = Int
2
    fromEnum VlanFlags
VlanFlagsLooseBinding = Int
4
    fromEnum VlanFlags
VlanFlagsMvrp = Int
8
    fromEnum (AnotherVlanFlags Int
k) = Int
k

    toEnum :: Int -> VlanFlags
toEnum Int
1 = VlanFlags
VlanFlagsReorderHeaders
    toEnum Int
2 = VlanFlags
VlanFlagsGvrp
    toEnum Int
4 = VlanFlags
VlanFlagsLooseBinding
    toEnum Int
8 = VlanFlags
VlanFlagsMvrp
    toEnum Int
k = Int -> VlanFlags
AnotherVlanFlags Int
k

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

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

foreign import ccall "nm_vlan_flags_get_type" c_nm_vlan_flags_get_type :: 
    IO GType

instance B.Types.TypedObject VlanFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_vlan_flags_get_type

instance B.Types.BoxedFlags VlanFlags

instance IsGFlag VlanFlags

-- Flags TeamLinkWatcherArpPingFlags
-- | /No description available in the introspection data./
-- 
-- /Since: 1.12/
data TeamLinkWatcherArpPingFlags = 
      TeamLinkWatcherArpPingFlagsValidateActive
    -- ^ the arp_ping link watcher
    --    option \'validate_active\' is enabled (set to true).
    | TeamLinkWatcherArpPingFlagsValidateInactive
    -- ^ the arp_ping link watcher
    --    option \'validate_inactive\' is enabled (set to true).
    | TeamLinkWatcherArpPingFlagsSendAlways
    -- ^ the arp_ping link watcher option
    --    \'send_always\' is enabled (set to true).
    | AnotherTeamLinkWatcherArpPingFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TeamLinkWatcherArpPingFlags -> ShowS
[TeamLinkWatcherArpPingFlags] -> ShowS
TeamLinkWatcherArpPingFlags -> String
(Int -> TeamLinkWatcherArpPingFlags -> ShowS)
-> (TeamLinkWatcherArpPingFlags -> String)
-> ([TeamLinkWatcherArpPingFlags] -> ShowS)
-> Show TeamLinkWatcherArpPingFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TeamLinkWatcherArpPingFlags -> ShowS
showsPrec :: Int -> TeamLinkWatcherArpPingFlags -> ShowS
$cshow :: TeamLinkWatcherArpPingFlags -> String
show :: TeamLinkWatcherArpPingFlags -> String
$cshowList :: [TeamLinkWatcherArpPingFlags] -> ShowS
showList :: [TeamLinkWatcherArpPingFlags] -> ShowS
Show, TeamLinkWatcherArpPingFlags -> TeamLinkWatcherArpPingFlags -> Bool
(TeamLinkWatcherArpPingFlags
 -> TeamLinkWatcherArpPingFlags -> Bool)
-> (TeamLinkWatcherArpPingFlags
    -> TeamLinkWatcherArpPingFlags -> Bool)
-> Eq TeamLinkWatcherArpPingFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TeamLinkWatcherArpPingFlags -> TeamLinkWatcherArpPingFlags -> Bool
== :: TeamLinkWatcherArpPingFlags -> TeamLinkWatcherArpPingFlags -> Bool
$c/= :: TeamLinkWatcherArpPingFlags -> TeamLinkWatcherArpPingFlags -> Bool
/= :: TeamLinkWatcherArpPingFlags -> TeamLinkWatcherArpPingFlags -> Bool
Eq)

instance P.Enum TeamLinkWatcherArpPingFlags where
    fromEnum :: TeamLinkWatcherArpPingFlags -> Int
fromEnum TeamLinkWatcherArpPingFlags
TeamLinkWatcherArpPingFlagsValidateActive = Int
2
    fromEnum TeamLinkWatcherArpPingFlags
TeamLinkWatcherArpPingFlagsValidateInactive = Int
4
    fromEnum TeamLinkWatcherArpPingFlags
TeamLinkWatcherArpPingFlagsSendAlways = Int
8
    fromEnum (AnotherTeamLinkWatcherArpPingFlags Int
k) = Int
k

    toEnum :: Int -> TeamLinkWatcherArpPingFlags
toEnum Int
2 = TeamLinkWatcherArpPingFlags
TeamLinkWatcherArpPingFlagsValidateActive
    toEnum Int
4 = TeamLinkWatcherArpPingFlags
TeamLinkWatcherArpPingFlagsValidateInactive
    toEnum Int
8 = TeamLinkWatcherArpPingFlags
TeamLinkWatcherArpPingFlagsSendAlways
    toEnum Int
k = Int -> TeamLinkWatcherArpPingFlags
AnotherTeamLinkWatcherArpPingFlags Int
k

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

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

foreign import ccall "nm_team_link_watcher_arp_ping_flags_get_type" c_nm_team_link_watcher_arp_ping_flags_get_type :: 
    IO GType

instance B.Types.TypedObject TeamLinkWatcherArpPingFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_team_link_watcher_arp_ping_flags_get_type

instance B.Types.BoxedFlags TeamLinkWatcherArpPingFlags

instance IsGFlag TeamLinkWatcherArpPingFlags

-- Flags SettingsUpdate2Flags
-- | /No description available in the introspection data./
-- 
-- /Since: 1.12/
data SettingsUpdate2Flags = 
      SettingsUpdate2FlagsNone
    -- ^ an alias for numeric zero, no flags set.
    | SettingsUpdate2FlagsToDisk
    -- ^ to persist the connection to disk.
    | SettingsUpdate2FlagsInMemory
    -- ^ makes the profile in-memory.
    --   Note that such profiles are stored in keyfile format under \/run.
    --   If the file is already in-memory, the file in \/run is updated in-place.
    --   Otherwise, the previous storage for the profile is left unchanged
    --   on disk, and the in-memory copy shadows it.
    --   Note that the original filename of the previous persistent storage (if any)
    --   is remembered. That means, when later persisting the profile again to disk,
    --   the file on disk will be overwritten again.
    --   Likewise, when finally deleting the profile, both the storage from \/run
    --   and persistent storage are deleted (or if the persistent storage does not
    --   allow deletion, and nmmeta file is written to mark the UUID as deleted).
    | SettingsUpdate2FlagsInMemoryDetached
    -- ^ this is almost the same
    --   as 'GI.NM.Flags.SettingsUpdate2FlagsInMemory', with one difference: when later deleting
    --   the profile, the original profile will not be deleted. Instead a nmmeta
    --   file is written to \/run to indicate that the profile is gone.
    --   Note that if such a nmmeta tombstone file exists and hides a file in persistent
    --   storage, then when re-adding the profile with the same UUID, then the original
    --   storage is taken over again.
    | SettingsUpdate2FlagsInMemoryOnly
    -- ^ this is like 'GI.NM.Flags.SettingsUpdate2FlagsInMemory',
    --   but if the connection has a corresponding file on persistent storage, the file
    --   will be deleted right away. If the profile is later again persisted to disk,
    --   a new, unused filename will be chosen.
    | SettingsUpdate2FlagsVolatile
    -- ^ This can be specified with either
    --   'GI.NM.Flags.SettingsUpdate2FlagsInMemory', 'GI.NM.Flags.SettingsUpdate2FlagsInMemoryDetached'
    --   or 'GI.NM.Flags.SettingsUpdate2FlagsInMemoryOnly'.
    --   After making the connection in-memory only, the connection is marked
    --   as volatile. That means, if the connection is currently not active
    --   it will be deleted right away. Otherwise, it is marked to for deletion
    --   once the connection deactivates. A volatile connection cannot autoactivate
    --   again (because it\'s about to be deleted), but a manual activation will
    --   clear the volatile flag.
    | SettingsUpdate2FlagsBlockAutoconnect
    -- ^ usually, when the connection
    --   has autoconnect enabled and is modified, it becomes eligible to autoconnect
    --   right away. Setting this flag, disables autoconnect until the connection
    --   is manually activated.
    | SettingsUpdate2FlagsNoReapply
    -- ^ when a profile gets modified that is
    --   currently active, then these changes don\'t take effect for the active
    --   device unless the profile gets reactivated or the configuration reapplied.
    --   There are two exceptions: by default \"connection.zone\" and \"connection.metered\"
    --   properties take effect immediately. Specify this flag to prevent these
    --   properties to take effect, so that the change is restricted to modify
    --   the profile. Since: 1.20.
    | AnotherSettingsUpdate2Flags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingsUpdate2Flags -> ShowS
[SettingsUpdate2Flags] -> ShowS
SettingsUpdate2Flags -> String
(Int -> SettingsUpdate2Flags -> ShowS)
-> (SettingsUpdate2Flags -> String)
-> ([SettingsUpdate2Flags] -> ShowS)
-> Show SettingsUpdate2Flags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingsUpdate2Flags -> ShowS
showsPrec :: Int -> SettingsUpdate2Flags -> ShowS
$cshow :: SettingsUpdate2Flags -> String
show :: SettingsUpdate2Flags -> String
$cshowList :: [SettingsUpdate2Flags] -> ShowS
showList :: [SettingsUpdate2Flags] -> ShowS
Show, SettingsUpdate2Flags -> SettingsUpdate2Flags -> Bool
(SettingsUpdate2Flags -> SettingsUpdate2Flags -> Bool)
-> (SettingsUpdate2Flags -> SettingsUpdate2Flags -> Bool)
-> Eq SettingsUpdate2Flags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingsUpdate2Flags -> SettingsUpdate2Flags -> Bool
== :: SettingsUpdate2Flags -> SettingsUpdate2Flags -> Bool
$c/= :: SettingsUpdate2Flags -> SettingsUpdate2Flags -> Bool
/= :: SettingsUpdate2Flags -> SettingsUpdate2Flags -> Bool
Eq)

instance P.Enum SettingsUpdate2Flags where
    fromEnum :: SettingsUpdate2Flags -> Int
fromEnum SettingsUpdate2Flags
SettingsUpdate2FlagsNone = Int
0
    fromEnum SettingsUpdate2Flags
SettingsUpdate2FlagsToDisk = Int
1
    fromEnum SettingsUpdate2Flags
SettingsUpdate2FlagsInMemory = Int
2
    fromEnum SettingsUpdate2Flags
SettingsUpdate2FlagsInMemoryDetached = Int
4
    fromEnum SettingsUpdate2Flags
SettingsUpdate2FlagsInMemoryOnly = Int
8
    fromEnum SettingsUpdate2Flags
SettingsUpdate2FlagsVolatile = Int
16
    fromEnum SettingsUpdate2Flags
SettingsUpdate2FlagsBlockAutoconnect = Int
32
    fromEnum SettingsUpdate2Flags
SettingsUpdate2FlagsNoReapply = Int
64
    fromEnum (AnotherSettingsUpdate2Flags Int
k) = Int
k

    toEnum :: Int -> SettingsUpdate2Flags
toEnum Int
0 = SettingsUpdate2Flags
SettingsUpdate2FlagsNone
    toEnum Int
1 = SettingsUpdate2Flags
SettingsUpdate2FlagsToDisk
    toEnum Int
2 = SettingsUpdate2Flags
SettingsUpdate2FlagsInMemory
    toEnum Int
4 = SettingsUpdate2Flags
SettingsUpdate2FlagsInMemoryDetached
    toEnum Int
8 = SettingsUpdate2Flags
SettingsUpdate2FlagsInMemoryOnly
    toEnum Int
16 = SettingsUpdate2Flags
SettingsUpdate2FlagsVolatile
    toEnum Int
32 = SettingsUpdate2Flags
SettingsUpdate2FlagsBlockAutoconnect
    toEnum Int
64 = SettingsUpdate2Flags
SettingsUpdate2FlagsNoReapply
    toEnum Int
k = Int -> SettingsUpdate2Flags
AnotherSettingsUpdate2Flags Int
k

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

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

foreign import ccall "nm_settings_update2_flags_get_type" c_nm_settings_update2_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SettingsUpdate2Flags where
    glibType :: IO GType
glibType = IO GType
c_nm_settings_update2_flags_get_type

instance B.Types.BoxedFlags SettingsUpdate2Flags

instance IsGFlag SettingsUpdate2Flags

-- Flags SettingsConnectionFlags
-- | Flags describing the current activation state.
-- 
-- /Since: 1.12/
data SettingsConnectionFlags = 
      SettingsConnectionFlagsNone
    -- ^ an alias for numeric zero, no flags set.
    | SettingsConnectionFlagsUnsaved
    -- ^ the connection is not saved to disk.
    --   That either means, that the connection is in-memory only and currently
    --   is not backed by a file. Or, that the connection is backed by a file,
    --   but has modifications in-memory that were not persisted to disk.
    | SettingsConnectionFlagsNmGenerated
    -- ^ A connection is \"nm-generated\" if
    --  it was generated by NetworkManger. If the connection gets modified or saved
    --  by the user, the flag gets cleared. A nm-generated is also unsaved
    --  and has no backing file as it is in-memory only.
    | SettingsConnectionFlagsVolatile
    -- ^ The connection will be deleted
    --  when it disconnects. That is for in-memory connections (unsaved), which are
    --  currently active but deleted on disconnect. Volatile connections are
    --  always unsaved, but they are also no backing file on disk and are entirely
    --  in-memory only.
    | SettingsConnectionFlagsExternal
    -- ^ the profile was generated to represent
    --  an external configuration of a networking device. Since: 1.26.
    | AnotherSettingsConnectionFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingsConnectionFlags -> ShowS
[SettingsConnectionFlags] -> ShowS
SettingsConnectionFlags -> String
(Int -> SettingsConnectionFlags -> ShowS)
-> (SettingsConnectionFlags -> String)
-> ([SettingsConnectionFlags] -> ShowS)
-> Show SettingsConnectionFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingsConnectionFlags -> ShowS
showsPrec :: Int -> SettingsConnectionFlags -> ShowS
$cshow :: SettingsConnectionFlags -> String
show :: SettingsConnectionFlags -> String
$cshowList :: [SettingsConnectionFlags] -> ShowS
showList :: [SettingsConnectionFlags] -> ShowS
Show, SettingsConnectionFlags -> SettingsConnectionFlags -> Bool
(SettingsConnectionFlags -> SettingsConnectionFlags -> Bool)
-> (SettingsConnectionFlags -> SettingsConnectionFlags -> Bool)
-> Eq SettingsConnectionFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingsConnectionFlags -> SettingsConnectionFlags -> Bool
== :: SettingsConnectionFlags -> SettingsConnectionFlags -> Bool
$c/= :: SettingsConnectionFlags -> SettingsConnectionFlags -> Bool
/= :: SettingsConnectionFlags -> SettingsConnectionFlags -> Bool
Eq)

instance P.Enum SettingsConnectionFlags where
    fromEnum :: SettingsConnectionFlags -> Int
fromEnum SettingsConnectionFlags
SettingsConnectionFlagsNone = Int
0
    fromEnum SettingsConnectionFlags
SettingsConnectionFlagsUnsaved = Int
1
    fromEnum SettingsConnectionFlags
SettingsConnectionFlagsNmGenerated = Int
2
    fromEnum SettingsConnectionFlags
SettingsConnectionFlagsVolatile = Int
4
    fromEnum SettingsConnectionFlags
SettingsConnectionFlagsExternal = Int
8
    fromEnum (AnotherSettingsConnectionFlags Int
k) = Int
k

    toEnum :: Int -> SettingsConnectionFlags
toEnum Int
0 = SettingsConnectionFlags
SettingsConnectionFlagsNone
    toEnum Int
1 = SettingsConnectionFlags
SettingsConnectionFlagsUnsaved
    toEnum Int
2 = SettingsConnectionFlags
SettingsConnectionFlagsNmGenerated
    toEnum Int
4 = SettingsConnectionFlags
SettingsConnectionFlagsVolatile
    toEnum Int
8 = SettingsConnectionFlags
SettingsConnectionFlagsExternal
    toEnum Int
k = Int -> SettingsConnectionFlags
AnotherSettingsConnectionFlags Int
k

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

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

foreign import ccall "nm_settings_connection_flags_get_type" c_nm_settings_connection_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SettingsConnectionFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_settings_connection_flags_get_type

instance B.Types.BoxedFlags SettingsConnectionFlags

instance IsGFlag SettingsConnectionFlags

-- Flags SettingsAddConnection2Flags
-- | Numeric flags for the \"flags\" argument of @/AddConnection2()/@ D-Bus API.
-- 
-- /Since: 1.20/
data SettingsAddConnection2Flags = 
      SettingsAddConnection2FlagsNone
    -- ^ an alias for numeric zero, no flags set.
    | SettingsAddConnection2FlagsToDisk
    -- ^ to persist the connection to disk.
    | SettingsAddConnection2FlagsInMemory
    -- ^ to make the connection in-memory only.
    | SettingsAddConnection2FlagsBlockAutoconnect
    -- ^ usually, when the connection
    --   has autoconnect enabled and gets added, it becomes eligible to autoconnect
    --   right away. Setting this flag, disables autoconnect until the connection
    --   is manually activated.
    | AnotherSettingsAddConnection2Flags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingsAddConnection2Flags -> ShowS
[SettingsAddConnection2Flags] -> ShowS
SettingsAddConnection2Flags -> String
(Int -> SettingsAddConnection2Flags -> ShowS)
-> (SettingsAddConnection2Flags -> String)
-> ([SettingsAddConnection2Flags] -> ShowS)
-> Show SettingsAddConnection2Flags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingsAddConnection2Flags -> ShowS
showsPrec :: Int -> SettingsAddConnection2Flags -> ShowS
$cshow :: SettingsAddConnection2Flags -> String
show :: SettingsAddConnection2Flags -> String
$cshowList :: [SettingsAddConnection2Flags] -> ShowS
showList :: [SettingsAddConnection2Flags] -> ShowS
Show, SettingsAddConnection2Flags -> SettingsAddConnection2Flags -> Bool
(SettingsAddConnection2Flags
 -> SettingsAddConnection2Flags -> Bool)
-> (SettingsAddConnection2Flags
    -> SettingsAddConnection2Flags -> Bool)
-> Eq SettingsAddConnection2Flags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingsAddConnection2Flags -> SettingsAddConnection2Flags -> Bool
== :: SettingsAddConnection2Flags -> SettingsAddConnection2Flags -> Bool
$c/= :: SettingsAddConnection2Flags -> SettingsAddConnection2Flags -> Bool
/= :: SettingsAddConnection2Flags -> SettingsAddConnection2Flags -> Bool
Eq)

instance P.Enum SettingsAddConnection2Flags where
    fromEnum :: SettingsAddConnection2Flags -> Int
fromEnum SettingsAddConnection2Flags
SettingsAddConnection2FlagsNone = Int
0
    fromEnum SettingsAddConnection2Flags
SettingsAddConnection2FlagsToDisk = Int
1
    fromEnum SettingsAddConnection2Flags
SettingsAddConnection2FlagsInMemory = Int
2
    fromEnum SettingsAddConnection2Flags
SettingsAddConnection2FlagsBlockAutoconnect = Int
32
    fromEnum (AnotherSettingsAddConnection2Flags Int
k) = Int
k

    toEnum :: Int -> SettingsAddConnection2Flags
toEnum Int
0 = SettingsAddConnection2Flags
SettingsAddConnection2FlagsNone
    toEnum Int
1 = SettingsAddConnection2Flags
SettingsAddConnection2FlagsToDisk
    toEnum Int
2 = SettingsAddConnection2Flags
SettingsAddConnection2FlagsInMemory
    toEnum Int
32 = SettingsAddConnection2Flags
SettingsAddConnection2FlagsBlockAutoconnect
    toEnum Int
k = Int -> SettingsAddConnection2Flags
AnotherSettingsAddConnection2Flags Int
k

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

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

foreign import ccall "nm_settings_add_connection2_flags_get_type" c_nm_settings_add_connection2_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SettingsAddConnection2Flags where
    glibType :: IO GType
glibType = IO GType
c_nm_settings_add_connection2_flags_get_type

instance B.Types.BoxedFlags SettingsAddConnection2Flags

instance IsGFlag SettingsAddConnection2Flags

-- Flags SettingWirelessWakeOnWLan
-- | Options for [SettingWireless:wakeOnWlan]("GI.NM.Objects.SettingWireless#g:attr:wakeOnWlan"). Note that not all options
-- are supported by all devices.
-- 
-- /Since: 1.12/
data SettingWirelessWakeOnWLan = 
      SettingWirelessWakeOnWLanAny
    -- ^ Wake on any activity
    | SettingWirelessWakeOnWLanDisconnect
    -- ^ Wake on disconnect
    | SettingWirelessWakeOnWLanMagic
    -- ^ Wake on magic packet
    | SettingWirelessWakeOnWLanGtkRekeyFailure
    -- ^ Wake on GTK rekey failure
    | SettingWirelessWakeOnWLanEapIdentityRequest
    -- ^ Wake on EAP identity request
    | SettingWirelessWakeOnWLan4wayHandshake
    -- ^ Wake on 4way handshake
    | SettingWirelessWakeOnWLanRfkillRelease
    -- ^ Wake on rfkill release
    | SettingWirelessWakeOnWLanTcp
    -- ^ /No description available in the introspection data./
    | SettingWirelessWakeOnWLanAll
    -- ^ Wake on all events. This does not
    --   include the exclusive flags /@nMSETTINGWIRELESSWAKEONWLANDEFAULT@/ or
    --   /@nMSETTINGWIRELESSWAKEONWLANIGNORE@/.
    | SettingWirelessWakeOnWLanDefault
    -- ^ Use the default value
    | SettingWirelessWakeOnWLanIgnore
    -- ^ Don\'t change configured settings
    | AnotherSettingWirelessWakeOnWLan Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingWirelessWakeOnWLan -> ShowS
[SettingWirelessWakeOnWLan] -> ShowS
SettingWirelessWakeOnWLan -> String
(Int -> SettingWirelessWakeOnWLan -> ShowS)
-> (SettingWirelessWakeOnWLan -> String)
-> ([SettingWirelessWakeOnWLan] -> ShowS)
-> Show SettingWirelessWakeOnWLan
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingWirelessWakeOnWLan -> ShowS
showsPrec :: Int -> SettingWirelessWakeOnWLan -> ShowS
$cshow :: SettingWirelessWakeOnWLan -> String
show :: SettingWirelessWakeOnWLan -> String
$cshowList :: [SettingWirelessWakeOnWLan] -> ShowS
showList :: [SettingWirelessWakeOnWLan] -> ShowS
Show, SettingWirelessWakeOnWLan -> SettingWirelessWakeOnWLan -> Bool
(SettingWirelessWakeOnWLan -> SettingWirelessWakeOnWLan -> Bool)
-> (SettingWirelessWakeOnWLan -> SettingWirelessWakeOnWLan -> Bool)
-> Eq SettingWirelessWakeOnWLan
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingWirelessWakeOnWLan -> SettingWirelessWakeOnWLan -> Bool
== :: SettingWirelessWakeOnWLan -> SettingWirelessWakeOnWLan -> Bool
$c/= :: SettingWirelessWakeOnWLan -> SettingWirelessWakeOnWLan -> Bool
/= :: SettingWirelessWakeOnWLan -> SettingWirelessWakeOnWLan -> Bool
Eq)

instance P.Enum SettingWirelessWakeOnWLan where
    fromEnum :: SettingWirelessWakeOnWLan -> Int
fromEnum SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanAny = Int
2
    fromEnum SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanDisconnect = Int
4
    fromEnum SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanMagic = Int
8
    fromEnum SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanGtkRekeyFailure = Int
16
    fromEnum SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanEapIdentityRequest = Int
32
    fromEnum SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLan4wayHandshake = Int
64
    fromEnum SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanRfkillRelease = Int
128
    fromEnum SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanTcp = Int
256
    fromEnum SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanAll = Int
510
    fromEnum SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanDefault = Int
1
    fromEnum SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanIgnore = Int
32768
    fromEnum (AnotherSettingWirelessWakeOnWLan Int
k) = Int
k

    toEnum :: Int -> SettingWirelessWakeOnWLan
toEnum Int
2 = SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanAny
    toEnum Int
4 = SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanDisconnect
    toEnum Int
8 = SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanMagic
    toEnum Int
16 = SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanGtkRekeyFailure
    toEnum Int
32 = SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanEapIdentityRequest
    toEnum Int
64 = SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLan4wayHandshake
    toEnum Int
128 = SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanRfkillRelease
    toEnum Int
256 = SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanTcp
    toEnum Int
510 = SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanAll
    toEnum Int
1 = SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanDefault
    toEnum Int
32768 = SettingWirelessWakeOnWLan
SettingWirelessWakeOnWLanIgnore
    toEnum Int
k = Int -> SettingWirelessWakeOnWLan
AnotherSettingWirelessWakeOnWLan Int
k

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

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

foreign import ccall "nm_setting_wireless_wake_on_wlan_get_type" c_nm_setting_wireless_wake_on_wlan_get_type :: 
    IO GType

instance B.Types.TypedObject SettingWirelessWakeOnWLan where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_wireless_wake_on_wlan_get_type

instance B.Types.BoxedFlags SettingWirelessWakeOnWLan

instance IsGFlag SettingWirelessWakeOnWLan

-- Flags SettingWirelessSecurityWpsMethod
-- | Configure the use of WPS by a connection while it activates.
-- 
-- Note: prior to 1.16, this was a GEnum type instead of a GFlags type
-- although, with the same numeric values.
-- 
-- /Since: 1.10/
data SettingWirelessSecurityWpsMethod = 
      SettingWirelessSecurityWpsMethodDefault
    -- ^ Attempt whichever method AP supports
    | SettingWirelessSecurityWpsMethodDisabled
    -- ^ WPS can not be used.
    | SettingWirelessSecurityWpsMethodAuto
    -- ^ Use WPS, any method
    | SettingWirelessSecurityWpsMethodPbc
    -- ^ use WPS push-button method
    | SettingWirelessSecurityWpsMethodPin
    -- ^ use PIN method
    | AnotherSettingWirelessSecurityWpsMethod Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingWirelessSecurityWpsMethod -> ShowS
[SettingWirelessSecurityWpsMethod] -> ShowS
SettingWirelessSecurityWpsMethod -> String
(Int -> SettingWirelessSecurityWpsMethod -> ShowS)
-> (SettingWirelessSecurityWpsMethod -> String)
-> ([SettingWirelessSecurityWpsMethod] -> ShowS)
-> Show SettingWirelessSecurityWpsMethod
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingWirelessSecurityWpsMethod -> ShowS
showsPrec :: Int -> SettingWirelessSecurityWpsMethod -> ShowS
$cshow :: SettingWirelessSecurityWpsMethod -> String
show :: SettingWirelessSecurityWpsMethod -> String
$cshowList :: [SettingWirelessSecurityWpsMethod] -> ShowS
showList :: [SettingWirelessSecurityWpsMethod] -> ShowS
Show, SettingWirelessSecurityWpsMethod
-> SettingWirelessSecurityWpsMethod -> Bool
(SettingWirelessSecurityWpsMethod
 -> SettingWirelessSecurityWpsMethod -> Bool)
-> (SettingWirelessSecurityWpsMethod
    -> SettingWirelessSecurityWpsMethod -> Bool)
-> Eq SettingWirelessSecurityWpsMethod
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingWirelessSecurityWpsMethod
-> SettingWirelessSecurityWpsMethod -> Bool
== :: SettingWirelessSecurityWpsMethod
-> SettingWirelessSecurityWpsMethod -> Bool
$c/= :: SettingWirelessSecurityWpsMethod
-> SettingWirelessSecurityWpsMethod -> Bool
/= :: SettingWirelessSecurityWpsMethod
-> SettingWirelessSecurityWpsMethod -> Bool
Eq)

instance P.Enum SettingWirelessSecurityWpsMethod where
    fromEnum :: SettingWirelessSecurityWpsMethod -> Int
fromEnum SettingWirelessSecurityWpsMethod
SettingWirelessSecurityWpsMethodDefault = Int
0
    fromEnum SettingWirelessSecurityWpsMethod
SettingWirelessSecurityWpsMethodDisabled = Int
1
    fromEnum SettingWirelessSecurityWpsMethod
SettingWirelessSecurityWpsMethodAuto = Int
2
    fromEnum SettingWirelessSecurityWpsMethod
SettingWirelessSecurityWpsMethodPbc = Int
4
    fromEnum SettingWirelessSecurityWpsMethod
SettingWirelessSecurityWpsMethodPin = Int
8
    fromEnum (AnotherSettingWirelessSecurityWpsMethod Int
k) = Int
k

    toEnum :: Int -> SettingWirelessSecurityWpsMethod
toEnum Int
0 = SettingWirelessSecurityWpsMethod
SettingWirelessSecurityWpsMethodDefault
    toEnum Int
1 = SettingWirelessSecurityWpsMethod
SettingWirelessSecurityWpsMethodDisabled
    toEnum Int
2 = SettingWirelessSecurityWpsMethod
SettingWirelessSecurityWpsMethodAuto
    toEnum Int
4 = SettingWirelessSecurityWpsMethod
SettingWirelessSecurityWpsMethodPbc
    toEnum Int
8 = SettingWirelessSecurityWpsMethod
SettingWirelessSecurityWpsMethodPin
    toEnum Int
k = Int -> SettingWirelessSecurityWpsMethod
AnotherSettingWirelessSecurityWpsMethod Int
k

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

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

foreign import ccall "nm_setting_wireless_security_wps_method_get_type" c_nm_setting_wireless_security_wps_method_get_type :: 
    IO GType

instance B.Types.TypedObject SettingWirelessSecurityWpsMethod where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_wireless_security_wps_method_get_type

instance B.Types.BoxedFlags SettingWirelessSecurityWpsMethod

instance IsGFlag SettingWirelessSecurityWpsMethod

-- Flags SettingWiredWakeOnLan
-- | Options for [SettingWired:wakeOnLan]("GI.NM.Objects.SettingWired#g:attr:wakeOnLan"). Note that not all options
-- are supported by all devices.
-- 
-- /Since: 1.2/
data SettingWiredWakeOnLan = 
      SettingWiredWakeOnLanPhy
    -- ^ Wake on PHY activity
    | SettingWiredWakeOnLanUnicast
    -- ^ Wake on unicast messages
    | SettingWiredWakeOnLanMulticast
    -- ^ Wake on multicast messages
    | SettingWiredWakeOnLanBroadcast
    -- ^ Wake on broadcast messages
    | SettingWiredWakeOnLanArp
    -- ^ Wake on ARP
    | SettingWiredWakeOnLanMagic
    -- ^ Wake on magic packet
    | SettingWiredWakeOnLanDefault
    -- ^ Use the default value
    | SettingWiredWakeOnLanIgnore
    -- ^ Don\'t change configured settings
    | AnotherSettingWiredWakeOnLan Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingWiredWakeOnLan -> ShowS
[SettingWiredWakeOnLan] -> ShowS
SettingWiredWakeOnLan -> String
(Int -> SettingWiredWakeOnLan -> ShowS)
-> (SettingWiredWakeOnLan -> String)
-> ([SettingWiredWakeOnLan] -> ShowS)
-> Show SettingWiredWakeOnLan
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingWiredWakeOnLan -> ShowS
showsPrec :: Int -> SettingWiredWakeOnLan -> ShowS
$cshow :: SettingWiredWakeOnLan -> String
show :: SettingWiredWakeOnLan -> String
$cshowList :: [SettingWiredWakeOnLan] -> ShowS
showList :: [SettingWiredWakeOnLan] -> ShowS
Show, SettingWiredWakeOnLan -> SettingWiredWakeOnLan -> Bool
(SettingWiredWakeOnLan -> SettingWiredWakeOnLan -> Bool)
-> (SettingWiredWakeOnLan -> SettingWiredWakeOnLan -> Bool)
-> Eq SettingWiredWakeOnLan
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingWiredWakeOnLan -> SettingWiredWakeOnLan -> Bool
== :: SettingWiredWakeOnLan -> SettingWiredWakeOnLan -> Bool
$c/= :: SettingWiredWakeOnLan -> SettingWiredWakeOnLan -> Bool
/= :: SettingWiredWakeOnLan -> SettingWiredWakeOnLan -> Bool
Eq)

instance P.Enum SettingWiredWakeOnLan where
    fromEnum :: SettingWiredWakeOnLan -> Int
fromEnum SettingWiredWakeOnLan
SettingWiredWakeOnLanPhy = Int
2
    fromEnum SettingWiredWakeOnLan
SettingWiredWakeOnLanUnicast = Int
4
    fromEnum SettingWiredWakeOnLan
SettingWiredWakeOnLanMulticast = Int
8
    fromEnum SettingWiredWakeOnLan
SettingWiredWakeOnLanBroadcast = Int
16
    fromEnum SettingWiredWakeOnLan
SettingWiredWakeOnLanArp = Int
32
    fromEnum SettingWiredWakeOnLan
SettingWiredWakeOnLanMagic = Int
64
    fromEnum SettingWiredWakeOnLan
SettingWiredWakeOnLanDefault = Int
1
    fromEnum SettingWiredWakeOnLan
SettingWiredWakeOnLanIgnore = Int
32768
    fromEnum (AnotherSettingWiredWakeOnLan Int
k) = Int
k

    toEnum :: Int -> SettingWiredWakeOnLan
toEnum Int
2 = SettingWiredWakeOnLan
SettingWiredWakeOnLanPhy
    toEnum Int
4 = SettingWiredWakeOnLan
SettingWiredWakeOnLanUnicast
    toEnum Int
8 = SettingWiredWakeOnLan
SettingWiredWakeOnLanMulticast
    toEnum Int
16 = SettingWiredWakeOnLan
SettingWiredWakeOnLanBroadcast
    toEnum Int
32 = SettingWiredWakeOnLan
SettingWiredWakeOnLanArp
    toEnum Int
64 = SettingWiredWakeOnLan
SettingWiredWakeOnLanMagic
    toEnum Int
1 = SettingWiredWakeOnLan
SettingWiredWakeOnLanDefault
    toEnum Int
32768 = SettingWiredWakeOnLan
SettingWiredWakeOnLanIgnore
    toEnum Int
k = Int -> SettingWiredWakeOnLan
AnotherSettingWiredWakeOnLan Int
k

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

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

foreign import ccall "nm_setting_wired_wake_on_lan_get_type" c_nm_setting_wired_wake_on_lan_get_type :: 
    IO GType

instance B.Types.TypedObject SettingWiredWakeOnLan where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_wired_wake_on_lan_get_type

instance B.Types.BoxedFlags SettingWiredWakeOnLan

instance IsGFlag SettingWiredWakeOnLan

-- Flags SettingSecretFlags
-- | These flags indicate specific behavior related to handling of a secret.  Each
-- secret has a corresponding set of these flags which indicate how the secret
-- is to be stored and\/or requested when it is needed.
data SettingSecretFlags = 
      SettingSecretFlagsNone
    -- ^ the system is responsible for providing and
    -- storing this secret (default)
    | SettingSecretFlagsAgentOwned
    -- ^ a user secret agent is responsible
    -- for providing and storing this secret; when it is required agents will be
    -- asked to retrieve it
    | SettingSecretFlagsNotSaved
    -- ^ this secret should not be saved, but
    -- should be requested from the user each time it is needed
    | SettingSecretFlagsNotRequired
    -- ^ in situations where it cannot be
    -- automatically determined that the secret is required (some VPNs and PPP
    -- providers don\'t require all secrets) this flag indicates that the specific
    -- secret is not required
    | AnotherSettingSecretFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingSecretFlags -> ShowS
[SettingSecretFlags] -> ShowS
SettingSecretFlags -> String
(Int -> SettingSecretFlags -> ShowS)
-> (SettingSecretFlags -> String)
-> ([SettingSecretFlags] -> ShowS)
-> Show SettingSecretFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingSecretFlags -> ShowS
showsPrec :: Int -> SettingSecretFlags -> ShowS
$cshow :: SettingSecretFlags -> String
show :: SettingSecretFlags -> String
$cshowList :: [SettingSecretFlags] -> ShowS
showList :: [SettingSecretFlags] -> ShowS
Show, SettingSecretFlags -> SettingSecretFlags -> Bool
(SettingSecretFlags -> SettingSecretFlags -> Bool)
-> (SettingSecretFlags -> SettingSecretFlags -> Bool)
-> Eq SettingSecretFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingSecretFlags -> SettingSecretFlags -> Bool
== :: SettingSecretFlags -> SettingSecretFlags -> Bool
$c/= :: SettingSecretFlags -> SettingSecretFlags -> Bool
/= :: SettingSecretFlags -> SettingSecretFlags -> Bool
Eq)

instance P.Enum SettingSecretFlags where
    fromEnum :: SettingSecretFlags -> Int
fromEnum SettingSecretFlags
SettingSecretFlagsNone = Int
0
    fromEnum SettingSecretFlags
SettingSecretFlagsAgentOwned = Int
1
    fromEnum SettingSecretFlags
SettingSecretFlagsNotSaved = Int
2
    fromEnum SettingSecretFlags
SettingSecretFlagsNotRequired = Int
4
    fromEnum (AnotherSettingSecretFlags Int
k) = Int
k

    toEnum :: Int -> SettingSecretFlags
toEnum Int
0 = SettingSecretFlags
SettingSecretFlagsNone
    toEnum Int
1 = SettingSecretFlags
SettingSecretFlagsAgentOwned
    toEnum Int
2 = SettingSecretFlags
SettingSecretFlagsNotSaved
    toEnum Int
4 = SettingSecretFlags
SettingSecretFlagsNotRequired
    toEnum Int
k = Int -> SettingSecretFlags
AnotherSettingSecretFlags Int
k

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

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

foreign import ccall "nm_setting_secret_flags_get_type" c_nm_setting_secret_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SettingSecretFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_secret_flags_get_type

instance B.Types.BoxedFlags SettingSecretFlags

instance IsGFlag SettingSecretFlags

-- Flags SettingDcbFlags
-- | DCB feature flags.
data SettingDcbFlags = 
      SettingDcbFlagsNone
    -- ^ no flag
    | SettingDcbFlagsEnable
    -- ^ the feature is enabled
    | SettingDcbFlagsAdvertise
    -- ^ the feature is advertised
    | SettingDcbFlagsWilling
    -- ^ the feature is willing to change based on
    -- peer configuration advertisements
    | AnotherSettingDcbFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SettingDcbFlags -> ShowS
[SettingDcbFlags] -> ShowS
SettingDcbFlags -> String
(Int -> SettingDcbFlags -> ShowS)
-> (SettingDcbFlags -> String)
-> ([SettingDcbFlags] -> ShowS)
-> Show SettingDcbFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettingDcbFlags -> ShowS
showsPrec :: Int -> SettingDcbFlags -> ShowS
$cshow :: SettingDcbFlags -> String
show :: SettingDcbFlags -> String
$cshowList :: [SettingDcbFlags] -> ShowS
showList :: [SettingDcbFlags] -> ShowS
Show, SettingDcbFlags -> SettingDcbFlags -> Bool
(SettingDcbFlags -> SettingDcbFlags -> Bool)
-> (SettingDcbFlags -> SettingDcbFlags -> Bool)
-> Eq SettingDcbFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettingDcbFlags -> SettingDcbFlags -> Bool
== :: SettingDcbFlags -> SettingDcbFlags -> Bool
$c/= :: SettingDcbFlags -> SettingDcbFlags -> Bool
/= :: SettingDcbFlags -> SettingDcbFlags -> Bool
Eq)

instance P.Enum SettingDcbFlags where
    fromEnum :: SettingDcbFlags -> Int
fromEnum SettingDcbFlags
SettingDcbFlagsNone = Int
0
    fromEnum SettingDcbFlags
SettingDcbFlagsEnable = Int
1
    fromEnum SettingDcbFlags
SettingDcbFlagsAdvertise = Int
2
    fromEnum SettingDcbFlags
SettingDcbFlagsWilling = Int
4
    fromEnum (AnotherSettingDcbFlags Int
k) = Int
k

    toEnum :: Int -> SettingDcbFlags
toEnum Int
0 = SettingDcbFlags
SettingDcbFlagsNone
    toEnum Int
1 = SettingDcbFlags
SettingDcbFlagsEnable
    toEnum Int
2 = SettingDcbFlags
SettingDcbFlagsAdvertise
    toEnum Int
4 = SettingDcbFlags
SettingDcbFlagsWilling
    toEnum Int
k = Int -> SettingDcbFlags
AnotherSettingDcbFlags Int
k

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

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

foreign import ccall "nm_setting_dcb_flags_get_type" c_nm_setting_dcb_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SettingDcbFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_dcb_flags_get_type

instance B.Types.BoxedFlags SettingDcbFlags

instance IsGFlag SettingDcbFlags

-- Flags Setting8021xAuthFlags
-- | t'GI.NM.Flags.Setting8021xAuthFlags' values indicate which authentication settings
-- should be used.
-- 
-- Before 1.22, this was wrongly marked as a enum and not as a flags
-- type.
-- 
-- /Since: 1.8/
data Setting8021xAuthFlags = 
      Setting8021xAuthFlagsNone
    -- ^ No flags
    | Setting8021xAuthFlagsTls10Disable
    -- ^ Disable TLSv1.0
    | Setting8021xAuthFlagsTls11Disable
    -- ^ Disable TLSv1.1
    | Setting8021xAuthFlagsTls12Disable
    -- ^ Disable TLSv1.2
    | Setting8021xAuthFlagsTlsDisableTimeChecks
    -- ^ Disable TLS time checks. Since 1.42.
    | Setting8021xAuthFlagsTls13Disable
    -- ^ Disable TLSv1.3. Since 1.42.
    | Setting8021xAuthFlagsTls10Enable
    -- ^ Enable TLSv1.0. Since 1.42.
    | Setting8021xAuthFlagsTls11Enable
    -- ^ Enable TLSv1.1. Since 1.42.
    | Setting8021xAuthFlagsTls12Enable
    -- ^ Enable TLSv1.2. Since 1.42.
    | Setting8021xAuthFlagsTls13Enable
    -- ^ Enable TLSv1.3. Since 1.42.
    | Setting8021xAuthFlagsAll
    -- ^ All supported flags
    | AnotherSetting8021xAuthFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Setting8021xAuthFlags -> ShowS
[Setting8021xAuthFlags] -> ShowS
Setting8021xAuthFlags -> String
(Int -> Setting8021xAuthFlags -> ShowS)
-> (Setting8021xAuthFlags -> String)
-> ([Setting8021xAuthFlags] -> ShowS)
-> Show Setting8021xAuthFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Setting8021xAuthFlags -> ShowS
showsPrec :: Int -> Setting8021xAuthFlags -> ShowS
$cshow :: Setting8021xAuthFlags -> String
show :: Setting8021xAuthFlags -> String
$cshowList :: [Setting8021xAuthFlags] -> ShowS
showList :: [Setting8021xAuthFlags] -> ShowS
Show, Setting8021xAuthFlags -> Setting8021xAuthFlags -> Bool
(Setting8021xAuthFlags -> Setting8021xAuthFlags -> Bool)
-> (Setting8021xAuthFlags -> Setting8021xAuthFlags -> Bool)
-> Eq Setting8021xAuthFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Setting8021xAuthFlags -> Setting8021xAuthFlags -> Bool
== :: Setting8021xAuthFlags -> Setting8021xAuthFlags -> Bool
$c/= :: Setting8021xAuthFlags -> Setting8021xAuthFlags -> Bool
/= :: Setting8021xAuthFlags -> Setting8021xAuthFlags -> Bool
Eq)

instance P.Enum Setting8021xAuthFlags where
    fromEnum :: Setting8021xAuthFlags -> Int
fromEnum Setting8021xAuthFlags
Setting8021xAuthFlagsNone = Int
0
    fromEnum Setting8021xAuthFlags
Setting8021xAuthFlagsTls10Disable = Int
1
    fromEnum Setting8021xAuthFlags
Setting8021xAuthFlagsTls11Disable = Int
2
    fromEnum Setting8021xAuthFlags
Setting8021xAuthFlagsTls12Disable = Int
4
    fromEnum Setting8021xAuthFlags
Setting8021xAuthFlagsTlsDisableTimeChecks = Int
8
    fromEnum Setting8021xAuthFlags
Setting8021xAuthFlagsTls13Disable = Int
16
    fromEnum Setting8021xAuthFlags
Setting8021xAuthFlagsTls10Enable = Int
32
    fromEnum Setting8021xAuthFlags
Setting8021xAuthFlagsTls11Enable = Int
64
    fromEnum Setting8021xAuthFlags
Setting8021xAuthFlagsTls12Enable = Int
128
    fromEnum Setting8021xAuthFlags
Setting8021xAuthFlagsTls13Enable = Int
256
    fromEnum Setting8021xAuthFlags
Setting8021xAuthFlagsAll = Int
511
    fromEnum (AnotherSetting8021xAuthFlags Int
k) = Int
k

    toEnum :: Int -> Setting8021xAuthFlags
toEnum Int
0 = Setting8021xAuthFlags
Setting8021xAuthFlagsNone
    toEnum Int
1 = Setting8021xAuthFlags
Setting8021xAuthFlagsTls10Disable
    toEnum Int
2 = Setting8021xAuthFlags
Setting8021xAuthFlagsTls11Disable
    toEnum Int
4 = Setting8021xAuthFlags
Setting8021xAuthFlagsTls12Disable
    toEnum Int
8 = Setting8021xAuthFlags
Setting8021xAuthFlagsTlsDisableTimeChecks
    toEnum Int
16 = Setting8021xAuthFlags
Setting8021xAuthFlagsTls13Disable
    toEnum Int
32 = Setting8021xAuthFlags
Setting8021xAuthFlagsTls10Enable
    toEnum Int
64 = Setting8021xAuthFlags
Setting8021xAuthFlagsTls11Enable
    toEnum Int
128 = Setting8021xAuthFlags
Setting8021xAuthFlagsTls12Enable
    toEnum Int
256 = Setting8021xAuthFlags
Setting8021xAuthFlagsTls13Enable
    toEnum Int
511 = Setting8021xAuthFlags
Setting8021xAuthFlagsAll
    toEnum Int
k = Int -> Setting8021xAuthFlags
AnotherSetting8021xAuthFlags Int
k

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

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

foreign import ccall "nm_setting_802_1x_auth_flags_get_type" c_nm_setting_802_1x_auth_flags_get_type :: 
    IO GType

instance B.Types.TypedObject Setting8021xAuthFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_setting_802_1x_auth_flags_get_type

instance B.Types.BoxedFlags Setting8021xAuthFlags

instance IsGFlag Setting8021xAuthFlags

-- Flags SecretAgentGetSecretsFlags
-- | t'GI.NM.Flags.SecretAgentGetSecretsFlags' values modify the behavior of a GetSecrets request.
data SecretAgentGetSecretsFlags = 
      SecretAgentGetSecretsFlagsNone
    -- ^ no special behavior; by default no
    --   user interaction is allowed and requests for secrets are fulfilled from
    --   persistent storage, or if no secrets are available an error is returned.
    | SecretAgentGetSecretsFlagsAllowInteraction
    -- ^ allows the request to
    --   interact with the user, possibly prompting via UI for secrets if any are
    --   required, or if none are found in persistent storage.
    | SecretAgentGetSecretsFlagsRequestNew
    -- ^ explicitly prompt for new
    --   secrets from the user.  This flag signals that NetworkManager thinks any
    --   existing secrets are invalid or wrong.  This flag implies that interaction
    --   is allowed.
    | SecretAgentGetSecretsFlagsUserRequested
    -- ^ set if the request was
    --   initiated by user-requested action via the D-Bus interface, as opposed to
    --   automatically initiated by NetworkManager in response to (for example) scan
    --   results or carrier changes.
    | SecretAgentGetSecretsFlagsWpsPbcActive
    -- ^ indicates that WPS enrollment
    --   is active with PBC method. The agent may suggest that the user pushes a button
    --   on the router instead of supplying a PSK.
    | SecretAgentGetSecretsFlagsOnlySystem
    -- ^ Internal flag, not part of
    --   the D-Bus API.
    | SecretAgentGetSecretsFlagsNoErrors
    -- ^ Internal flag, not part of
    --   the D-Bus API.
    | AnotherSecretAgentGetSecretsFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SecretAgentGetSecretsFlags -> ShowS
[SecretAgentGetSecretsFlags] -> ShowS
SecretAgentGetSecretsFlags -> String
(Int -> SecretAgentGetSecretsFlags -> ShowS)
-> (SecretAgentGetSecretsFlags -> String)
-> ([SecretAgentGetSecretsFlags] -> ShowS)
-> Show SecretAgentGetSecretsFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SecretAgentGetSecretsFlags -> ShowS
showsPrec :: Int -> SecretAgentGetSecretsFlags -> ShowS
$cshow :: SecretAgentGetSecretsFlags -> String
show :: SecretAgentGetSecretsFlags -> String
$cshowList :: [SecretAgentGetSecretsFlags] -> ShowS
showList :: [SecretAgentGetSecretsFlags] -> ShowS
Show, SecretAgentGetSecretsFlags -> SecretAgentGetSecretsFlags -> Bool
(SecretAgentGetSecretsFlags -> SecretAgentGetSecretsFlags -> Bool)
-> (SecretAgentGetSecretsFlags
    -> SecretAgentGetSecretsFlags -> Bool)
-> Eq SecretAgentGetSecretsFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SecretAgentGetSecretsFlags -> SecretAgentGetSecretsFlags -> Bool
== :: SecretAgentGetSecretsFlags -> SecretAgentGetSecretsFlags -> Bool
$c/= :: SecretAgentGetSecretsFlags -> SecretAgentGetSecretsFlags -> Bool
/= :: SecretAgentGetSecretsFlags -> SecretAgentGetSecretsFlags -> Bool
Eq)

instance P.Enum SecretAgentGetSecretsFlags where
    fromEnum :: SecretAgentGetSecretsFlags -> Int
fromEnum SecretAgentGetSecretsFlags
SecretAgentGetSecretsFlagsNone = Int
0
    fromEnum SecretAgentGetSecretsFlags
SecretAgentGetSecretsFlagsAllowInteraction = Int
1
    fromEnum SecretAgentGetSecretsFlags
SecretAgentGetSecretsFlagsRequestNew = Int
2
    fromEnum SecretAgentGetSecretsFlags
SecretAgentGetSecretsFlagsUserRequested = Int
4
    fromEnum SecretAgentGetSecretsFlags
SecretAgentGetSecretsFlagsWpsPbcActive = Int
8
    fromEnum SecretAgentGetSecretsFlags
SecretAgentGetSecretsFlagsOnlySystem = Int
2147483648
    fromEnum SecretAgentGetSecretsFlags
SecretAgentGetSecretsFlagsNoErrors = Int
1073741824
    fromEnum (AnotherSecretAgentGetSecretsFlags Int
k) = Int
k

    toEnum :: Int -> SecretAgentGetSecretsFlags
toEnum Int
0 = SecretAgentGetSecretsFlags
SecretAgentGetSecretsFlagsNone
    toEnum Int
1 = SecretAgentGetSecretsFlags
SecretAgentGetSecretsFlagsAllowInteraction
    toEnum Int
2 = SecretAgentGetSecretsFlags
SecretAgentGetSecretsFlagsRequestNew
    toEnum Int
4 = SecretAgentGetSecretsFlags
SecretAgentGetSecretsFlagsUserRequested
    toEnum Int
8 = SecretAgentGetSecretsFlags
SecretAgentGetSecretsFlagsWpsPbcActive
    toEnum Int
2147483648 = SecretAgentGetSecretsFlags
SecretAgentGetSecretsFlagsOnlySystem
    toEnum Int
1073741824 = SecretAgentGetSecretsFlags
SecretAgentGetSecretsFlagsNoErrors
    toEnum Int
k = Int -> SecretAgentGetSecretsFlags
AnotherSecretAgentGetSecretsFlags Int
k

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

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

foreign import ccall "nm_secret_agent_get_secrets_flags_get_type" c_nm_secret_agent_get_secrets_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SecretAgentGetSecretsFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_secret_agent_get_secrets_flags_get_type

instance B.Types.BoxedFlags SecretAgentGetSecretsFlags

instance IsGFlag SecretAgentGetSecretsFlags

-- Flags SecretAgentCapabilities
-- | t'GI.NM.Flags.SecretAgentCapabilities' indicate various capabilities of the agent.
data SecretAgentCapabilities = 
      SecretAgentCapabilitiesNone
    -- ^ the agent supports no special capabilities
    | SecretAgentCapabilitiesVpnHints
    -- ^ the agent supports passing hints to
    -- VPN plugin authentication dialogs.
    | SecretAgentCapabilitiesLast
    -- ^ bounds checking value; should not be used.
    | AnotherSecretAgentCapabilities Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SecretAgentCapabilities -> ShowS
[SecretAgentCapabilities] -> ShowS
SecretAgentCapabilities -> String
(Int -> SecretAgentCapabilities -> ShowS)
-> (SecretAgentCapabilities -> String)
-> ([SecretAgentCapabilities] -> ShowS)
-> Show SecretAgentCapabilities
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SecretAgentCapabilities -> ShowS
showsPrec :: Int -> SecretAgentCapabilities -> ShowS
$cshow :: SecretAgentCapabilities -> String
show :: SecretAgentCapabilities -> String
$cshowList :: [SecretAgentCapabilities] -> ShowS
showList :: [SecretAgentCapabilities] -> ShowS
Show, SecretAgentCapabilities -> SecretAgentCapabilities -> Bool
(SecretAgentCapabilities -> SecretAgentCapabilities -> Bool)
-> (SecretAgentCapabilities -> SecretAgentCapabilities -> Bool)
-> Eq SecretAgentCapabilities
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SecretAgentCapabilities -> SecretAgentCapabilities -> Bool
== :: SecretAgentCapabilities -> SecretAgentCapabilities -> Bool
$c/= :: SecretAgentCapabilities -> SecretAgentCapabilities -> Bool
/= :: SecretAgentCapabilities -> SecretAgentCapabilities -> Bool
Eq)

instance P.Enum SecretAgentCapabilities where
    fromEnum :: SecretAgentCapabilities -> Int
fromEnum SecretAgentCapabilities
SecretAgentCapabilitiesNone = Int
0
    fromEnum SecretAgentCapabilities
SecretAgentCapabilitiesVpnHints = Int
1
    fromEnum SecretAgentCapabilities
SecretAgentCapabilitiesLast = Int
1
    fromEnum (AnotherSecretAgentCapabilities Int
k) = Int
k

    toEnum :: Int -> SecretAgentCapabilities
toEnum Int
0 = SecretAgentCapabilities
SecretAgentCapabilitiesNone
    toEnum Int
1 = SecretAgentCapabilities
SecretAgentCapabilitiesVpnHints
    toEnum Int
k = Int -> SecretAgentCapabilities
AnotherSecretAgentCapabilities Int
k

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

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

foreign import ccall "nm_secret_agent_capabilities_get_type" c_nm_secret_agent_capabilities_get_type :: 
    IO GType

instance B.Types.TypedObject SecretAgentCapabilities where
    glibType :: IO GType
glibType = IO GType
c_nm_secret_agent_capabilities_get_type

instance B.Types.BoxedFlags SecretAgentCapabilities

instance IsGFlag SecretAgentCapabilities

-- Flags RadioFlags
-- | Flags related to radio interfaces.
-- 
-- /Since: 1.38/
data RadioFlags = 
      RadioFlagsNone
    -- ^ an alias for numeric zero, no flags set.
    | RadioFlagsWlanAvailable
    -- ^ A Wireless LAN device or rfkill switch
    --   is detected in the system.
    | RadioFlagsWwanAvailable
    -- ^ A Wireless WAN device or rfkill switch
    --   is detected in the system.
    | AnotherRadioFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RadioFlags -> ShowS
[RadioFlags] -> ShowS
RadioFlags -> String
(Int -> RadioFlags -> ShowS)
-> (RadioFlags -> String)
-> ([RadioFlags] -> ShowS)
-> Show RadioFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RadioFlags -> ShowS
showsPrec :: Int -> RadioFlags -> ShowS
$cshow :: RadioFlags -> String
show :: RadioFlags -> String
$cshowList :: [RadioFlags] -> ShowS
showList :: [RadioFlags] -> ShowS
Show, RadioFlags -> RadioFlags -> Bool
(RadioFlags -> RadioFlags -> Bool)
-> (RadioFlags -> RadioFlags -> Bool) -> Eq RadioFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RadioFlags -> RadioFlags -> Bool
== :: RadioFlags -> RadioFlags -> Bool
$c/= :: RadioFlags -> RadioFlags -> Bool
/= :: RadioFlags -> RadioFlags -> Bool
Eq)

instance P.Enum RadioFlags where
    fromEnum :: RadioFlags -> Int
fromEnum RadioFlags
RadioFlagsNone = Int
0
    fromEnum RadioFlags
RadioFlagsWlanAvailable = Int
1
    fromEnum RadioFlags
RadioFlagsWwanAvailable = Int
2
    fromEnum (AnotherRadioFlags Int
k) = Int
k

    toEnum :: Int -> RadioFlags
toEnum Int
0 = RadioFlags
RadioFlagsNone
    toEnum Int
1 = RadioFlags
RadioFlagsWlanAvailable
    toEnum Int
2 = RadioFlags
RadioFlagsWwanAvailable
    toEnum Int
k = Int -> RadioFlags
AnotherRadioFlags Int
k

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

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

foreign import ccall "nm_radio_flags_get_type" c_nm_radio_flags_get_type :: 
    IO GType

instance B.Types.TypedObject RadioFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_radio_flags_get_type

instance B.Types.BoxedFlags RadioFlags

instance IsGFlag RadioFlags

-- Flags MptcpFlags
-- | /No description available in the introspection data./
-- 
-- /Since: 1.40/
data MptcpFlags = 
      MptcpFlagsNone
    -- ^ The default, meaning that no MPTCP flags are set.
    | MptcpFlagsDisabled
    -- ^ don\'t configure MPTCP endpoints on the device.
    | MptcpFlagsEnabled
    -- ^ MPTCP is enabled and endpoints will be configured.
    --   This flag is implied if any of the other flags indicate that
    --   MPTCP is enabled and therefore in most cases unnecessary.
    --   Note that if \"\/proc\/sys\/net\/mptcp\/enabled\" sysctl is disabled, MPTCP
    --   handling is disabled despite this flag. This can be overruled with the
    --   \"also-without-sysctl\" flag.
    --   Note that by default interfaces that don\'t have a default route are
    --   excluded from having MPTCP endpoints configured. This can be overruled
    --   with the \"also-without-default-route\" and this affects endpoints
    --   per address family.
    | MptcpFlagsAlsoWithoutSysctl
    -- ^ even if MPTCP handling is enabled
    --   via the \"enabled\" flag, it is ignored unless \"\/proc\/sys\/net\/mptcp\/enabled\"
    --   is on. With this flag, MPTCP endpoints will be configured regardless
    --   of the sysctl setting.
    | MptcpFlagsAlsoWithoutDefaultRoute
    -- ^ even if MPTCP handling is enabled
    --   via the \"enabled\" flag, it is ignored per-address family unless NetworkManager
    --   configures a default route. With this flag, NetworkManager will also configure
    --   MPTCP endpoints if there is no default route. This takes effect per-address
    --   family.
    | MptcpFlagsSignal
    -- ^ Flag for the MPTCP endpoint. The endpoint will be
    --   announced\/signaled to each peer via an MPTCP ADD_ADDR sub-option.
    | MptcpFlagsSubflow
    -- ^ Flag for the MPTCP endpoint. If additional subflow creation
    --   is allowed by the MPTCP limits, the MPTCP path manager will try to create an
    --   additional subflow using this endpoint as the source address after the MPTCP connection
    --   is established.
    | MptcpFlagsBackup
    -- ^ Flag for the MPTCP endpoint. If this is a subflow endpoint, the
    --   subflows created using this endpoint will have the backup flag set during the connection
    --   process. This flag instructs the peer to only send data on a given subflow when all
    --   non-backup subflows are unavailable. This does not affect outgoing data,
    --   where subflow priority is determined by the backup\/non-backup flag received
    --   from the peer
    | MptcpFlagsFullmesh
    -- ^ Flag for the MPTCP endpoint. If this is a subflow endpoint and additional
    --   subflow creation is allowed by the MPTCP limits, the MPTCP path manager will try to create an
    --   additional subflow for each known peer address, using this endpoint as the source address.
    --   This will occur after the MPTCP connection is established. If the peer did not announce
    --   any additional addresses using the MPTCP ADD_ADDR sub-option, this will behave the same
    --   as a plain subflow endpoint. When the peer does announce addresses, each received ADD_ADDR
    --   sub-option will trigger creation of an additional subflow to generate a full mesh topology.
    | AnotherMptcpFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MptcpFlags -> ShowS
[MptcpFlags] -> ShowS
MptcpFlags -> String
(Int -> MptcpFlags -> ShowS)
-> (MptcpFlags -> String)
-> ([MptcpFlags] -> ShowS)
-> Show MptcpFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MptcpFlags -> ShowS
showsPrec :: Int -> MptcpFlags -> ShowS
$cshow :: MptcpFlags -> String
show :: MptcpFlags -> String
$cshowList :: [MptcpFlags] -> ShowS
showList :: [MptcpFlags] -> ShowS
Show, MptcpFlags -> MptcpFlags -> Bool
(MptcpFlags -> MptcpFlags -> Bool)
-> (MptcpFlags -> MptcpFlags -> Bool) -> Eq MptcpFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MptcpFlags -> MptcpFlags -> Bool
== :: MptcpFlags -> MptcpFlags -> Bool
$c/= :: MptcpFlags -> MptcpFlags -> Bool
/= :: MptcpFlags -> MptcpFlags -> Bool
Eq)

instance P.Enum MptcpFlags where
    fromEnum :: MptcpFlags -> Int
fromEnum MptcpFlags
MptcpFlagsNone = Int
0
    fromEnum MptcpFlags
MptcpFlagsDisabled = Int
1
    fromEnum MptcpFlags
MptcpFlagsEnabled = Int
2
    fromEnum MptcpFlags
MptcpFlagsAlsoWithoutSysctl = Int
4
    fromEnum MptcpFlags
MptcpFlagsAlsoWithoutDefaultRoute = Int
8
    fromEnum MptcpFlags
MptcpFlagsSignal = Int
16
    fromEnum MptcpFlags
MptcpFlagsSubflow = Int
32
    fromEnum MptcpFlags
MptcpFlagsBackup = Int
64
    fromEnum MptcpFlags
MptcpFlagsFullmesh = Int
128
    fromEnum (AnotherMptcpFlags Int
k) = Int
k

    toEnum :: Int -> MptcpFlags
toEnum Int
0 = MptcpFlags
MptcpFlagsNone
    toEnum Int
1 = MptcpFlags
MptcpFlagsDisabled
    toEnum Int
2 = MptcpFlags
MptcpFlagsEnabled
    toEnum Int
4 = MptcpFlags
MptcpFlagsAlsoWithoutSysctl
    toEnum Int
8 = MptcpFlags
MptcpFlagsAlsoWithoutDefaultRoute
    toEnum Int
16 = MptcpFlags
MptcpFlagsSignal
    toEnum Int
32 = MptcpFlags
MptcpFlagsSubflow
    toEnum Int
64 = MptcpFlags
MptcpFlagsBackup
    toEnum Int
128 = MptcpFlags
MptcpFlagsFullmesh
    toEnum Int
k = Int -> MptcpFlags
AnotherMptcpFlags Int
k

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

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

foreign import ccall "nm_mptcp_flags_get_type" c_nm_mptcp_flags_get_type :: 
    IO GType

instance B.Types.TypedObject MptcpFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_mptcp_flags_get_type

instance B.Types.BoxedFlags MptcpFlags

instance IsGFlag MptcpFlags

-- Flags ManagerReloadFlags
-- | Flags for the manager @/Reload()/@ call.
-- 
-- /Since: 1.22/
data ManagerReloadFlags = 
      ManagerReloadFlagsConf
    -- ^ reload the NetworkManager.conf configuration
    --   from disk. Note that this does not include connections, which can be
    --   reloaded via Setting\'s @/ReloadConnections()/@.
    | ManagerReloadFlagsDnsRc
    -- ^ update DNS configuration, which usually
    --   involves writing \/etc\/resolv.conf anew.
    | ManagerReloadFlagsDnsFull
    -- ^ means to restart the DNS plugin. This
    --   is for example useful when using dnsmasq plugin, which uses additional
    --   configuration in \/etc\/NetworkManager\/dnsmasq.d. If you edit those files,
    --   you can restart the DNS plugin. This action shortly interrupts name
    --   resolution.
    | AnotherManagerReloadFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ManagerReloadFlags -> ShowS
[ManagerReloadFlags] -> ShowS
ManagerReloadFlags -> String
(Int -> ManagerReloadFlags -> ShowS)
-> (ManagerReloadFlags -> String)
-> ([ManagerReloadFlags] -> ShowS)
-> Show ManagerReloadFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ManagerReloadFlags -> ShowS
showsPrec :: Int -> ManagerReloadFlags -> ShowS
$cshow :: ManagerReloadFlags -> String
show :: ManagerReloadFlags -> String
$cshowList :: [ManagerReloadFlags] -> ShowS
showList :: [ManagerReloadFlags] -> ShowS
Show, ManagerReloadFlags -> ManagerReloadFlags -> Bool
(ManagerReloadFlags -> ManagerReloadFlags -> Bool)
-> (ManagerReloadFlags -> ManagerReloadFlags -> Bool)
-> Eq ManagerReloadFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ManagerReloadFlags -> ManagerReloadFlags -> Bool
== :: ManagerReloadFlags -> ManagerReloadFlags -> Bool
$c/= :: ManagerReloadFlags -> ManagerReloadFlags -> Bool
/= :: ManagerReloadFlags -> ManagerReloadFlags -> Bool
Eq)

instance P.Enum ManagerReloadFlags where
    fromEnum :: ManagerReloadFlags -> Int
fromEnum ManagerReloadFlags
ManagerReloadFlagsConf = Int
1
    fromEnum ManagerReloadFlags
ManagerReloadFlagsDnsRc = Int
2
    fromEnum ManagerReloadFlags
ManagerReloadFlagsDnsFull = Int
4
    fromEnum (AnotherManagerReloadFlags Int
k) = Int
k

    toEnum :: Int -> ManagerReloadFlags
toEnum Int
1 = ManagerReloadFlags
ManagerReloadFlagsConf
    toEnum Int
2 = ManagerReloadFlags
ManagerReloadFlagsDnsRc
    toEnum Int
4 = ManagerReloadFlags
ManagerReloadFlagsDnsFull
    toEnum Int
k = Int -> ManagerReloadFlags
AnotherManagerReloadFlags Int
k

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

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

foreign import ccall "nm_manager_reload_flags_get_type" c_nm_manager_reload_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ManagerReloadFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_manager_reload_flags_get_type

instance B.Types.BoxedFlags ManagerReloadFlags

instance IsGFlag ManagerReloadFlags

-- Flags KeyfileHandlerFlags
-- | Flags for customizing 'GI.NM.Functions.keyfileRead' and 'GI.NM.Functions.keyfileWrite'.
-- 
-- Currently no flags are implemented.
-- 
-- /Since: 1.30/
data KeyfileHandlerFlags = 
      KeyfileHandlerFlagsNone
    -- ^ no flags set.
    | AnotherKeyfileHandlerFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> KeyfileHandlerFlags -> ShowS
[KeyfileHandlerFlags] -> ShowS
KeyfileHandlerFlags -> String
(Int -> KeyfileHandlerFlags -> ShowS)
-> (KeyfileHandlerFlags -> String)
-> ([KeyfileHandlerFlags] -> ShowS)
-> Show KeyfileHandlerFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyfileHandlerFlags -> ShowS
showsPrec :: Int -> KeyfileHandlerFlags -> ShowS
$cshow :: KeyfileHandlerFlags -> String
show :: KeyfileHandlerFlags -> String
$cshowList :: [KeyfileHandlerFlags] -> ShowS
showList :: [KeyfileHandlerFlags] -> ShowS
Show, KeyfileHandlerFlags -> KeyfileHandlerFlags -> Bool
(KeyfileHandlerFlags -> KeyfileHandlerFlags -> Bool)
-> (KeyfileHandlerFlags -> KeyfileHandlerFlags -> Bool)
-> Eq KeyfileHandlerFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyfileHandlerFlags -> KeyfileHandlerFlags -> Bool
== :: KeyfileHandlerFlags -> KeyfileHandlerFlags -> Bool
$c/= :: KeyfileHandlerFlags -> KeyfileHandlerFlags -> Bool
/= :: KeyfileHandlerFlags -> KeyfileHandlerFlags -> Bool
Eq)

instance P.Enum KeyfileHandlerFlags where
    fromEnum :: KeyfileHandlerFlags -> Int
fromEnum KeyfileHandlerFlags
KeyfileHandlerFlagsNone = Int
0
    fromEnum (AnotherKeyfileHandlerFlags Int
k) = Int
k

    toEnum :: Int -> KeyfileHandlerFlags
toEnum Int
0 = KeyfileHandlerFlags
KeyfileHandlerFlagsNone
    toEnum Int
k = Int -> KeyfileHandlerFlags
AnotherKeyfileHandlerFlags Int
k

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

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

foreign import ccall "nm_keyfile_handler_flags_get_type" c_nm_keyfile_handler_flags_get_type :: 
    IO GType

instance B.Types.TypedObject KeyfileHandlerFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_keyfile_handler_flags_get_type

instance B.Types.BoxedFlags KeyfileHandlerFlags

instance IsGFlag KeyfileHandlerFlags

-- Flags IPTunnelFlags
-- | IP tunnel flags.
-- 
-- /Since: 1.12/
data IPTunnelFlags = 
      IPTunnelFlagsNone
    -- ^ no flag
    | IPTunnelFlagsIp6IgnEncapLimit
    -- ^ don\'t add encapsulation limit
    --     if one isn\'t present in inner packet
    | IPTunnelFlagsIp6UseOrigTclass
    -- ^ copy the traffic class field
    --     from the inner packet
    | IPTunnelFlagsIp6UseOrigFlowlabel
    -- ^ copy the flowlabel from the
    --     inner packet
    | IPTunnelFlagsIp6Mip6Dev
    -- ^ used for Mobile IPv6
    | IPTunnelFlagsIp6RcvDscpCopy
    -- ^ copy DSCP from the outer packet
    | IPTunnelFlagsIp6UseOrigFwmark
    -- ^ copy fwmark from inner packet
    | AnotherIPTunnelFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> IPTunnelFlags -> ShowS
[IPTunnelFlags] -> ShowS
IPTunnelFlags -> String
(Int -> IPTunnelFlags -> ShowS)
-> (IPTunnelFlags -> String)
-> ([IPTunnelFlags] -> ShowS)
-> Show IPTunnelFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IPTunnelFlags -> ShowS
showsPrec :: Int -> IPTunnelFlags -> ShowS
$cshow :: IPTunnelFlags -> String
show :: IPTunnelFlags -> String
$cshowList :: [IPTunnelFlags] -> ShowS
showList :: [IPTunnelFlags] -> ShowS
Show, IPTunnelFlags -> IPTunnelFlags -> Bool
(IPTunnelFlags -> IPTunnelFlags -> Bool)
-> (IPTunnelFlags -> IPTunnelFlags -> Bool) -> Eq IPTunnelFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IPTunnelFlags -> IPTunnelFlags -> Bool
== :: IPTunnelFlags -> IPTunnelFlags -> Bool
$c/= :: IPTunnelFlags -> IPTunnelFlags -> Bool
/= :: IPTunnelFlags -> IPTunnelFlags -> Bool
Eq)

instance P.Enum IPTunnelFlags where
    fromEnum :: IPTunnelFlags -> Int
fromEnum IPTunnelFlags
IPTunnelFlagsNone = Int
0
    fromEnum IPTunnelFlags
IPTunnelFlagsIp6IgnEncapLimit = Int
1
    fromEnum IPTunnelFlags
IPTunnelFlagsIp6UseOrigTclass = Int
2
    fromEnum IPTunnelFlags
IPTunnelFlagsIp6UseOrigFlowlabel = Int
4
    fromEnum IPTunnelFlags
IPTunnelFlagsIp6Mip6Dev = Int
8
    fromEnum IPTunnelFlags
IPTunnelFlagsIp6RcvDscpCopy = Int
16
    fromEnum IPTunnelFlags
IPTunnelFlagsIp6UseOrigFwmark = Int
32
    fromEnum (AnotherIPTunnelFlags Int
k) = Int
k

    toEnum :: Int -> IPTunnelFlags
toEnum Int
0 = IPTunnelFlags
IPTunnelFlagsNone
    toEnum Int
1 = IPTunnelFlags
IPTunnelFlagsIp6IgnEncapLimit
    toEnum Int
2 = IPTunnelFlags
IPTunnelFlagsIp6UseOrigTclass
    toEnum Int
4 = IPTunnelFlags
IPTunnelFlagsIp6UseOrigFlowlabel
    toEnum Int
8 = IPTunnelFlags
IPTunnelFlagsIp6Mip6Dev
    toEnum Int
16 = IPTunnelFlags
IPTunnelFlagsIp6RcvDscpCopy
    toEnum Int
32 = IPTunnelFlags
IPTunnelFlagsIp6UseOrigFwmark
    toEnum Int
k = Int -> IPTunnelFlags
AnotherIPTunnelFlags Int
k

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

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

foreign import ccall "nm_ip_tunnel_flags_get_type" c_nm_ip_tunnel_flags_get_type :: 
    IO GType

instance B.Types.TypedObject IPTunnelFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_ip_tunnel_flags_get_type

instance B.Types.BoxedFlags IPTunnelFlags

instance IsGFlag IPTunnelFlags

-- Flags IPRoutingRuleAsStringFlags
-- | /No description available in the introspection data./
-- 
-- /Since: 1.18/
data IPRoutingRuleAsStringFlags = 
      IPRoutingRuleAsStringFlagsNone
    -- ^ no flags selected.
    | IPRoutingRuleAsStringFlagsAfInet
    -- ^ whether to allow parsing
    --   IPv4 addresses.
    | IPRoutingRuleAsStringFlagsAfInet6
    -- ^ whether to allow parsing
    --   IPv6 addresses. If both /@nMIPROUTINGRULEASSTRINGFLAGSAFINET@/ and
    --   /@nMIPROUTINGRULEASSTRINGFLAGSAFINET6@/ are unset, it\'s the same
    --   as setting them both.
    | IPRoutingRuleAsStringFlagsValidate
    -- ^ if set, ensure that the
    --   rule verfies or fail.
    | AnotherIPRoutingRuleAsStringFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> IPRoutingRuleAsStringFlags -> ShowS
[IPRoutingRuleAsStringFlags] -> ShowS
IPRoutingRuleAsStringFlags -> String
(Int -> IPRoutingRuleAsStringFlags -> ShowS)
-> (IPRoutingRuleAsStringFlags -> String)
-> ([IPRoutingRuleAsStringFlags] -> ShowS)
-> Show IPRoutingRuleAsStringFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IPRoutingRuleAsStringFlags -> ShowS
showsPrec :: Int -> IPRoutingRuleAsStringFlags -> ShowS
$cshow :: IPRoutingRuleAsStringFlags -> String
show :: IPRoutingRuleAsStringFlags -> String
$cshowList :: [IPRoutingRuleAsStringFlags] -> ShowS
showList :: [IPRoutingRuleAsStringFlags] -> ShowS
Show, IPRoutingRuleAsStringFlags -> IPRoutingRuleAsStringFlags -> Bool
(IPRoutingRuleAsStringFlags -> IPRoutingRuleAsStringFlags -> Bool)
-> (IPRoutingRuleAsStringFlags
    -> IPRoutingRuleAsStringFlags -> Bool)
-> Eq IPRoutingRuleAsStringFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IPRoutingRuleAsStringFlags -> IPRoutingRuleAsStringFlags -> Bool
== :: IPRoutingRuleAsStringFlags -> IPRoutingRuleAsStringFlags -> Bool
$c/= :: IPRoutingRuleAsStringFlags -> IPRoutingRuleAsStringFlags -> Bool
/= :: IPRoutingRuleAsStringFlags -> IPRoutingRuleAsStringFlags -> Bool
Eq)

instance P.Enum IPRoutingRuleAsStringFlags where
    fromEnum :: IPRoutingRuleAsStringFlags -> Int
fromEnum IPRoutingRuleAsStringFlags
IPRoutingRuleAsStringFlagsNone = Int
0
    fromEnum IPRoutingRuleAsStringFlags
IPRoutingRuleAsStringFlagsAfInet = Int
1
    fromEnum IPRoutingRuleAsStringFlags
IPRoutingRuleAsStringFlagsAfInet6 = Int
2
    fromEnum IPRoutingRuleAsStringFlags
IPRoutingRuleAsStringFlagsValidate = Int
4
    fromEnum (AnotherIPRoutingRuleAsStringFlags Int
k) = Int
k

    toEnum :: Int -> IPRoutingRuleAsStringFlags
toEnum Int
0 = IPRoutingRuleAsStringFlags
IPRoutingRuleAsStringFlagsNone
    toEnum Int
1 = IPRoutingRuleAsStringFlags
IPRoutingRuleAsStringFlagsAfInet
    toEnum Int
2 = IPRoutingRuleAsStringFlags
IPRoutingRuleAsStringFlagsAfInet6
    toEnum Int
4 = IPRoutingRuleAsStringFlags
IPRoutingRuleAsStringFlagsValidate
    toEnum Int
k = Int -> IPRoutingRuleAsStringFlags
AnotherIPRoutingRuleAsStringFlags Int
k

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

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

foreign import ccall "nm_ip_routing_rule_as_string_flags_get_type" c_nm_ip_routing_rule_as_string_flags_get_type :: 
    IO GType

instance B.Types.TypedObject IPRoutingRuleAsStringFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_ip_routing_rule_as_string_flags_get_type

instance B.Types.BoxedFlags IPRoutingRuleAsStringFlags

instance IsGFlag IPRoutingRuleAsStringFlags

-- Flags IPAddressCmpFlags
-- | Compare flags for 'GI.NM.Structs.IPAddress.iPAddressCmpFull'.
-- 
-- /Since: 1.22/
data IPAddressCmpFlags = 
      IPAddressCmpFlagsNone
    -- ^ no flags.
    | IPAddressCmpFlagsWithAttrs
    -- ^ when comparing two addresses,
    --   also consider their attributes. Warning: note that attributes are GVariants
    --   and they don\'t have a total order. In other words, if the address differs only
    --   by their attributes, the returned compare order is not total. In that case,
    --   the return value merely indicates equality (zero) or inequality.
    | AnotherIPAddressCmpFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> IPAddressCmpFlags -> ShowS
[IPAddressCmpFlags] -> ShowS
IPAddressCmpFlags -> String
(Int -> IPAddressCmpFlags -> ShowS)
-> (IPAddressCmpFlags -> String)
-> ([IPAddressCmpFlags] -> ShowS)
-> Show IPAddressCmpFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IPAddressCmpFlags -> ShowS
showsPrec :: Int -> IPAddressCmpFlags -> ShowS
$cshow :: IPAddressCmpFlags -> String
show :: IPAddressCmpFlags -> String
$cshowList :: [IPAddressCmpFlags] -> ShowS
showList :: [IPAddressCmpFlags] -> ShowS
Show, IPAddressCmpFlags -> IPAddressCmpFlags -> Bool
(IPAddressCmpFlags -> IPAddressCmpFlags -> Bool)
-> (IPAddressCmpFlags -> IPAddressCmpFlags -> Bool)
-> Eq IPAddressCmpFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IPAddressCmpFlags -> IPAddressCmpFlags -> Bool
== :: IPAddressCmpFlags -> IPAddressCmpFlags -> Bool
$c/= :: IPAddressCmpFlags -> IPAddressCmpFlags -> Bool
/= :: IPAddressCmpFlags -> IPAddressCmpFlags -> Bool
Eq)

instance P.Enum IPAddressCmpFlags where
    fromEnum :: IPAddressCmpFlags -> Int
fromEnum IPAddressCmpFlags
IPAddressCmpFlagsNone = Int
0
    fromEnum IPAddressCmpFlags
IPAddressCmpFlagsWithAttrs = Int
1
    fromEnum (AnotherIPAddressCmpFlags Int
k) = Int
k

    toEnum :: Int -> IPAddressCmpFlags
toEnum Int
0 = IPAddressCmpFlags
IPAddressCmpFlagsNone
    toEnum Int
1 = IPAddressCmpFlags
IPAddressCmpFlagsWithAttrs
    toEnum Int
k = Int -> IPAddressCmpFlags
AnotherIPAddressCmpFlags Int
k

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

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

foreign import ccall "nm_ip_address_cmp_flags_get_type" c_nm_ip_address_cmp_flags_get_type :: 
    IO GType

instance B.Types.TypedObject IPAddressCmpFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_ip_address_cmp_flags_get_type

instance B.Types.BoxedFlags IPAddressCmpFlags

instance IsGFlag IPAddressCmpFlags

-- Flags DhcpHostnameFlags
-- | t'GI.NM.Flags.DhcpHostnameFlags' describe flags related to the DHCP hostname and
-- FQDN.
-- 
-- /Since: 1.22/
data DhcpHostnameFlags = 
      DhcpHostnameFlagsNone
    -- ^ no flag set. The default value from
    --   Networkmanager global configuration is used. If such value is unset
    --   or still zero, the DHCP request will use standard FQDN flags, i.e.
    --   'GI.NM.Flags.DhcpHostnameFlagsFqdnServUpdate' and
    --   'GI.NM.Flags.DhcpHostnameFlagsFqdnEncoded' for IPv4 and
    --   'GI.NM.Flags.DhcpHostnameFlagsFqdnServUpdate' for IPv6.
    | DhcpHostnameFlagsFqdnServUpdate
    -- ^ whether the server should
    --   do the A RR (FQDN-to-address) DNS updates.
    | DhcpHostnameFlagsFqdnEncoded
    -- ^ if set, the FQDN is encoded
    --   using canonical wire format. Otherwise it uses the deprecated
    --   ASCII encoding. This flag is allowed only for DHCPv4.
    | DhcpHostnameFlagsFqdnNoUpdate
    -- ^ when not set, request the
    --   server to perform updates (the PTR RR and possibly the A RR
    --   based on the 'GI.NM.Flags.DhcpHostnameFlagsFqdnServUpdate' flag). If
    --   this is set, the 'GI.NM.Flags.DhcpHostnameFlagsFqdnServUpdate' flag
    --   should be cleared.
    | DhcpHostnameFlagsFqdnClearFlags
    -- ^ when set, no FQDN flags are
    --   sent in the DHCP FQDN option. When cleared and all other FQDN
    --   flags are zero, standard FQDN flags are sent. This flag is
    --   incompatible with any other FQDN flag.
    | AnotherDhcpHostnameFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DhcpHostnameFlags -> ShowS
[DhcpHostnameFlags] -> ShowS
DhcpHostnameFlags -> String
(Int -> DhcpHostnameFlags -> ShowS)
-> (DhcpHostnameFlags -> String)
-> ([DhcpHostnameFlags] -> ShowS)
-> Show DhcpHostnameFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DhcpHostnameFlags -> ShowS
showsPrec :: Int -> DhcpHostnameFlags -> ShowS
$cshow :: DhcpHostnameFlags -> String
show :: DhcpHostnameFlags -> String
$cshowList :: [DhcpHostnameFlags] -> ShowS
showList :: [DhcpHostnameFlags] -> ShowS
Show, DhcpHostnameFlags -> DhcpHostnameFlags -> Bool
(DhcpHostnameFlags -> DhcpHostnameFlags -> Bool)
-> (DhcpHostnameFlags -> DhcpHostnameFlags -> Bool)
-> Eq DhcpHostnameFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DhcpHostnameFlags -> DhcpHostnameFlags -> Bool
== :: DhcpHostnameFlags -> DhcpHostnameFlags -> Bool
$c/= :: DhcpHostnameFlags -> DhcpHostnameFlags -> Bool
/= :: DhcpHostnameFlags -> DhcpHostnameFlags -> Bool
Eq)

instance P.Enum DhcpHostnameFlags where
    fromEnum :: DhcpHostnameFlags -> Int
fromEnum DhcpHostnameFlags
DhcpHostnameFlagsNone = Int
0
    fromEnum DhcpHostnameFlags
DhcpHostnameFlagsFqdnServUpdate = Int
1
    fromEnum DhcpHostnameFlags
DhcpHostnameFlagsFqdnEncoded = Int
2
    fromEnum DhcpHostnameFlags
DhcpHostnameFlagsFqdnNoUpdate = Int
4
    fromEnum DhcpHostnameFlags
DhcpHostnameFlagsFqdnClearFlags = Int
8
    fromEnum (AnotherDhcpHostnameFlags Int
k) = Int
k

    toEnum :: Int -> DhcpHostnameFlags
toEnum Int
0 = DhcpHostnameFlags
DhcpHostnameFlagsNone
    toEnum Int
1 = DhcpHostnameFlags
DhcpHostnameFlagsFqdnServUpdate
    toEnum Int
2 = DhcpHostnameFlags
DhcpHostnameFlagsFqdnEncoded
    toEnum Int
4 = DhcpHostnameFlags
DhcpHostnameFlagsFqdnNoUpdate
    toEnum Int
8 = DhcpHostnameFlags
DhcpHostnameFlagsFqdnClearFlags
    toEnum Int
k = Int -> DhcpHostnameFlags
AnotherDhcpHostnameFlags Int
k

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

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

foreign import ccall "nm_dhcp_hostname_flags_get_type" c_nm_dhcp_hostname_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DhcpHostnameFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_dhcp_hostname_flags_get_type

instance B.Types.BoxedFlags DhcpHostnameFlags

instance IsGFlag DhcpHostnameFlags

-- Flags DeviceWifiCapabilities
-- | 802.11 specific device encryption and authentication capabilities.
data DeviceWifiCapabilities = 
      DeviceWifiCapabilitiesNone
    -- ^ device has no encryption\/authentication capabilities
    | DeviceWifiCapabilitiesCipherWep40
    -- ^ device supports 40\/64-bit WEP encryption
    | DeviceWifiCapabilitiesCipherWep104
    -- ^ device supports 104\/128-bit WEP encryption
    | DeviceWifiCapabilitiesCipherTkip
    -- ^ device supports TKIP encryption
    | DeviceWifiCapabilitiesCipherCcmp
    -- ^ device supports AES\/CCMP encryption
    | DeviceWifiCapabilitiesWpa
    -- ^ device supports WPA1 authentication
    | DeviceWifiCapabilitiesRsn
    -- ^ device supports WPA2\/RSN authentication
    | DeviceWifiCapabilitiesAp
    -- ^ device supports Access Point mode
    | DeviceWifiCapabilitiesAdhoc
    -- ^ device supports Ad-Hoc mode
    | DeviceWifiCapabilitiesFreqValid
    -- ^ device reports frequency capabilities
    | DeviceWifiCapabilitiesFreq2ghz
    -- ^ device supports 2.4GHz frequencies
    | DeviceWifiCapabilitiesFreq5ghz
    -- ^ device supports 5GHz frequencies
    | DeviceWifiCapabilitiesFreq6ghz
    -- ^ device supports 6GHz frequencies. Since: 1.46.
    | DeviceWifiCapabilitiesMesh
    -- ^ device supports acting as a mesh point. Since: 1.20.
    | DeviceWifiCapabilitiesIbssRsn
    -- ^ device supports WPA2\/RSN in an IBSS network. Since: 1.22.
    | AnotherDeviceWifiCapabilities Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DeviceWifiCapabilities -> ShowS
[DeviceWifiCapabilities] -> ShowS
DeviceWifiCapabilities -> String
(Int -> DeviceWifiCapabilities -> ShowS)
-> (DeviceWifiCapabilities -> String)
-> ([DeviceWifiCapabilities] -> ShowS)
-> Show DeviceWifiCapabilities
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DeviceWifiCapabilities -> ShowS
showsPrec :: Int -> DeviceWifiCapabilities -> ShowS
$cshow :: DeviceWifiCapabilities -> String
show :: DeviceWifiCapabilities -> String
$cshowList :: [DeviceWifiCapabilities] -> ShowS
showList :: [DeviceWifiCapabilities] -> ShowS
Show, DeviceWifiCapabilities -> DeviceWifiCapabilities -> Bool
(DeviceWifiCapabilities -> DeviceWifiCapabilities -> Bool)
-> (DeviceWifiCapabilities -> DeviceWifiCapabilities -> Bool)
-> Eq DeviceWifiCapabilities
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeviceWifiCapabilities -> DeviceWifiCapabilities -> Bool
== :: DeviceWifiCapabilities -> DeviceWifiCapabilities -> Bool
$c/= :: DeviceWifiCapabilities -> DeviceWifiCapabilities -> Bool
/= :: DeviceWifiCapabilities -> DeviceWifiCapabilities -> Bool
Eq)

instance P.Enum DeviceWifiCapabilities where
    fromEnum :: DeviceWifiCapabilities -> Int
fromEnum DeviceWifiCapabilities
DeviceWifiCapabilitiesNone = Int
0
    fromEnum DeviceWifiCapabilities
DeviceWifiCapabilitiesCipherWep40 = Int
1
    fromEnum DeviceWifiCapabilities
DeviceWifiCapabilitiesCipherWep104 = Int
2
    fromEnum DeviceWifiCapabilities
DeviceWifiCapabilitiesCipherTkip = Int
4
    fromEnum DeviceWifiCapabilities
DeviceWifiCapabilitiesCipherCcmp = Int
8
    fromEnum DeviceWifiCapabilities
DeviceWifiCapabilitiesWpa = Int
16
    fromEnum DeviceWifiCapabilities
DeviceWifiCapabilitiesRsn = Int
32
    fromEnum DeviceWifiCapabilities
DeviceWifiCapabilitiesAp = Int
64
    fromEnum DeviceWifiCapabilities
DeviceWifiCapabilitiesAdhoc = Int
128
    fromEnum DeviceWifiCapabilities
DeviceWifiCapabilitiesFreqValid = Int
256
    fromEnum DeviceWifiCapabilities
DeviceWifiCapabilitiesFreq2ghz = Int
512
    fromEnum DeviceWifiCapabilities
DeviceWifiCapabilitiesFreq5ghz = Int
1024
    fromEnum DeviceWifiCapabilities
DeviceWifiCapabilitiesFreq6ghz = Int
2048
    fromEnum DeviceWifiCapabilities
DeviceWifiCapabilitiesMesh = Int
4096
    fromEnum DeviceWifiCapabilities
DeviceWifiCapabilitiesIbssRsn = Int
8192
    fromEnum (AnotherDeviceWifiCapabilities Int
k) = Int
k

    toEnum :: Int -> DeviceWifiCapabilities
toEnum Int
0 = DeviceWifiCapabilities
DeviceWifiCapabilitiesNone
    toEnum Int
1 = DeviceWifiCapabilities
DeviceWifiCapabilitiesCipherWep40
    toEnum Int
2 = DeviceWifiCapabilities
DeviceWifiCapabilitiesCipherWep104
    toEnum Int
4 = DeviceWifiCapabilities
DeviceWifiCapabilitiesCipherTkip
    toEnum Int
8 = DeviceWifiCapabilities
DeviceWifiCapabilitiesCipherCcmp
    toEnum Int
16 = DeviceWifiCapabilities
DeviceWifiCapabilitiesWpa
    toEnum Int
32 = DeviceWifiCapabilities
DeviceWifiCapabilitiesRsn
    toEnum Int
64 = DeviceWifiCapabilities
DeviceWifiCapabilitiesAp
    toEnum Int
128 = DeviceWifiCapabilities
DeviceWifiCapabilitiesAdhoc
    toEnum Int
256 = DeviceWifiCapabilities
DeviceWifiCapabilitiesFreqValid
    toEnum Int
512 = DeviceWifiCapabilities
DeviceWifiCapabilitiesFreq2ghz
    toEnum Int
1024 = DeviceWifiCapabilities
DeviceWifiCapabilitiesFreq5ghz
    toEnum Int
2048 = DeviceWifiCapabilities
DeviceWifiCapabilitiesFreq6ghz
    toEnum Int
4096 = DeviceWifiCapabilities
DeviceWifiCapabilitiesMesh
    toEnum Int
8192 = DeviceWifiCapabilities
DeviceWifiCapabilitiesIbssRsn
    toEnum Int
k = Int -> DeviceWifiCapabilities
AnotherDeviceWifiCapabilities Int
k

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

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

foreign import ccall "nm_device_wifi_capabilities_get_type" c_nm_device_wifi_capabilities_get_type :: 
    IO GType

instance B.Types.TypedObject DeviceWifiCapabilities where
    glibType :: IO GType
glibType = IO GType
c_nm_device_wifi_capabilities_get_type

instance B.Types.BoxedFlags DeviceWifiCapabilities

instance IsGFlag DeviceWifiCapabilities

-- Flags DeviceReapplyFlags
-- | Flags for the @/Reapply()/@ D-Bus call of a device and
-- 'GI.NM.Objects.Device.deviceReapplyAsync'.
-- 
-- /Since: 1.42/
data DeviceReapplyFlags = 
      DeviceReapplyFlagsNone
    -- ^ no flag set.
    | DeviceReapplyFlagsPreserveExternalIp
    -- ^ during reapply,
    --   preserve external IP addresses and routes.
    | AnotherDeviceReapplyFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DeviceReapplyFlags -> ShowS
[DeviceReapplyFlags] -> ShowS
DeviceReapplyFlags -> String
(Int -> DeviceReapplyFlags -> ShowS)
-> (DeviceReapplyFlags -> String)
-> ([DeviceReapplyFlags] -> ShowS)
-> Show DeviceReapplyFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DeviceReapplyFlags -> ShowS
showsPrec :: Int -> DeviceReapplyFlags -> ShowS
$cshow :: DeviceReapplyFlags -> String
show :: DeviceReapplyFlags -> String
$cshowList :: [DeviceReapplyFlags] -> ShowS
showList :: [DeviceReapplyFlags] -> ShowS
Show, DeviceReapplyFlags -> DeviceReapplyFlags -> Bool
(DeviceReapplyFlags -> DeviceReapplyFlags -> Bool)
-> (DeviceReapplyFlags -> DeviceReapplyFlags -> Bool)
-> Eq DeviceReapplyFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeviceReapplyFlags -> DeviceReapplyFlags -> Bool
== :: DeviceReapplyFlags -> DeviceReapplyFlags -> Bool
$c/= :: DeviceReapplyFlags -> DeviceReapplyFlags -> Bool
/= :: DeviceReapplyFlags -> DeviceReapplyFlags -> Bool
Eq)

instance P.Enum DeviceReapplyFlags where
    fromEnum :: DeviceReapplyFlags -> Int
fromEnum DeviceReapplyFlags
DeviceReapplyFlagsNone = Int
0
    fromEnum DeviceReapplyFlags
DeviceReapplyFlagsPreserveExternalIp = Int
1
    fromEnum (AnotherDeviceReapplyFlags Int
k) = Int
k

    toEnum :: Int -> DeviceReapplyFlags
toEnum Int
0 = DeviceReapplyFlags
DeviceReapplyFlagsNone
    toEnum Int
1 = DeviceReapplyFlags
DeviceReapplyFlagsPreserveExternalIp
    toEnum Int
k = Int -> DeviceReapplyFlags
AnotherDeviceReapplyFlags Int
k

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

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

foreign import ccall "nm_device_reapply_flags_get_type" c_nm_device_reapply_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DeviceReapplyFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_device_reapply_flags_get_type

instance B.Types.BoxedFlags DeviceReapplyFlags

instance IsGFlag DeviceReapplyFlags

-- Flags DeviceModemCapabilities
-- | t'GI.NM.Flags.DeviceModemCapabilities' values indicate the generic radio access
-- technology families a modem device supports.  For more information on the
-- specific access technologies the device supports use the ModemManager D-Bus
-- API.
data DeviceModemCapabilities = 
      DeviceModemCapabilitiesNone
    -- ^ modem has no usable capabilities
    | DeviceModemCapabilitiesPots
    -- ^ modem uses the analog wired telephone
    -- network and is not a wireless\/cellular device
    | DeviceModemCapabilitiesCdmaEvdo
    -- ^ modem supports at least one of CDMA
    -- 1xRTT, EVDO revision 0, EVDO revision A, or EVDO revision B
    | DeviceModemCapabilitiesGsmUmts
    -- ^ modem supports at least one of GSM,
    -- GPRS, EDGE, UMTS, HSDPA, HSUPA, or HSPA+ packet switched data capability
    | DeviceModemCapabilitiesLte
    -- ^ modem has LTE data capability
    | DeviceModemCapabilities5gnr
    -- ^ modem has 5GNR data capability. Since: 1.36.
    | AnotherDeviceModemCapabilities Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DeviceModemCapabilities -> ShowS
[DeviceModemCapabilities] -> ShowS
DeviceModemCapabilities -> String
(Int -> DeviceModemCapabilities -> ShowS)
-> (DeviceModemCapabilities -> String)
-> ([DeviceModemCapabilities] -> ShowS)
-> Show DeviceModemCapabilities
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DeviceModemCapabilities -> ShowS
showsPrec :: Int -> DeviceModemCapabilities -> ShowS
$cshow :: DeviceModemCapabilities -> String
show :: DeviceModemCapabilities -> String
$cshowList :: [DeviceModemCapabilities] -> ShowS
showList :: [DeviceModemCapabilities] -> ShowS
Show, DeviceModemCapabilities -> DeviceModemCapabilities -> Bool
(DeviceModemCapabilities -> DeviceModemCapabilities -> Bool)
-> (DeviceModemCapabilities -> DeviceModemCapabilities -> Bool)
-> Eq DeviceModemCapabilities
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeviceModemCapabilities -> DeviceModemCapabilities -> Bool
== :: DeviceModemCapabilities -> DeviceModemCapabilities -> Bool
$c/= :: DeviceModemCapabilities -> DeviceModemCapabilities -> Bool
/= :: DeviceModemCapabilities -> DeviceModemCapabilities -> Bool
Eq)

instance P.Enum DeviceModemCapabilities where
    fromEnum :: DeviceModemCapabilities -> Int
fromEnum DeviceModemCapabilities
DeviceModemCapabilitiesNone = Int
0
    fromEnum DeviceModemCapabilities
DeviceModemCapabilitiesPots = Int
1
    fromEnum DeviceModemCapabilities
DeviceModemCapabilitiesCdmaEvdo = Int
2
    fromEnum DeviceModemCapabilities
DeviceModemCapabilitiesGsmUmts = Int
4
    fromEnum DeviceModemCapabilities
DeviceModemCapabilitiesLte = Int
8
    fromEnum DeviceModemCapabilities
DeviceModemCapabilities5gnr = Int
64
    fromEnum (AnotherDeviceModemCapabilities Int
k) = Int
k

    toEnum :: Int -> DeviceModemCapabilities
toEnum Int
0 = DeviceModemCapabilities
DeviceModemCapabilitiesNone
    toEnum Int
1 = DeviceModemCapabilities
DeviceModemCapabilitiesPots
    toEnum Int
2 = DeviceModemCapabilities
DeviceModemCapabilitiesCdmaEvdo
    toEnum Int
4 = DeviceModemCapabilities
DeviceModemCapabilitiesGsmUmts
    toEnum Int
8 = DeviceModemCapabilities
DeviceModemCapabilitiesLte
    toEnum Int
64 = DeviceModemCapabilities
DeviceModemCapabilities5gnr
    toEnum Int
k = Int -> DeviceModemCapabilities
AnotherDeviceModemCapabilities Int
k

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

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

foreign import ccall "nm_device_modem_capabilities_get_type" c_nm_device_modem_capabilities_get_type :: 
    IO GType

instance B.Types.TypedObject DeviceModemCapabilities where
    glibType :: IO GType
glibType = IO GType
c_nm_device_modem_capabilities_get_type

instance B.Types.BoxedFlags DeviceModemCapabilities

instance IsGFlag DeviceModemCapabilities

-- Flags DeviceInterfaceFlags
-- | Flags for a network interface.
-- 
-- /Since: 1.22/
data DeviceInterfaceFlags = 
      DeviceInterfaceFlagsUp
    -- ^ the interface is enabled from the
    --   administrative point of view. Corresponds to kernel IFF_UP.
    | DeviceInterfaceFlagsLowerUp
    -- ^ the physical link is up. Corresponds
    --   to kernel IFF_LOWER_UP.
    | DeviceInterfaceFlagsPromisc
    -- ^ receive all packets. Corresponds to
    --   kernel IFF_PROMISC. Since: 1.32.
    | DeviceInterfaceFlagsCarrier
    -- ^ the interface has carrier. In most
    --   cases this is equal to the value of /@nMDEVICEINTERFACEFLAGLOWERUP@/.
    --   However some devices have a non-standard carrier detection mechanism.
    | DeviceInterfaceFlagsLldpClientEnabled
    -- ^ the flag to indicate device
    --   LLDP status. Since: 1.32.
    | AnotherDeviceInterfaceFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DeviceInterfaceFlags -> ShowS
[DeviceInterfaceFlags] -> ShowS
DeviceInterfaceFlags -> String
(Int -> DeviceInterfaceFlags -> ShowS)
-> (DeviceInterfaceFlags -> String)
-> ([DeviceInterfaceFlags] -> ShowS)
-> Show DeviceInterfaceFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DeviceInterfaceFlags -> ShowS
showsPrec :: Int -> DeviceInterfaceFlags -> ShowS
$cshow :: DeviceInterfaceFlags -> String
show :: DeviceInterfaceFlags -> String
$cshowList :: [DeviceInterfaceFlags] -> ShowS
showList :: [DeviceInterfaceFlags] -> ShowS
Show, DeviceInterfaceFlags -> DeviceInterfaceFlags -> Bool
(DeviceInterfaceFlags -> DeviceInterfaceFlags -> Bool)
-> (DeviceInterfaceFlags -> DeviceInterfaceFlags -> Bool)
-> Eq DeviceInterfaceFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeviceInterfaceFlags -> DeviceInterfaceFlags -> Bool
== :: DeviceInterfaceFlags -> DeviceInterfaceFlags -> Bool
$c/= :: DeviceInterfaceFlags -> DeviceInterfaceFlags -> Bool
/= :: DeviceInterfaceFlags -> DeviceInterfaceFlags -> Bool
Eq)

instance P.Enum DeviceInterfaceFlags where
    fromEnum :: DeviceInterfaceFlags -> Int
fromEnum DeviceInterfaceFlags
DeviceInterfaceFlagsUp = Int
1
    fromEnum DeviceInterfaceFlags
DeviceInterfaceFlagsLowerUp = Int
2
    fromEnum DeviceInterfaceFlags
DeviceInterfaceFlagsPromisc = Int
4
    fromEnum DeviceInterfaceFlags
DeviceInterfaceFlagsCarrier = Int
65536
    fromEnum DeviceInterfaceFlags
DeviceInterfaceFlagsLldpClientEnabled = Int
131072
    fromEnum (AnotherDeviceInterfaceFlags Int
k) = Int
k

    toEnum :: Int -> DeviceInterfaceFlags
toEnum Int
1 = DeviceInterfaceFlags
DeviceInterfaceFlagsUp
    toEnum Int
2 = DeviceInterfaceFlags
DeviceInterfaceFlagsLowerUp
    toEnum Int
4 = DeviceInterfaceFlags
DeviceInterfaceFlagsPromisc
    toEnum Int
65536 = DeviceInterfaceFlags
DeviceInterfaceFlagsCarrier
    toEnum Int
131072 = DeviceInterfaceFlags
DeviceInterfaceFlagsLldpClientEnabled
    toEnum Int
k = Int -> DeviceInterfaceFlags
AnotherDeviceInterfaceFlags Int
k

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

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

foreign import ccall "nm_device_interface_flags_get_type" c_nm_device_interface_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DeviceInterfaceFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_device_interface_flags_get_type

instance B.Types.BoxedFlags DeviceInterfaceFlags

instance IsGFlag DeviceInterfaceFlags

-- Flags DeviceCapabilities
-- | General device capability flags.
data DeviceCapabilities = 
      DeviceCapabilitiesNone
    -- ^ device has no special capabilities
    | DeviceCapabilitiesNmSupported
    -- ^ NetworkManager supports this device
    | DeviceCapabilitiesCarrierDetect
    -- ^ this device can indicate carrier status
    | DeviceCapabilitiesIsSoftware
    -- ^ this device is a software device
    | DeviceCapabilitiesSriov
    -- ^ this device supports single-root I\/O virtualization
    | AnotherDeviceCapabilities Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DeviceCapabilities -> ShowS
[DeviceCapabilities] -> ShowS
DeviceCapabilities -> String
(Int -> DeviceCapabilities -> ShowS)
-> (DeviceCapabilities -> String)
-> ([DeviceCapabilities] -> ShowS)
-> Show DeviceCapabilities
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DeviceCapabilities -> ShowS
showsPrec :: Int -> DeviceCapabilities -> ShowS
$cshow :: DeviceCapabilities -> String
show :: DeviceCapabilities -> String
$cshowList :: [DeviceCapabilities] -> ShowS
showList :: [DeviceCapabilities] -> ShowS
Show, DeviceCapabilities -> DeviceCapabilities -> Bool
(DeviceCapabilities -> DeviceCapabilities -> Bool)
-> (DeviceCapabilities -> DeviceCapabilities -> Bool)
-> Eq DeviceCapabilities
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeviceCapabilities -> DeviceCapabilities -> Bool
== :: DeviceCapabilities -> DeviceCapabilities -> Bool
$c/= :: DeviceCapabilities -> DeviceCapabilities -> Bool
/= :: DeviceCapabilities -> DeviceCapabilities -> Bool
Eq)

instance P.Enum DeviceCapabilities where
    fromEnum :: DeviceCapabilities -> Int
fromEnum DeviceCapabilities
DeviceCapabilitiesNone = Int
0
    fromEnum DeviceCapabilities
DeviceCapabilitiesNmSupported = Int
1
    fromEnum DeviceCapabilities
DeviceCapabilitiesCarrierDetect = Int
2
    fromEnum DeviceCapabilities
DeviceCapabilitiesIsSoftware = Int
4
    fromEnum DeviceCapabilities
DeviceCapabilitiesSriov = Int
8
    fromEnum (AnotherDeviceCapabilities Int
k) = Int
k

    toEnum :: Int -> DeviceCapabilities
toEnum Int
0 = DeviceCapabilities
DeviceCapabilitiesNone
    toEnum Int
1 = DeviceCapabilities
DeviceCapabilitiesNmSupported
    toEnum Int
2 = DeviceCapabilities
DeviceCapabilitiesCarrierDetect
    toEnum Int
4 = DeviceCapabilities
DeviceCapabilitiesIsSoftware
    toEnum Int
8 = DeviceCapabilities
DeviceCapabilitiesSriov
    toEnum Int
k = Int -> DeviceCapabilities
AnotherDeviceCapabilities Int
k

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

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

foreign import ccall "nm_device_capabilities_get_type" c_nm_device_capabilities_get_type :: 
    IO GType

instance B.Types.TypedObject DeviceCapabilities where
    glibType :: IO GType
glibType = IO GType
c_nm_device_capabilities_get_type

instance B.Types.BoxedFlags DeviceCapabilities

instance IsGFlag DeviceCapabilities

-- Flags ConnectionSerializationFlags
-- | These flags determine which properties are serialized when calling
-- 'GI.NM.Interfaces.Connection.connectionToDbus'.
data ConnectionSerializationFlags = 
      ConnectionSerializationFlagsAll
    -- ^ serialize all properties (including secrets)
    | ConnectionSerializationFlagsWithNonSecret
    -- ^ serialize properties that are
    --   not secrets. Since 1.32.
    | ConnectionSerializationFlagsNoSecrets
    -- ^ this is a deprecated alias for
    --   /@nMCONNECTIONSERIALIZEWITHNONSECRET@/.
    | ConnectionSerializationFlagsWithSecrets
    -- ^ serialize all secrets. This flag is
    --   ignored if any of /@nMCONNECTIONSERIALIZEWITHSECRETSAGENTOWNED@/,
    --   /@nMCONNECTIONSERIALIZEWITHSECRETSSYSTEMOWNED@/ or
    --   /@nMCONNECTIONSERIALIZEWITHSECRETSNOTSAVED@/ is set. Since 1.32.
    | ConnectionSerializationFlagsOnlySecrets
    -- ^ a deprecated alias for
    --   /@nMCONNECTIONSERIALIZEWITHSECRETS@/.
    | ConnectionSerializationFlagsWithSecretsAgentOwned
    -- ^ serialize agent-owned
    --   secrets. Since: 1.20.
    | ConnectionSerializationFlagsWithSecretsSystemOwned
    -- ^ serialize system-owned
    --   secrets. Since: 1.32.
    | ConnectionSerializationFlagsWithSecretsNotSaved
    -- ^ serialize secrets that
    --   are marked as never saved. Since: 1.32.
    | AnotherConnectionSerializationFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ConnectionSerializationFlags -> ShowS
[ConnectionSerializationFlags] -> ShowS
ConnectionSerializationFlags -> String
(Int -> ConnectionSerializationFlags -> ShowS)
-> (ConnectionSerializationFlags -> String)
-> ([ConnectionSerializationFlags] -> ShowS)
-> Show ConnectionSerializationFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ConnectionSerializationFlags -> ShowS
showsPrec :: Int -> ConnectionSerializationFlags -> ShowS
$cshow :: ConnectionSerializationFlags -> String
show :: ConnectionSerializationFlags -> String
$cshowList :: [ConnectionSerializationFlags] -> ShowS
showList :: [ConnectionSerializationFlags] -> ShowS
Show, ConnectionSerializationFlags
-> ConnectionSerializationFlags -> Bool
(ConnectionSerializationFlags
 -> ConnectionSerializationFlags -> Bool)
-> (ConnectionSerializationFlags
    -> ConnectionSerializationFlags -> Bool)
-> Eq ConnectionSerializationFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConnectionSerializationFlags
-> ConnectionSerializationFlags -> Bool
== :: ConnectionSerializationFlags
-> ConnectionSerializationFlags -> Bool
$c/= :: ConnectionSerializationFlags
-> ConnectionSerializationFlags -> Bool
/= :: ConnectionSerializationFlags
-> ConnectionSerializationFlags -> Bool
Eq)

instance P.Enum ConnectionSerializationFlags where
    fromEnum :: ConnectionSerializationFlags -> Int
fromEnum ConnectionSerializationFlags
ConnectionSerializationFlagsAll = Int
0
    fromEnum ConnectionSerializationFlags
ConnectionSerializationFlagsWithNonSecret = Int
1
    fromEnum ConnectionSerializationFlags
ConnectionSerializationFlagsNoSecrets = Int
1
    fromEnum ConnectionSerializationFlags
ConnectionSerializationFlagsWithSecrets = Int
2
    fromEnum ConnectionSerializationFlags
ConnectionSerializationFlagsOnlySecrets = Int
2
    fromEnum ConnectionSerializationFlags
ConnectionSerializationFlagsWithSecretsAgentOwned = Int
4
    fromEnum ConnectionSerializationFlags
ConnectionSerializationFlagsWithSecretsSystemOwned = Int
8
    fromEnum ConnectionSerializationFlags
ConnectionSerializationFlagsWithSecretsNotSaved = Int
16
    fromEnum (AnotherConnectionSerializationFlags Int
k) = Int
k

    toEnum :: Int -> ConnectionSerializationFlags
toEnum Int
0 = ConnectionSerializationFlags
ConnectionSerializationFlagsAll
    toEnum Int
1 = ConnectionSerializationFlags
ConnectionSerializationFlagsWithNonSecret
    toEnum Int
2 = ConnectionSerializationFlags
ConnectionSerializationFlagsWithSecrets
    toEnum Int
4 = ConnectionSerializationFlags
ConnectionSerializationFlagsWithSecretsAgentOwned
    toEnum Int
8 = ConnectionSerializationFlags
ConnectionSerializationFlagsWithSecretsSystemOwned
    toEnum Int
16 = ConnectionSerializationFlags
ConnectionSerializationFlagsWithSecretsNotSaved
    toEnum Int
k = Int -> ConnectionSerializationFlags
AnotherConnectionSerializationFlags Int
k

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

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

foreign import ccall "nm_connection_serialization_flags_get_type" c_nm_connection_serialization_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ConnectionSerializationFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_connection_serialization_flags_get_type

instance B.Types.BoxedFlags ConnectionSerializationFlags

instance IsGFlag ConnectionSerializationFlags

-- Flags ClientInstanceFlags
-- | /No description available in the introspection data./
-- 
-- /Since: 1.24/
data ClientInstanceFlags = 
      ClientInstanceFlagsNone
    -- ^ special value to indicate no flags.
    | ClientInstanceFlagsNoAutoFetchPermissions
    -- ^ by default, NMClient
    --   will fetch the permissions via \"GetPermissions\" and refetch them when
    --   \"CheckPermissions\" signal gets received. By setting this flag, this behavior
    --   can be disabled. You can toggle this flag to enable and disable automatic
    --   fetching of the permissions. Watch also 'GI.NM.Objects.Client.clientGetPermissionsState'
    --   to know whether the permissions are up to date.
    | ClientInstanceFlagsInitializedGood
    -- ^ as t'GI.NM.Objects.Client.Client' is an GInitable
    --   and GAsyncInitable, 'GI.NM.Objects.Client.clientGetInstanceFlags' returns this flag
    --   once initialization completed with success. This flag cannot be set
    --   as NM_CLIENT_INSTANCE_FLAGS property. Since: 1.42.
    | ClientInstanceFlagsInitializedBad
    -- ^ like /@nMCLIENTINSTANCEFLAGSINITIALIZEDGOOD@/
    --   indicates that the instance completed initialization with failure. In that
    --   case the instance is unusable. Since: 1.42.
    | AnotherClientInstanceFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ClientInstanceFlags -> ShowS
[ClientInstanceFlags] -> ShowS
ClientInstanceFlags -> String
(Int -> ClientInstanceFlags -> ShowS)
-> (ClientInstanceFlags -> String)
-> ([ClientInstanceFlags] -> ShowS)
-> Show ClientInstanceFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClientInstanceFlags -> ShowS
showsPrec :: Int -> ClientInstanceFlags -> ShowS
$cshow :: ClientInstanceFlags -> String
show :: ClientInstanceFlags -> String
$cshowList :: [ClientInstanceFlags] -> ShowS
showList :: [ClientInstanceFlags] -> ShowS
Show, ClientInstanceFlags -> ClientInstanceFlags -> Bool
(ClientInstanceFlags -> ClientInstanceFlags -> Bool)
-> (ClientInstanceFlags -> ClientInstanceFlags -> Bool)
-> Eq ClientInstanceFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClientInstanceFlags -> ClientInstanceFlags -> Bool
== :: ClientInstanceFlags -> ClientInstanceFlags -> Bool
$c/= :: ClientInstanceFlags -> ClientInstanceFlags -> Bool
/= :: ClientInstanceFlags -> ClientInstanceFlags -> Bool
Eq)

instance P.Enum ClientInstanceFlags where
    fromEnum :: ClientInstanceFlags -> Int
fromEnum ClientInstanceFlags
ClientInstanceFlagsNone = Int
0
    fromEnum ClientInstanceFlags
ClientInstanceFlagsNoAutoFetchPermissions = Int
1
    fromEnum ClientInstanceFlags
ClientInstanceFlagsInitializedGood = Int
2
    fromEnum ClientInstanceFlags
ClientInstanceFlagsInitializedBad = Int
4
    fromEnum (AnotherClientInstanceFlags Int
k) = Int
k

    toEnum :: Int -> ClientInstanceFlags
toEnum Int
0 = ClientInstanceFlags
ClientInstanceFlagsNone
    toEnum Int
1 = ClientInstanceFlags
ClientInstanceFlagsNoAutoFetchPermissions
    toEnum Int
2 = ClientInstanceFlags
ClientInstanceFlagsInitializedGood
    toEnum Int
4 = ClientInstanceFlags
ClientInstanceFlagsInitializedBad
    toEnum Int
k = Int -> ClientInstanceFlags
AnotherClientInstanceFlags Int
k

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

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

foreign import ccall "nm_client_instance_flags_get_type" c_nm_client_instance_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ClientInstanceFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_client_instance_flags_get_type

instance B.Types.BoxedFlags ClientInstanceFlags

instance IsGFlag ClientInstanceFlags

-- Flags CheckpointCreateFlags
-- | The flags for CheckpointCreate call
-- 
-- /Since: 1.12/
data CheckpointCreateFlags = 
      CheckpointCreateFlagsNone
    -- ^ no flags
    | CheckpointCreateFlagsDestroyAll
    -- ^ when creating
    --   a new checkpoint, destroy all existing ones.
    | CheckpointCreateFlagsDeleteNewConnections
    -- ^ upon rollback,
    --   delete any new connection added after the checkpoint. Since: 1.6.
    | CheckpointCreateFlagsDisconnectNewDevices
    -- ^ upon rollback,
    --   disconnect any new device appeared after the checkpoint. Since: 1.6.
    | CheckpointCreateFlagsAllowOverlapping
    -- ^ by default, creating
    --   a checkpoint fails if there are already existing checkpoints that
    --   reference the same devices. With this flag, creation of such
    --   checkpoints is allowed, however, if an older checkpoint
    --   that references overlapping devices gets rolled back, it will
    --   automatically destroy this checkpoint during rollback. This
    --   allows to create several overlapping checkpoints in parallel,
    --   and rollback to them at will. With the special case that
    --   rolling back to an older checkpoint will invalidate all
    --   overlapping younger checkpoints. This opts-in that the
    --   checkpoint can be automatically destroyed by the rollback
    --   of an older checkpoint. Since: 1.12.
    | CheckpointCreateFlagsNoPreserveExternalPorts
    -- ^ during rollback,
    --   by default externally added ports attached to bridge devices are preserved.
    --   With this flag, the rollback detaches all external ports.
    --   This only has an effect for bridge ports. Before 1.38, this was the default
    --   behavior. Since: 1.38.
    | CheckpointCreateFlagsTrackInternalGlobalDns
    -- ^ during rollback,
    --   by default changes to global DNS via D-BUS interface are preserved.
    --   With this flag, the rollback reverts the global DNS changes made via D-Bus
    --   interface. Global DNS defined in [global-dns] section of
    --   NetworkManager.conf is not impacted by this flag. Since: 1.48.
    | AnotherCheckpointCreateFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CheckpointCreateFlags -> ShowS
[CheckpointCreateFlags] -> ShowS
CheckpointCreateFlags -> String
(Int -> CheckpointCreateFlags -> ShowS)
-> (CheckpointCreateFlags -> String)
-> ([CheckpointCreateFlags] -> ShowS)
-> Show CheckpointCreateFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CheckpointCreateFlags -> ShowS
showsPrec :: Int -> CheckpointCreateFlags -> ShowS
$cshow :: CheckpointCreateFlags -> String
show :: CheckpointCreateFlags -> String
$cshowList :: [CheckpointCreateFlags] -> ShowS
showList :: [CheckpointCreateFlags] -> ShowS
Show, CheckpointCreateFlags -> CheckpointCreateFlags -> Bool
(CheckpointCreateFlags -> CheckpointCreateFlags -> Bool)
-> (CheckpointCreateFlags -> CheckpointCreateFlags -> Bool)
-> Eq CheckpointCreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CheckpointCreateFlags -> CheckpointCreateFlags -> Bool
== :: CheckpointCreateFlags -> CheckpointCreateFlags -> Bool
$c/= :: CheckpointCreateFlags -> CheckpointCreateFlags -> Bool
/= :: CheckpointCreateFlags -> CheckpointCreateFlags -> Bool
Eq)

instance P.Enum CheckpointCreateFlags where
    fromEnum :: CheckpointCreateFlags -> Int
fromEnum CheckpointCreateFlags
CheckpointCreateFlagsNone = Int
0
    fromEnum CheckpointCreateFlags
CheckpointCreateFlagsDestroyAll = Int
1
    fromEnum CheckpointCreateFlags
CheckpointCreateFlagsDeleteNewConnections = Int
2
    fromEnum CheckpointCreateFlags
CheckpointCreateFlagsDisconnectNewDevices = Int
4
    fromEnum CheckpointCreateFlags
CheckpointCreateFlagsAllowOverlapping = Int
8
    fromEnum CheckpointCreateFlags
CheckpointCreateFlagsNoPreserveExternalPorts = Int
16
    fromEnum CheckpointCreateFlags
CheckpointCreateFlagsTrackInternalGlobalDns = Int
32
    fromEnum (AnotherCheckpointCreateFlags Int
k) = Int
k

    toEnum :: Int -> CheckpointCreateFlags
toEnum Int
0 = CheckpointCreateFlags
CheckpointCreateFlagsNone
    toEnum Int
1 = CheckpointCreateFlags
CheckpointCreateFlagsDestroyAll
    toEnum Int
2 = CheckpointCreateFlags
CheckpointCreateFlagsDeleteNewConnections
    toEnum Int
4 = CheckpointCreateFlags
CheckpointCreateFlagsDisconnectNewDevices
    toEnum Int
8 = CheckpointCreateFlags
CheckpointCreateFlagsAllowOverlapping
    toEnum Int
16 = CheckpointCreateFlags
CheckpointCreateFlagsNoPreserveExternalPorts
    toEnum Int
32 = CheckpointCreateFlags
CheckpointCreateFlagsTrackInternalGlobalDns
    toEnum Int
k = Int -> CheckpointCreateFlags
AnotherCheckpointCreateFlags Int
k

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

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

foreign import ccall "nm_checkpoint_create_flags_get_type" c_nm_checkpoint_create_flags_get_type :: 
    IO GType

instance B.Types.TypedObject CheckpointCreateFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_checkpoint_create_flags_get_type

instance B.Types.BoxedFlags CheckpointCreateFlags

instance IsGFlag CheckpointCreateFlags

-- Flags BluetoothCapabilities
-- | t'GI.NM.Flags.BluetoothCapabilities' values indicate the usable capabilities of a
-- Bluetooth device.
data BluetoothCapabilities = 
      BluetoothCapabilitiesNone
    -- ^ device has no usable capabilities
    | BluetoothCapabilitiesDun
    -- ^ device provides Dial-Up Networking capability
    | BluetoothCapabilitiesNap
    -- ^ device provides Network Access Point capability
    | AnotherBluetoothCapabilities Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BluetoothCapabilities -> ShowS
[BluetoothCapabilities] -> ShowS
BluetoothCapabilities -> String
(Int -> BluetoothCapabilities -> ShowS)
-> (BluetoothCapabilities -> String)
-> ([BluetoothCapabilities] -> ShowS)
-> Show BluetoothCapabilities
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BluetoothCapabilities -> ShowS
showsPrec :: Int -> BluetoothCapabilities -> ShowS
$cshow :: BluetoothCapabilities -> String
show :: BluetoothCapabilities -> String
$cshowList :: [BluetoothCapabilities] -> ShowS
showList :: [BluetoothCapabilities] -> ShowS
Show, BluetoothCapabilities -> BluetoothCapabilities -> Bool
(BluetoothCapabilities -> BluetoothCapabilities -> Bool)
-> (BluetoothCapabilities -> BluetoothCapabilities -> Bool)
-> Eq BluetoothCapabilities
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BluetoothCapabilities -> BluetoothCapabilities -> Bool
== :: BluetoothCapabilities -> BluetoothCapabilities -> Bool
$c/= :: BluetoothCapabilities -> BluetoothCapabilities -> Bool
/= :: BluetoothCapabilities -> BluetoothCapabilities -> Bool
Eq)

instance P.Enum BluetoothCapabilities where
    fromEnum :: BluetoothCapabilities -> Int
fromEnum BluetoothCapabilities
BluetoothCapabilitiesNone = Int
0
    fromEnum BluetoothCapabilities
BluetoothCapabilitiesDun = Int
1
    fromEnum BluetoothCapabilities
BluetoothCapabilitiesNap = Int
2
    fromEnum (AnotherBluetoothCapabilities Int
k) = Int
k

    toEnum :: Int -> BluetoothCapabilities
toEnum Int
0 = BluetoothCapabilities
BluetoothCapabilitiesNone
    toEnum Int
1 = BluetoothCapabilities
BluetoothCapabilitiesDun
    toEnum Int
2 = BluetoothCapabilities
BluetoothCapabilitiesNap
    toEnum Int
k = Int -> BluetoothCapabilities
AnotherBluetoothCapabilities Int
k

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

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

foreign import ccall "nm_bluetooth_capabilities_get_type" c_nm_bluetooth_capabilities_get_type :: 
    IO GType

instance B.Types.TypedObject BluetoothCapabilities where
    glibType :: IO GType
glibType = IO GType
c_nm_bluetooth_capabilities_get_type

instance B.Types.BoxedFlags BluetoothCapabilities

instance IsGFlag BluetoothCapabilities

-- Flags ActivationStateFlags
-- | Flags describing the current activation state.
-- 
-- /Since: 1.10/
data ActivationStateFlags = 
      ActivationStateFlagsNone
    -- ^ an alias for numeric zero, no flags set.
    | ActivationStateFlagsIsController
    -- ^ the device is a controller.
    | ActivationStateFlagsIsPort
    -- ^ the device is a port.
    | ActivationStateFlagsLayer2Ready
    -- ^ layer2 is activated and ready.
    | ActivationStateFlagsIp4Ready
    -- ^ IPv4 setting is completed.
    | ActivationStateFlagsIp6Ready
    -- ^ IPv6 setting is completed.
    | ActivationStateFlagsControllerHasPorts
    -- ^ The controller has any port devices attached.
    --   This only makes sense if the device is a controller.
    | ActivationStateFlagsLifetimeBoundToProfileVisibility
    -- ^ the lifetime
    --   of the activation is bound to the visibility of the connection profile,
    --   which in turn depends on \"connection.permissions\" and whether a session
    --   for the user exists. Since: 1.16.
    | ActivationStateFlagsExternal
    -- ^ the active connection was generated to
    --  represent an external configuration of a networking device. Since: 1.26.
    | AnotherActivationStateFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ActivationStateFlags -> ShowS
[ActivationStateFlags] -> ShowS
ActivationStateFlags -> String
(Int -> ActivationStateFlags -> ShowS)
-> (ActivationStateFlags -> String)
-> ([ActivationStateFlags] -> ShowS)
-> Show ActivationStateFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ActivationStateFlags -> ShowS
showsPrec :: Int -> ActivationStateFlags -> ShowS
$cshow :: ActivationStateFlags -> String
show :: ActivationStateFlags -> String
$cshowList :: [ActivationStateFlags] -> ShowS
showList :: [ActivationStateFlags] -> ShowS
Show, ActivationStateFlags -> ActivationStateFlags -> Bool
(ActivationStateFlags -> ActivationStateFlags -> Bool)
-> (ActivationStateFlags -> ActivationStateFlags -> Bool)
-> Eq ActivationStateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ActivationStateFlags -> ActivationStateFlags -> Bool
== :: ActivationStateFlags -> ActivationStateFlags -> Bool
$c/= :: ActivationStateFlags -> ActivationStateFlags -> Bool
/= :: ActivationStateFlags -> ActivationStateFlags -> Bool
Eq)

instance P.Enum ActivationStateFlags where
    fromEnum :: ActivationStateFlags -> Int
fromEnum ActivationStateFlags
ActivationStateFlagsNone = Int
0
    fromEnum ActivationStateFlags
ActivationStateFlagsIsController = Int
1
    fromEnum ActivationStateFlags
ActivationStateFlagsIsPort = Int
2
    fromEnum ActivationStateFlags
ActivationStateFlagsLayer2Ready = Int
4
    fromEnum ActivationStateFlags
ActivationStateFlagsIp4Ready = Int
8
    fromEnum ActivationStateFlags
ActivationStateFlagsIp6Ready = Int
16
    fromEnum ActivationStateFlags
ActivationStateFlagsControllerHasPorts = Int
32
    fromEnum ActivationStateFlags
ActivationStateFlagsLifetimeBoundToProfileVisibility = Int
64
    fromEnum ActivationStateFlags
ActivationStateFlagsExternal = Int
128
    fromEnum (AnotherActivationStateFlags Int
k) = Int
k

    toEnum :: Int -> ActivationStateFlags
toEnum Int
0 = ActivationStateFlags
ActivationStateFlagsNone
    toEnum Int
1 = ActivationStateFlags
ActivationStateFlagsIsController
    toEnum Int
2 = ActivationStateFlags
ActivationStateFlagsIsPort
    toEnum Int
4 = ActivationStateFlags
ActivationStateFlagsLayer2Ready
    toEnum Int
8 = ActivationStateFlags
ActivationStateFlagsIp4Ready
    toEnum Int
16 = ActivationStateFlags
ActivationStateFlagsIp6Ready
    toEnum Int
32 = ActivationStateFlags
ActivationStateFlagsControllerHasPorts
    toEnum Int
64 = ActivationStateFlags
ActivationStateFlagsLifetimeBoundToProfileVisibility
    toEnum Int
128 = ActivationStateFlags
ActivationStateFlagsExternal
    toEnum Int
k = Int -> ActivationStateFlags
AnotherActivationStateFlags Int
k

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

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

foreign import ccall "nm_activation_state_flags_get_type" c_nm_activation_state_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ActivationStateFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_activation_state_flags_get_type

instance B.Types.BoxedFlags ActivationStateFlags

instance IsGFlag ActivationStateFlags

-- Flags 80211ApSecurityFlags
-- | 802.11 access point security and authentication flags.  These flags describe
-- the current security requirements of an access point as determined from the
-- access point\'s beacon.
data NM80211ApSecurityFlags = 
      NM80211ApSecurityFlagsNone
    -- ^ the access point has no special security requirements
    | NM80211ApSecurityFlagsPairWep40
    -- ^ 40\/64-bit WEP is supported for
    -- pairwise\/unicast encryption
    | NM80211ApSecurityFlagsPairWep104
    -- ^ 104\/128-bit WEP is supported for
    -- pairwise\/unicast encryption
    | NM80211ApSecurityFlagsPairTkip
    -- ^ TKIP is supported for pairwise\/unicast encryption
    | NM80211ApSecurityFlagsPairCcmp
    -- ^ AES\/CCMP is supported for pairwise\/unicast encryption
    | NM80211ApSecurityFlagsGroupWep40
    -- ^ 40\/64-bit WEP is supported for group\/broadcast
    -- encryption
    | NM80211ApSecurityFlagsGroupWep104
    -- ^ 104\/128-bit WEP is supported for
    -- group\/broadcast encryption
    | NM80211ApSecurityFlagsGroupTkip
    -- ^ TKIP is supported for group\/broadcast encryption
    | NM80211ApSecurityFlagsGroupCcmp
    -- ^ AES\/CCMP is supported for group\/broadcast
    -- encryption
    | NM80211ApSecurityFlagsKeyMgmtPsk
    -- ^ WPA\/RSN Pre-Shared Key encryption is
    -- supported
    | NM80211ApSecurityFlagsKeyMgmt8021x
    -- ^ 802.1x authentication and key management
    -- is supported
    | NM80211ApSecurityFlagsKeyMgmtSae
    -- ^ WPA\/RSN Simultaneous Authentication of Equals is
    -- supported
    | NM80211ApSecurityFlagsKeyMgmtOwe
    -- ^ WPA\/RSN Opportunistic Wireless Encryption is
    -- supported
    | NM80211ApSecurityFlagsKeyMgmtOweTm
    -- ^ WPA\/RSN Opportunistic Wireless Encryption
    -- transition mode is supported. Since: 1.26.
    | NM80211ApSecurityFlagsKeyMgmtEapSuiteB192
    -- ^ WPA3 Enterprise Suite-B 192 bit mode
    -- is supported. Since: 1.30.
    | AnotherNM80211ApSecurityFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> NM80211ApSecurityFlags -> ShowS
[NM80211ApSecurityFlags] -> ShowS
NM80211ApSecurityFlags -> String
(Int -> NM80211ApSecurityFlags -> ShowS)
-> (NM80211ApSecurityFlags -> String)
-> ([NM80211ApSecurityFlags] -> ShowS)
-> Show NM80211ApSecurityFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NM80211ApSecurityFlags -> ShowS
showsPrec :: Int -> NM80211ApSecurityFlags -> ShowS
$cshow :: NM80211ApSecurityFlags -> String
show :: NM80211ApSecurityFlags -> String
$cshowList :: [NM80211ApSecurityFlags] -> ShowS
showList :: [NM80211ApSecurityFlags] -> ShowS
Show, NM80211ApSecurityFlags -> NM80211ApSecurityFlags -> Bool
(NM80211ApSecurityFlags -> NM80211ApSecurityFlags -> Bool)
-> (NM80211ApSecurityFlags -> NM80211ApSecurityFlags -> Bool)
-> Eq NM80211ApSecurityFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NM80211ApSecurityFlags -> NM80211ApSecurityFlags -> Bool
== :: NM80211ApSecurityFlags -> NM80211ApSecurityFlags -> Bool
$c/= :: NM80211ApSecurityFlags -> NM80211ApSecurityFlags -> Bool
/= :: NM80211ApSecurityFlags -> NM80211ApSecurityFlags -> Bool
Eq)

instance P.Enum NM80211ApSecurityFlags where
    fromEnum :: NM80211ApSecurityFlags -> Int
fromEnum NM80211ApSecurityFlags
NM80211ApSecurityFlagsNone = Int
0
    fromEnum NM80211ApSecurityFlags
NM80211ApSecurityFlagsPairWep40 = Int
1
    fromEnum NM80211ApSecurityFlags
NM80211ApSecurityFlagsPairWep104 = Int
2
    fromEnum NM80211ApSecurityFlags
NM80211ApSecurityFlagsPairTkip = Int
4
    fromEnum NM80211ApSecurityFlags
NM80211ApSecurityFlagsPairCcmp = Int
8
    fromEnum NM80211ApSecurityFlags
NM80211ApSecurityFlagsGroupWep40 = Int
16
    fromEnum NM80211ApSecurityFlags
NM80211ApSecurityFlagsGroupWep104 = Int
32
    fromEnum NM80211ApSecurityFlags
NM80211ApSecurityFlagsGroupTkip = Int
64
    fromEnum NM80211ApSecurityFlags
NM80211ApSecurityFlagsGroupCcmp = Int
128
    fromEnum NM80211ApSecurityFlags
NM80211ApSecurityFlagsKeyMgmtPsk = Int
256
    fromEnum NM80211ApSecurityFlags
NM80211ApSecurityFlagsKeyMgmt8021x = Int
512
    fromEnum NM80211ApSecurityFlags
NM80211ApSecurityFlagsKeyMgmtSae = Int
1024
    fromEnum NM80211ApSecurityFlags
NM80211ApSecurityFlagsKeyMgmtOwe = Int
2048
    fromEnum NM80211ApSecurityFlags
NM80211ApSecurityFlagsKeyMgmtOweTm = Int
4096
    fromEnum NM80211ApSecurityFlags
NM80211ApSecurityFlagsKeyMgmtEapSuiteB192 = Int
8192
    fromEnum (AnotherNM80211ApSecurityFlags Int
k) = Int
k

    toEnum :: Int -> NM80211ApSecurityFlags
toEnum Int
0 = NM80211ApSecurityFlags
NM80211ApSecurityFlagsNone
    toEnum Int
1 = NM80211ApSecurityFlags
NM80211ApSecurityFlagsPairWep40
    toEnum Int
2 = NM80211ApSecurityFlags
NM80211ApSecurityFlagsPairWep104
    toEnum Int
4 = NM80211ApSecurityFlags
NM80211ApSecurityFlagsPairTkip
    toEnum Int
8 = NM80211ApSecurityFlags
NM80211ApSecurityFlagsPairCcmp
    toEnum Int
16 = NM80211ApSecurityFlags
NM80211ApSecurityFlagsGroupWep40
    toEnum Int
32 = NM80211ApSecurityFlags
NM80211ApSecurityFlagsGroupWep104
    toEnum Int
64 = NM80211ApSecurityFlags
NM80211ApSecurityFlagsGroupTkip
    toEnum Int
128 = NM80211ApSecurityFlags
NM80211ApSecurityFlagsGroupCcmp
    toEnum Int
256 = NM80211ApSecurityFlags
NM80211ApSecurityFlagsKeyMgmtPsk
    toEnum Int
512 = NM80211ApSecurityFlags
NM80211ApSecurityFlagsKeyMgmt8021x
    toEnum Int
1024 = NM80211ApSecurityFlags
NM80211ApSecurityFlagsKeyMgmtSae
    toEnum Int
2048 = NM80211ApSecurityFlags
NM80211ApSecurityFlagsKeyMgmtOwe
    toEnum Int
4096 = NM80211ApSecurityFlags
NM80211ApSecurityFlagsKeyMgmtOweTm
    toEnum Int
8192 = NM80211ApSecurityFlags
NM80211ApSecurityFlagsKeyMgmtEapSuiteB192
    toEnum Int
k = Int -> NM80211ApSecurityFlags
AnotherNM80211ApSecurityFlags Int
k

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

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

foreign import ccall "nm_802_11_ap_security_flags_get_type" c_nm_802_11_ap_security_flags_get_type :: 
    IO GType

instance B.Types.TypedObject NM80211ApSecurityFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_802_11_ap_security_flags_get_type

instance B.Types.BoxedFlags NM80211ApSecurityFlags

instance IsGFlag NM80211ApSecurityFlags

-- Flags 80211ApFlags
-- | 802.11 access point flags.
data NM80211ApFlags = 
      NM80211ApFlagsNone
    -- ^ access point has no special capabilities
    | NM80211ApFlagsPrivacy
    -- ^ access point requires authentication and
    -- encryption (usually means WEP)
    | NM80211ApFlagsWps
    -- ^ access point supports some WPS method
    | NM80211ApFlagsWpsPbc
    -- ^ access point supports push-button WPS
    | NM80211ApFlagsWpsPin
    -- ^ access point supports PIN-based WPS
    | AnotherNM80211ApFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> NM80211ApFlags -> ShowS
[NM80211ApFlags] -> ShowS
NM80211ApFlags -> String
(Int -> NM80211ApFlags -> ShowS)
-> (NM80211ApFlags -> String)
-> ([NM80211ApFlags] -> ShowS)
-> Show NM80211ApFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NM80211ApFlags -> ShowS
showsPrec :: Int -> NM80211ApFlags -> ShowS
$cshow :: NM80211ApFlags -> String
show :: NM80211ApFlags -> String
$cshowList :: [NM80211ApFlags] -> ShowS
showList :: [NM80211ApFlags] -> ShowS
Show, NM80211ApFlags -> NM80211ApFlags -> Bool
(NM80211ApFlags -> NM80211ApFlags -> Bool)
-> (NM80211ApFlags -> NM80211ApFlags -> Bool) -> Eq NM80211ApFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NM80211ApFlags -> NM80211ApFlags -> Bool
== :: NM80211ApFlags -> NM80211ApFlags -> Bool
$c/= :: NM80211ApFlags -> NM80211ApFlags -> Bool
/= :: NM80211ApFlags -> NM80211ApFlags -> Bool
Eq)

instance P.Enum NM80211ApFlags where
    fromEnum :: NM80211ApFlags -> Int
fromEnum NM80211ApFlags
NM80211ApFlagsNone = Int
0
    fromEnum NM80211ApFlags
NM80211ApFlagsPrivacy = Int
1
    fromEnum NM80211ApFlags
NM80211ApFlagsWps = Int
2
    fromEnum NM80211ApFlags
NM80211ApFlagsWpsPbc = Int
4
    fromEnum NM80211ApFlags
NM80211ApFlagsWpsPin = Int
8
    fromEnum (AnotherNM80211ApFlags Int
k) = Int
k

    toEnum :: Int -> NM80211ApFlags
toEnum Int
0 = NM80211ApFlags
NM80211ApFlagsNone
    toEnum Int
1 = NM80211ApFlags
NM80211ApFlagsPrivacy
    toEnum Int
2 = NM80211ApFlags
NM80211ApFlagsWps
    toEnum Int
4 = NM80211ApFlags
NM80211ApFlagsWpsPbc
    toEnum Int
8 = NM80211ApFlags
NM80211ApFlagsWpsPin
    toEnum Int
k = Int -> NM80211ApFlags
AnotherNM80211ApFlags Int
k

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

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

foreign import ccall "nm_802_11_ap_flags_get_type" c_nm_802_11_ap_flags_get_type :: 
    IO GType

instance B.Types.TypedObject NM80211ApFlags where
    glibType :: IO GType
glibType = IO GType
c_nm_802_11_ap_flags_get_type

instance B.Types.BoxedFlags NM80211ApFlags

instance IsGFlag NM80211ApFlags